forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-17 09:23:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

swarm/api: Rename Db -> Resource

Browse source
This commit is contained in:
lash 2018-01-22 05:13:28 +01:00
parent 11c3b4cae1
commit 80f539c217
4 changed files with 34 additions and 78 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
swarm/api/api.go
View file

@ -365,7 +365,7 @@ func (self *Api) BuildDirectoryTree(mhash string, nameresolver bool) (key storag
} }
// Look up mutable resource updates at specific periods and versions // Look up mutable resource updates at specific periods and versions
func (self *Api) DbLookup(name string, period uint32, version uint32) (storage.Key, []byte, error) { func (self *Api) ResourceLookup(name string, period uint32, version uint32) (storage.Key, []byte, error) {
var err error var err error
if version != 0 { if version != 0 {
if period == 0 { if period == 0 {
@ -391,22 +391,22 @@ func (self *Api) DbLookup(name string, period uint32, version uint32) (storage.K
return key, data, nil return key, data, nil
} }
func (self *Api) DbCreate(name string, frequency uint64) (err error) { func (self *Api) ResourceCreate(name string, frequency uint64) (err error) {
_, err = self.resource.NewResource(name, frequency) _, err = self.resource.NewResource(name, frequency)
return err return err
} }
func (self *Api) DbUpdate(name string, data []byte) (storage.Key, uint32, uint32, error) { func (self *Api) ResourceUpdate(name string, data []byte) (storage.Key, uint32, uint32, error) {
key, err := self.resource.Update(name, data) key, err := self.resource.Update(name, data)
period, _ := self.resource.GetLastPeriod(name) period, _ := self.resource.GetLastPeriod(name)
version, _ := self.resource.GetVersion(name) version, _ := self.resource.GetVersion(name)
return key, period, version, err return key, period, version, err
} }
func (self *Api) DbHashSize() int { func (self *Api) ResourceHashSize() int {
return self.resource.HashSize() return self.resource.HashSize()
} }
func (self *Api) DbIsValidated() bool { func (self *Api) ResourceIsValidated() bool {
return self.resource.IsValidated() return self.resource.IsValidated()
} }

71
swarm/api/http/server.go
View file

@ -291,7 +291,7 @@ func (s *Server) HandleDelete(w http.ResponseWriter, r *Request) {
fmt.Fprint(w, newKey) fmt.Fprint(w, newKey)
} }
func (s *Server) HandlePostDb(w http.ResponseWriter, r *Request) { func (s *Server) HandlePostResource(w http.ResponseWriter, r *Request) {
var outdata string var outdata string
if r.uri.Path != "" { if r.uri.Path != "" {
frequency, err := strconv.ParseUint(r.uri.Path, 10, 64) frequency, err := strconv.ParseUint(r.uri.Path, 10, 64)
@ -299,7 +299,7 @@ func (s *Server) HandlePostDb(w http.ResponseWriter, r *Request) {
s.BadRequest(w, r, fmt.Sprintf("Cannot parse frequency parameter: %v", err)) s.BadRequest(w, r, fmt.Sprintf("Cannot parse frequency parameter: %v", err))
return return
} }
err = s.api.DbCreate(r.uri.Addr, frequency) err = s.api.ResourceCreate(r.uri.Addr, frequency)
if err != nil { if err != nil {
s.Error(w, r, fmt.Errorf("Resource creation failed: %v", err)) s.Error(w, r, fmt.Errorf("Resource creation failed: %v", err))
return return
@ -333,13 +333,12 @@ func (s *Server) HandlePostDb(w http.ResponseWriter, r *Request) {
data, err := ioutil.ReadAll(r.Body) data, err := ioutil.ReadAll(r.Body)
if err != nil { if err != nil {
w.WriteHeader(http.StatusInternalServerError) s.Error(w, r, err)
return return
} }
_, _, _, err = s.api.DbUpdate(r.uri.Addr, data) _, _, _, err = s.api.ResourceUpdate(r.uri.Addr, data)
if err != nil { if err != nil {
w.Header().Add("Status", fmt.Sprintf("%d", http.StatusUnauthorized)) w.WriteHeader(http.StatusUnauthorized)
http.ServeContent(w, &r.Request, "", time.Now(), bytes.NewReader([]byte(err.Error())))
return return
} }
@ -351,15 +350,15 @@ func (s *Server) HandlePostDb(w http.ResponseWriter, r *Request) {
} }
// Retrieve mutable resource updates: // Retrieve mutable resource updates:
// bzz-db[-[immutable|-raw]]://<id> - get latest update // bzz-resource://<id> - get latest update
// bzz-db[-[immutable|-raw]]://<id>/<n> - get latest update on period n // bzz-resource://<id>/<n> - get latest update on period n
// bzz-db[-[immutable|-raw]]://<id>/<n>/<m> - get update version m of period n // bzz-resource://<id>/<n>/<m> - get update version m of period n
// <id> = ens name or hash // <id> = ens name or hash
func (s *Server) HandleGetDb(w http.ResponseWriter, r *Request) { func (s *Server) HandleGetResource(w http.ResponseWriter, r *Request) {
s.handleGetDb(w, r, r.uri.Addr) s.handleGetResource(w, r, r.uri.Addr)
} }
func (s *Server) handleGetDb(w http.ResponseWriter, r *Request, name string) { func (s *Server) handleGetResource(w http.ResponseWriter, r *Request, name string) {
var params []string var params []string
if len(r.uri.Path) > 0 { if len(r.uri.Path) > 0 {
params = strings.Split(r.uri.Path, "/") params = strings.Split(r.uri.Path, "/")
@ -368,19 +367,18 @@ func (s *Server) handleGetDb(w http.ResponseWriter, r *Request, name string) {
var period uint64 var period uint64
var version uint64 var version uint64
var data []byte var data []byte
var dataLength int
var err error var err error
now := time.Now() now := time.Now()
log.Debug("handlegetdb", "name", name) log.Debug("handlegetdb", "name", name)
switch len(params) { switch len(params) {
case 0: case 0:
updateKey, data, err = s.api.DbLookup(name, 0, 0) updateKey, data, err = s.api.ResourceLookup(name, 0, 0)
case 2: case 2:
version, err = strconv.ParseUint(params[1], 10, 32) version, err = strconv.ParseUint(params[1], 10, 32)
if err != nil { if err != nil {
break break
} }
updateKey, data, err = s.api.DbLookup(name, uint32(period), uint32(version)) updateKey, data, err = s.api.ResourceLookup(name, uint32(period), uint32(version))
case 1: case 1:
version, err = strconv.ParseUint(params[1], 10, 32) version, err = strconv.ParseUint(params[1], 10, 32)
if err != nil { if err != nil {
@ -390,7 +388,7 @@ func (s *Server) handleGetDb(w http.ResponseWriter, r *Request, name string) {
if err != nil { if err != nil {
break break
} }
updateKey, data, err = s.api.DbLookup(name, uint32(period), uint32(version)) updateKey, data, err = s.api.ResourceLookup(name, uint32(period), uint32(version))
default: default:
s.BadRequest(w, r, fmt.Sprintf("Invalid mutable resource request")) s.BadRequest(w, r, fmt.Sprintf("Invalid mutable resource request"))
return return
@ -399,35 +397,8 @@ func (s *Server) handleGetDb(w http.ResponseWriter, r *Request, name string) {
s.Error(w, r, fmt.Errorf("Mutable resource lookup failed: %v", err)) s.Error(w, r, fmt.Errorf("Mutable resource lookup failed: %v", err))
return return
} }
if !r.uri.DbRaw() { log.Debug("Found update", "key", updateKey)
w.Header().Set("Content-Type", "application/octet-stream") w.Header().Set("Content-Type", "application/octet-stream")
} else {
entry := api.ManifestEntry{
Hash: name,
Path: updateKey.Hex(),
ContentType: api.ManifestType,
Size: int64(dataLength),
ModTime: now,
Status: http.StatusOK,
}
mode := 0644
if s.api.DbIsValidated() {
mode |= (2 << 3) | 2
}
entry.Mode = int64(mode)
manifest := api.Manifest{
Entries: []api.ManifestEntry{
entry,
},
}
manifestJson, err := json.Marshal(manifest)
if err != nil {
s.Error(w, r, fmt.Errorf("Could not convert manifest to json: %v", err))
return
}
w.Header().Set("Content-Type", api.ManifestType)
data = []byte(manifestJson)
}
http.ServeContent(w, &r.Request, "", now, bytes.NewReader(data)) http.ServeContent(w, &r.Request, "", now, bytes.NewReader(data))
} }
@ -498,7 +469,7 @@ func (s *Server) HandleGet(w http.ResponseWriter, r *Request) {
err = json.Unmarshal(b, m) err = json.Unmarshal(b, m)
if len(m.Entries) > 0 { if len(m.Entries) > 0 {
if m.Entries[0].ContentType == api.ResourceContentType { if m.Entries[0].ContentType == api.ResourceContentType {
s.handleGetDb(w, r, m.Entries[0].Path) s.handleGetResource(w, r, m.Entries[0].Path)
return return
} }
} }
@ -755,8 +726,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
case "POST": case "POST":
if uri.Raw() || uri.DeprecatedRaw() { if uri.Raw() || uri.DeprecatedRaw() {
s.HandlePostRaw(w, req) s.HandlePostRaw(w, req)
} else if uri.Db() { } else if uri.Resource() {
s.HandlePostDb(w, req) s.HandlePostResource(w, req)
} else { } else {
s.HandlePostFiles(w, req) s.HandlePostFiles(w, req)
} }
@ -783,8 +754,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
case "GET": case "GET":
if uri.Db() || uri.DbRaw() { if uri.Resource() {
s.HandleGetDb(w, req) s.HandleGetResource(w, req)
return return
} }

21
swarm/api/http/server_test.go
View file

@ -53,7 +53,7 @@ func TestBzzGetDb(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
url := fmt.Sprintf("%s/bzz-db:/%x/42", srv.URL, keybytes) url := fmt.Sprintf("%s/bzz-resource:/%x/42", srv.URL, keybytes)
resp, err := http.Post(url, "application/octet-stream", bytes.NewReader(databytes)) resp, err := http.Post(url, "application/octet-stream", bytes.NewReader(databytes))
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -67,7 +67,7 @@ func TestBzzGetDb(t *testing.T) {
} }
log.Debug("Create", "status", resp.Status, "body", manifesthash) log.Debug("Create", "status", resp.Status, "body", manifesthash)
url = fmt.Sprintf("%s/bzz-db:/%x", srv.URL, keybytes) url = fmt.Sprintf("%s/bzz-resource:/%x", srv.URL, keybytes)
data := []byte("foo") data := []byte("foo")
resp, err = http.Post(url, "application/octet-stream", bytes.NewReader(data)) resp, err = http.Post(url, "application/octet-stream", bytes.NewReader(data))
if err != nil { if err != nil {
@ -88,9 +88,9 @@ func TestBzzGetDb(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
log.Debug("Manifest", "status", resp.Status, "body", fmt.Sprintf("%s", b)) log.Debug("Get raw", "status", resp.Status, "body", fmt.Sprintf("%s", b))
url = fmt.Sprintf("%s/bzz-db-raw:/%x", srv.URL, keybytes) url = fmt.Sprintf("%s/bzz-resource:/%x", srv.URL, keybytes)
resp, err = http.Get(url) resp, err = http.Get(url)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
@ -99,18 +99,7 @@ func TestBzzGetDb(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
log.Debug("Get raw", "status", resp.Status) log.Debug("Get resource", "status", resp.Status, "data", b)
url = fmt.Sprintf("%s/bzz-db:/%x", srv.URL, keybytes)
resp, err = http.Get(url)
if err != nil {
t.Fatal(err)
}
b, err = ioutil.ReadAll(resp.Body)
if err != nil {
t.Fatal(err)
}
log.Debug("Get manifest", "status", resp.Status)
} }

10
swarm/api/uri.go
View file

@ -69,7 +69,7 @@ func Parse(rawuri string) (*URI, error) {
// check the scheme is valid // check the scheme is valid
switch uri.Scheme { switch uri.Scheme {
case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzz-hash", "bzzr", "bzzi", "bzz-db", "bzz-db-raw": case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzz-hash", "bzzr", "bzzi", "bzz-resource":
default: default:
return nil, fmt.Errorf("unknown scheme %q", u.Scheme) return nil, fmt.Errorf("unknown scheme %q", u.Scheme)
} }
@ -92,12 +92,8 @@ func Parse(rawuri string) (*URI, error) {
return uri, nil return uri, nil
} }
func (u *URI) Db() bool { func (u *URI) Resource() bool {
return u.Scheme == "bzz-db" return u.Scheme == "bzz-resource"
}
func (u *URI) DbRaw() bool {
return u.Scheme == "bzz-db-raw"
} }
func (u *URI) Raw() bool { func (u *URI) Raw() bool {