Merge pull request #68 from jllucas/client

Client

api/apihttp/apihttp.go

@@ -23,12 +23,12 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
+
 	"github.com/bbva/qed/log"
 	"github.com/bbva/qed/metrics"
 	"github.com/bbva/qed/protocol"
 	"github.com/bbva/qed/raftwal"
-
-	"github.com/prometheus/client_golang/prometheus"
 )
 
 // HealthCheckResponse contains the response from HealthCheckHandler.
@@ -316,12 +316,14 @@ func AuthHandlerMiddleware(handler http.HandlerFunc) http.HandlerFunc {
 //	/events -> Add
 //	/proofs/membership -> Membership
 func NewApiHttp(balloon raftwal.RaftBalloonApi) *http.ServeMux {
+
 	api := http.NewServeMux()
 	api.HandleFunc("/health-check", AuthHandlerMiddleware(HealthCheckHandler))
 	api.HandleFunc("/events", AuthHandlerMiddleware(Add(balloon)))
 	api.HandleFunc("/proofs/membership", AuthHandlerMiddleware(Membership(balloon)))
 	api.HandleFunc("/proofs/digest-membership", AuthHandlerMiddleware(DigestMembership(balloon)))
 	api.HandleFunc("/proofs/incremental", AuthHandlerMiddleware(Incremental(balloon)))
+	api.HandleFunc("/info/shards", AuthHandlerMiddleware(InfoShardsHandler(balloon)))
 
 	return api
 }
@@ -360,3 +362,32 @@ func LogHandler(handle http.Handler) http.HandlerFunc {
 		}
 	}
 }
+
+func InfoShardsHandler(balloon raftwal.RaftBalloonApi) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != "GET" {
+			w.Header().Set("Allow", "GET")
+			w.WriteHeader(http.StatusMethodNotAllowed)
+			return
+		}
+
+		var scheme string
+		if r.TLS != nil {
+			scheme = "https://"
+		} else {
+			scheme = "http://"
+		}
+
+		info := balloon.Info()
+		info["URIScheme"] = scheme
+
+		out, err := json.Marshal(info)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write(out)
+	}
+}

api/apihttp/apihttp_test.go

@@ -47,47 +47,51 @@ func (b fakeRaftBalloon) Add(event []byte) (*balloon.Snapshot, error) {
 	return &balloon.Snapshot{hashing.Digest{0x02}, hashing.Digest{0x00}, hashing.Digest{0x01}, 0}, nil
 }
 
-func (b fakeRaftBalloon) Join(nodeID, addr string) error {
+func (b fakeRaftBalloon) Join(nodeID, addr string, metadata map[string]string) error {
 	return nil
 }
 
 func (b fakeRaftBalloon) QueryDigestMembership(keyDigest hashing.Digest, version uint64) (*balloon.MembershipProof, error) {
 	return &balloon.MembershipProof{
-		true,
-		visitor.NewFakeVerifiable(true),
-		visitor.NewFakeVerifiable(true),
-		1,
-		1,
-		2,
-		keyDigest,
-		hashing.NewFakeXorHasher(),
+		Exists:         true,
+		HyperProof:     visitor.NewFakeVerifiable(true),
+		HistoryProof:   visitor.NewFakeVerifiable(true),
+		CurrentVersion: 1,
+		QueryVersion:   1,
+		ActualVersion:  2,
+		KeyDigest:      keyDigest,
+		Hasher:         hashing.NewFakeXorHasher(),
 	}, nil
 }
 
 func (b fakeRaftBalloon) QueryMembership(event []byte, version uint64) (*balloon.MembershipProof, error) {
 	hasher := hashing.NewFakeXorHasher()
 	return &balloon.MembershipProof{
-		true,
-		visitor.NewFakeVerifiable(true),
-		visitor.NewFakeVerifiable(true),
-		1,
-		1,
-		2,
-		hasher.Do(event),
-		hasher,
+		Exists:         true,
+		HyperProof:     visitor.NewFakeVerifiable(true),
+		HistoryProof:   visitor.NewFakeVerifiable(true),
+		CurrentVersion: 1,
+		QueryVersion:   1,
+		ActualVersion:  2,
+		KeyDigest:      hasher.Do(event),
+		Hasher:         hasher,
 	}, nil
 }
 
 func (b fakeRaftBalloon) QueryConsistency(start, end uint64) (*balloon.IncrementalProof, error) {
 	ip := balloon.IncrementalProof{
-		2,
-		8,
-		visitor.AuditPath{"0|0": hashing.Digest{0x00}},
-		hashing.NewFakeXorHasher(),
+		Start:     2,
+		End:       8,
+		AuditPath: visitor.AuditPath{"0|0": hashing.Digest{0x00}},
+		Hasher:    hashing.NewFakeXorHasher(),
 	}
 	return &ip, nil
 }
 
+func (b fakeRaftBalloon) Info() map[string]interface{} {
+	return make(map[string]interface{})
+}
+
 func TestHealthCheckHandler(t *testing.T) {
 	// Create a request to pass to our handler. We don't have any query parameters for now, so we'll
 	// pass 'nil' as the third parameter.
@@ -385,7 +389,7 @@ func BenchmarkApiAdd(b *testing.B) {
 	r, clean := newNodeBench(b, 1)
 	defer clean()
 
-	err := r.Open(true)
+	err := r.Open(true, map[string]string{"foo": "bar"})
 	assert.NoError(b, err)
 
 	handler := Add(r)

api/mgmthttp/mgmthttp.go

@@ -34,34 +34,46 @@ func NewMgmtHttp(raftBalloon raftwal.RaftBalloonApi) *http.ServeMux {
 
 func joinHandle(raftBalloon raftwal.RaftBalloonApi) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		m := map[string]string{}
+		body := make(map[string]interface{})
 
-		if err := json.NewDecoder(r.Body).Decode(&m); err != nil {
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
 
-		if len(m) != 2 {
+		if len(body) != 3 {
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
 
-		remoteAddr, ok := m["addr"]
+		remoteAddr, ok := body["addr"].(string)
 		if !ok {
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
 
-		nodeID, ok := m["id"]
+		nodeID, ok := body["id"].(string)
 		if !ok {
 			w.WriteHeader(http.StatusBadRequest)
 			return
 		}
 
-		if err := raftBalloon.Join(nodeID, remoteAddr); err != nil {
+		m, ok := body["metadata"].(map[string]interface{})
+		if !ok {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		// TO IMPROVE: use map[string]interface{} for nested metadata.
+		metadata := make(map[string]string)
+		for k, v := range m {
+			metadata[k] = v.(string)
+		}
+
+		if err := raftBalloon.Join(nodeID, remoteAddr, metadata); err != nil {
 			w.WriteHeader(http.StatusInternalServerError)
 			return
 		}
 
+		w.WriteHeader(http.StatusOK)
 	}
 }

balloon/history/proof.go

@@ -122,7 +122,6 @@ func (p IncrementalProof) Verify(startDigest, endDigest hashing.Digest) (correct
 	// visit the pruned trees
 	startRecomputed := startPruned.PostOrder(computeHash).(hashing.Digest)
 	endRecomputed := endPruned.PostOrder(computeHash).(hashing.Digest)
-
 	return bytes.Equal(startRecomputed, startDigest) && bytes.Equal(endRecomputed, endDigest)
 
 }