implement api.Get and change js api to separate out register

bzz/api.go

@@ -71,13 +71,20 @@ func (self *Api) Stop() {
 
 // Get uses iterative manifest retrieval and prefix matching
 // to resolve path to content using dpa retrieve
-func (self *Api) Get(bzzpath string) (string, error) {
+func (self *Api) Get(bzzpath string) (content []byte, mimeType string, status int, size int, err error) {
-	return "", nil
+	var reader SectionReader
+	reader, mimeType, status, err = self.getPath("/" + bzzpath)
+	content = make([]byte, reader.Size())
+	size, err = reader.Read(content)
+	if err == io.EOF {
+		err = nil
+	}
+	return
 }
 
 // Put provides singleton manifest creation and optional name registration
 // on top of dpa store
-func (self *Api) Put(content, contentType, address, domain string) (string, error) {
+func (self *Api) Put(content, contentType string) (string, error) {
 	sr := io.NewSectionReader(strings.NewReader(content), 0, int64(len(content)))
 	wg := &sync.WaitGroup{}
 	key, err := self.dpa.Store(sr, wg)
@@ -103,7 +110,7 @@ func (self *Api) Download(bzzpath, localpath string) (string, error) {
 // Upload replicates a local directory as a manifest file and uploads it
 // using dpa store
 // TODO: localpath should point to a manifest
-func (self *Api) Upload(localpath, address, domain string) (string, error) {
+func (self *Api) Upload(localpath string) (string, error) {
 	var files []string
 	localpath = common.ExpandHomePath(localpath)
 	dpaLogger.Debugf("uploading '%s'", localpath)
@@ -165,9 +172,13 @@ func (self *Api) Upload(localpath, address, domain string) (string, error) {
 	return fmt.Sprintf("%064x", key), err2
 }
 
+func (self *Api) Register(sender, address, domain string) (err error) {
+	return
+}
+
 type errResolve error
 
-func (self *Api) resolveHost(hostport string) (contentHash Key, errR errResolve) {
+func (self *Api) resolve(hostport string) (contentHash Key, errR errResolve) {
 	var host, port string
 	var err error
 	host, port, err = net.SplitHostPort(hostport)
@@ -212,7 +223,7 @@ func (self *Api) getPath(uri string) (reader SectionReader, mimeType string, sta
 
 	//resolving host and port
 	var key Key
-	key, err = self.resolveHost(hostPort)
+	key, err = self.resolve(hostPort)
 	if err != nil {
 		return
 	}

bzz/httpaccess.go

@@ -76,7 +76,7 @@ func handler(w http.ResponseWriter, r *http.Request, api *Api) {
 			dpaLogger.Debugf("Swarm: Raw GET request '%s' received", uri)
 
 			// resolving host
-			key, err := api.resolveHost(path)
+			key, err := api.resolve(path)
 			if err != nil {
 				dpaLogger.Debugf("Swarm: %v", err)
 				http.Error(w, err.Error(), http.StatusBadRequest)

bzz/js_api.go

@@ -16,6 +16,7 @@ func NewJSApi(vm *jsre.JSRE, api *Api) (jsapi *JSApi) {
 	vm.Set("bzz", struct{}{})
 	t, _ := vm.Get("bzz")
 	o := t.Object()
+	o.Set("register", jsapi.register)
 	o.Set("download", jsapi.download)
 	o.Set("upload", jsapi.upload)
 	o.Set("get", jsapi.get)
@@ -29,6 +30,38 @@ type JSApi struct {
 	api *Api
 }
 
+func (self *JSApi) register(call otto.FunctionCall) otto.Value {
+	if len(call.ArgumentList) != 2 {
+		fmt.Println("requires 3 arguments: bzz.register(address, contenthash, domain)")
+		return otto.UndefinedValue()
+	}
+
+	var err error
+	var sender, contenthash, domain string
+	sender, err = call.Argument(0).ToString()
+	if err != nil {
+		fmt.Println(err)
+		return otto.UndefinedValue()
+	}
+	contenthash, err = call.Argument(1).ToString()
+	if err != nil {
+		fmt.Println(err)
+		return otto.UndefinedValue()
+	}
+	domain, err = call.Argument(2).ToString()
+	if err != nil {
+		fmt.Println(err)
+		return otto.UndefinedValue()
+	}
+
+	err = self.api.Register(sender, contenthash, domain)
+	if err != nil {
+		fmt.Println(err)
+		return otto.FalseValue()
+	}
+	return otto.TrueValue()
+}
+
 func (self *JSApi) get(call otto.FunctionCall) otto.Value {
 	if len(call.ArgumentList) != 1 {
 		fmt.Println("requires 1 argument: bzz.get(path)")
@@ -36,31 +69,41 @@ func (self *JSApi) get(call otto.FunctionCall) otto.Value {
 	}
 
 	var err error
-	var bzzpath, res string
+	var bzzpath string
 	bzzpath, err = call.Argument(0).ToString()
 	if err != nil {
 		fmt.Println(err)
 		return otto.UndefinedValue()
 	}
 
-	res, err = self.api.Get(bzzpath)
+	var content []byte
+	var mimeType string
+	var status, size int
+	content, mimeType, status, size, err = self.api.Get(bzzpath)
 	if err != nil {
 		fmt.Println(err)
 		return otto.UndefinedValue()
 	}
 
-	v, _ := call.Otto.ToValue(res)
+	obj := map[string]string{
+		"content":     string(content),
+		"contentType": mimeType,
+		"status":      fmt.Sprintf("%v", status),
+		"size":        fmt.Sprintf("%v", size),
+	}
+
+	v, _ := call.Otto.ToValue(obj)
 	return v
 }
 
 func (self *JSApi) put(call otto.FunctionCall) otto.Value {
-	if len(call.ArgumentList) != 2 && len(call.ArgumentList) != 4 {
+	if len(call.ArgumentList) != 2 {
-		fmt.Println("requires 2 or 4 arguments: bzz.put(content, content-type[, address, domain])")
+		fmt.Println("requires 2 arguments: bzz.put(content, content-type)")
 		return otto.UndefinedValue()
 	}
 
 	var err error
-	var res, content, contentType, address, domain string
+	var res, content, contentType string
 	content, err = call.Argument(0).ToString()
 	if err != nil {
 		fmt.Println(err)
@@ -71,20 +114,8 @@ func (self *JSApi) put(call otto.FunctionCall) otto.Value {
 		fmt.Println(err)
 		return otto.UndefinedValue()
 	}
-	if len(call.ArgumentList) > 2 {
-		address, err = call.Argument(2).ToString()
-		if err != nil {
-			fmt.Println(err)
-			return otto.UndefinedValue()
-		}
-		domain, err = call.Argument(3).ToString()
-		if err != nil {
-			fmt.Println(err)
-			return otto.UndefinedValue()
-		}
-	}
 
-	res, err = self.api.Put(content, contentType, address, domain)
+	res, err = self.api.Put(content, contentType)
 	if err != nil {
 		fmt.Println(err)
 		return otto.UndefinedValue()
@@ -124,32 +155,20 @@ func (self *JSApi) download(call otto.FunctionCall) otto.Value {
 }
 
 func (self *JSApi) upload(call otto.FunctionCall) otto.Value {
-	if len(call.ArgumentList) != 1 && len(call.ArgumentList) != 3 {
+	if len(call.ArgumentList) != 1 {
-		fmt.Println("requires 1 or 3 arguments: bzz.put(localpath[, address, domain])")
+		fmt.Println("requires 1 arguments: bzz.put(localpath)")
 		return otto.UndefinedValue()
 	}
 
 	var err error
-	var localpath, address, domain, res string
+	var localpath, res string
 	localpath, err = call.Argument(0).ToString()
 	if err != nil {
 		fmt.Println(err)
 		return otto.UndefinedValue()
 	}
-	if len(call.ArgumentList) > 1 {
-		address, err = call.Argument(1).ToString()
-		if err != nil {
-			fmt.Println(err)
-			return otto.UndefinedValue()
-		}
-		domain, err = call.Argument(2).ToString()
-		if err != nil {
-			fmt.Println(err)
-			return otto.UndefinedValue()
-		}
-	}
 
-	res, err = self.api.Upload(localpath, address, domain)
+	res, err = self.api.Upload(localpath)
 	if err != nil {
 		fmt.Println(err)
 		return otto.UndefinedValue()