forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-22 20:56:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

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

Browse source
This commit is contained in:
zelig 2015-05-28 11:29:12 +01:00
parent 7355e92dcc
commit c031c4b925
3 changed files with 72 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
bzz/api.go
View file

@ -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) {
return "", nil
func (self *Api) Get(bzzpath string) (content []byte, mimeType string, status int, size int, err error) {
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
}

2
bzz/httpaccess.go
View file

@ -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)

89
bzz/js_api.go
View file

@ -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 {
fmt.Println("requires 2 or 4 arguments: bzz.put(content, content-type[, address, domain])")
if len(call.ArgumentList) != 2 {
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 {
fmt.Println("requires 1 or 3 arguments: bzz.put(localpath[, address, domain])")
if len(call.ArgumentList) != 1 {
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()