From 81ec1f9694f84178895c134634d0702eae7d8e6f Mon Sep 17 00:00:00 2001
From: lash <dev@holbrook.no>
Date: Fri, 19 Jan 2018 17:08:04 +0100
Subject: [PATCH] swarm/api: Add all lookup types + public getblock

---
 swarm/api/api.go          | 19 +++++++++++++++++--
 swarm/api/http/server.go  | 35 +++++++++++++++++++++++++++++------
 swarm/api/uri.go          |  6 +++++-
 swarm/storage/resource.go |  8 ++++----
 4 files changed, 55 insertions(+), 13 deletions(-)

diff --git a/swarm/api/api.go b/swarm/api/api.go
index cc10fa2134..827e89ad1d 100644
--- a/swarm/api/api.go
+++ b/swarm/api/api.go
@@ -364,8 +364,23 @@ func (self *Api) BuildDirectoryTree(mhash string, nameresolver bool) (key storag
 	return key, manifestEntryMap, nil
 }
 
-func (self *Api) DbLookupLatest(name string) (io.ReadSeeker, error) {
-	_, err := self.resource.LookupLatest(name, true)
+// Look up mutable resource updates at specific periods and versions
+func (self *Api) DbLookup(name string, period uint32, version uint32) (io.ReadSeeker, error) {
+	var err error
+	if version != 0 {
+		if period == 0 {
+			currentblocknumber, err := self.resource.GetBlock()
+			if err != nil {
+				return nil, fmt.Errorf("Could not determine latest block: %v", err)
+			}
+			period = self.resource.BlockToPeriod(name, currentblocknumber)
+		}
+		_, err = self.resource.LookupVersion(name, period, version, true)
+	} else if period != 0 {
+		_, err = self.resource.LookupHistorical(name, period, true)
+	} else {
+		_, err = self.resource.LookupLatest(name, true)
+	}
 	if err != nil {
 		return nil, err
 	}
diff --git a/swarm/api/http/server.go b/swarm/api/http/server.go
index 440cb04cb8..bcdb4d2e59 100644
--- a/swarm/api/http/server.go
+++ b/swarm/api/http/server.go
@@ -320,25 +320,48 @@ func (s *Server) HandlePostDb(w http.ResponseWriter, r *Request) {
 	w.WriteHeader(http.StatusOK)
 }
 
+// Retrieve mutable resource updates:
+// bzz-db[-[immutable|-raw]]://<id> - get latest update
+// bzz-db[-[immutable|-raw]]://<id>/<n> - get latest update on period n
+// bzz-db[-[immutable|-raw]]://<id>/<n>/<m> - get update version m of period n
 func (s *Server) HandleGetDb(w http.ResponseWriter, r *Request) {
 	w.Header().Set("Content-Type", "application/octet-stream")
 
+	key, err := s.api.Resolve(r.uri)
+	if err != nil {
+		s.Error(w, r, fmt.Errorf("error resolving %s: %s", r.uri.Addr, err))
+		return
+	}
+	_ = key
+
 	var params []string
 	if len(r.uri.Path) > 0 {
 		params = strings.Split(r.uri.Path, "/")
 	}
 	switch len(params) {
 	case 0:
-		data, err := s.api.DbLookupLatest(r.uri.Addr)
-		if err != nil {
-			w.WriteHeader(http.StatusInternalServerError)
-			break
-		}
-		http.ServeContent(w, &r.Request, "", time.Now(), data)
+		data, err := s.api.DbLookup(r.uri.Addr)
+		break
+	case 2:
+		strconv.ParseUint(params[1], 10, 32)
+	case 1:
+		strconv.ParseUint(params[0], 10, 32)
 		break
 	default:
 		w.WriteHeader(http.StatusBadRequest)
+		err = "params 0-2"
 	}
+	if err != nil {
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+	wrappedData := wrapDbContent(data, s.uri.Scheme)
+	http.ServeContent(w, &r.Request, "", time.Now(), data)
+
+}
+
+func wrapDbContent(data io.Reader, scheme *string) io.Reader {
+
 }
 
 // HandleGet handles a GET request to
diff --git a/swarm/api/uri.go b/swarm/api/uri.go
index 9b786045c7..c7a929f0f2 100644
--- a/swarm/api/uri.go
+++ b/swarm/api/uri.go
@@ -69,7 +69,7 @@ func Parse(rawuri string) (*URI, error) {
 
 	// check the scheme is valid
 	switch uri.Scheme {
-	case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzz-hash", "bzzr", "bzzi", "bzz-db":
+	case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzz-hash", "bzzr", "bzzi", "bzz-db", "bzz-db-raw":
 	default:
 		return nil, fmt.Errorf("unknown scheme %q", u.Scheme)
 	}
@@ -96,6 +96,10 @@ func (u *URI) Db() bool {
 	return u.Scheme == "bzz-db"
 }
 
+func (u *URI) DbRaw() bool {
+	return u.Scheme == "bzz-db-raw"
+}
+
 func (u *URI) Raw() bool {
 	return u.Scheme == "bzz-raw"
 }
diff --git a/swarm/storage/resource.go b/swarm/storage/resource.go
index 1e00c1dcf7..33845da40d 100644
--- a/swarm/storage/resource.go
+++ b/swarm/storage/resource.go
@@ -231,7 +231,7 @@ func (self *ResourceHandler) NewResource(name string, frequency uint64) (*resour
 	}
 
 	// get our blockheight at this time
-	currentblock, err := self.getBlock()
+	currentblock, err := self.GetBlock()
 	if err != nil {
 		return nil, err
 	}
@@ -310,7 +310,7 @@ func (self *ResourceHandler) LookupLatest(name string, refresh bool) (*resource,
 	if err != nil {
 		return nil, err
 	}
-	currentblock, err := self.getBlock()
+	currentblock, err := self.GetBlock()
 	if err != nil {
 		return nil, err
 	}
@@ -492,7 +492,7 @@ func (self *ResourceHandler) Update(name string, data []byte) (Key, error) {
 	}
 
 	// get our blockheight at this time and the next block of the update period
-	currentblock, err := self.getBlock()
+	currentblock, err := self.GetBlock()
 	if err != nil {
 		return nil, err
 	}
@@ -560,7 +560,7 @@ func (self *ResourceHandler) Close() {
 	self.ChunkStore.Close()
 }
 
-func (self *ResourceHandler) getBlock() (uint64, error) {
+func (self *ResourceHandler) GetBlock() (uint64, error) {
 	// get the block height and convert to uint64
 	var currentblock string
 	err := self.rpcClient.Call(&currentblock, "eth_blockNumber")