network: Add API for Capabilities (ethersphere#1675)

* network: Add API for Capabilities

Author: nolash

network/capability/api.go

@@ -0,0 +1,61 @@
+// Copyright 2019 The Swarm authors
+// This file is part of the swarm library.
+//
+// The swarm library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The swarm library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the swarm library. If not, see <http://www.gnu.org/licenses/>.
+
+package capability
+
+import (
+	"fmt"
+
+	"github.com/ethersphere/swarm/log"
+)
+
+// API abstracts RPC API access to capabilities controls
+// will in the future provide notifications of capability changes
+type API struct {
+	*Capabilities
+}
+
+// NetAPI creates new API abstraction around provided Capabilities object
+func NewAPI(c *Capabilities) *API {
+	return &API{
+		Capabilities: c,
+	}
+}
+
+// RegisterCapability adds the given capability object to the Capabilities collection
+// If the Capability is already registered an error will be returned
+func (a *API) RegisterCapability(cp *Capability) error {
+	log.Debug("Registering capability", "cp", cp)
+	return a.Add(cp)
+}
+
+// IsRegisteredCapability returns true if a Capability with the given id is registered
+func (a *API) IsRegisteredCapability(id CapabilityID) (bool, error) {
+	return a.Get(id) != nil, nil
+}
+
+// MatchCapability returns true if the Capability flag at the given index is set
+// Fails with error if the Capability is not registered, or if the index is out of bounds
+func (a *API) MatchCapability(id CapabilityID, idx int) (bool, error) {
+	c := a.Get(id)
+	if c == nil {
+		return false, fmt.Errorf("Capability %d not registered", id)
+	}
+	if idx > len(c.Cap)-1 {
+		return false, fmt.Errorf("Capability %d idx %d out of range", id, idx)
+	}
+	return c.Cap[idx], nil
+}

network/capability/api_test.go

@@ -0,0 +1,73 @@
+// Copyright 2019 The Swarm authors
+// This file is part of the swarm library.
+//
+// The swarm library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The swarm library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the swarm library. If not, see <http://www.gnu.org/licenses/>.
+
+package capability
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+// TestAPI tests that API calls stores and reports correctly
+func TestAPI(t *testing.T) {
+
+	// Initialize capability
+	caps := NewCapabilities()
+
+	// Set up faux rpc
+	rpcSrv := rpc.NewServer()
+	rpcClient := rpc.DialInProc(rpcSrv)
+	rpcSrv.RegisterName("cap", NewAPI(caps))
+
+	// create the capability and register it
+	c1 := NewCapability(42, 13)
+	c1.Set(9)
+	err := rpcClient.Call(nil, "cap_registerCapability", c1)
+	if err != nil {
+		t.Fatalf("Register fail: %v", err)
+	}
+
+	// check that the capability is registered
+	c1.Set(9)
+	err = rpcClient.Call(nil, "cap_isRegisteredCapability", c1.Id)
+	if err != nil {
+		t.Fatalf("Register fail: %v", err)
+	}
+
+	// check that isRegistered doesn't give false positives
+	c2 := CapabilityID(13)
+	err = rpcClient.Call(nil, "cap_isRegisteredCapability", c2)
+	if err != nil {
+		t.Fatalf("Register fail: %v", err)
+	}
+
+	// check that correct values have been stored
+	var r bool
+	err = rpcClient.Call(&r, "cap_matchCapability", c1.Id, 9)
+	if err != nil {
+		t.Fatalf("isSet fail: %v", err)
+	} else if !r {
+		t.Fatalf("isSet should be false, got %v", r)
+	}
+
+	err = rpcClient.Call(&r, "cap_matchCapability", c1.Id, 1)
+	if err != nil {
+		t.Fatalf("isSet fail: %v", err)
+	} else if r {
+		t.Fatalf("isSet should be true, got %v", r)
+	}
+}

network/adaptive.go renamed to network/capability/capability.go

@@ -1,4 +1,20 @@
-package network
+// Copyright 2019 The Swarm authors
+// This file is part of the swarm library.
+//
+// The swarm library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The swarm library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the swarm library. If not, see <http://www.gnu.org/licenses/>.
+
+package capability
 
 import (
 	"fmt"
@@ -95,7 +111,7 @@ func NewCapabilities() *Capabilities {
 }
 
 // adds a capability to the Capabilities collection
-func (c *Capabilities) add(cp *Capability) error {
+func (c *Capabilities) Add(cp *Capability) error {
 	if _, ok := c.idx[cp.Id]; ok {
 		return fmt.Errorf("Capability id %d already registered", cp.Id)
 	}
@@ -108,7 +124,7 @@ func (c *Capabilities) add(cp *Capability) error {
 
 // gets the capability with the specified module id
 // returns nil if the id doesn't exist
-func (c *Capabilities) get(id CapabilityID) *Capability {
+func (c *Capabilities) Get(id CapabilityID) *Capability {
 	idx, ok := c.idx[id]
 	if !ok {
 		return nil
@@ -164,7 +180,7 @@ func (c *Capabilities) DecodeRLP(s *rlp.Stream) error {
 		}
 
 		// Add the entry to the Capabilities array
-		c.add(&cap)
+		c.Add(&cap)
 	}
 
 	return nil

network/adaptive_test.go renamed to network/capability/capability_test.go

@@ -1,4 +1,20 @@
-package network
+// Copyright 2019 The Swarm authors
+// This file is part of the swarm library.
+//
+// The swarm library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The swarm library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the swarm library. If not, see <http://www.gnu.org/licenses/>.
+
+package capability
 
 import (
 	"bytes"
@@ -63,21 +79,21 @@ func TestCapabilitiesControl(t *testing.T) {
 
 	// Register module. Should succeed
 	c1 := NewCapability(1, 16)
-	err := caps.add(c1)
+	err := caps.Add(c1)
 	if err != nil {
 		t.Fatalf("RegisterCapabilityModule fail: %v", err)
 	}
 
 	// Fail if capability id already exists
 	c2 := NewCapability(1, 1)
-	err = caps.add(c2)
+	err = caps.Add(c2)
 	if err == nil {
 		t.Fatalf("Expected RegisterCapabilityModule call with existing id to fail")
 	}
 
 	// More than one capabilities flag vector should be possible
 	c3 := NewCapability(2, 1)
-	err = caps.add(c3)
+	err = caps.Add(c3)
 	if err != nil {
 		t.Fatalf("RegisterCapabilityModule (second) fail: %v", err)
 	}
@@ -105,8 +121,8 @@ func TestCapabilitiesString(t *testing.T) {
 	}
 
 	caps := NewCapabilities()
-	caps.add(c1)
-	caps.add(c2)
+	caps.Add(c1)
+	caps.Add(c2)
 
 	correctString := "42:001,666:100010101"
 	if correctString != caps.String() {
@@ -122,12 +138,12 @@ func TestCapabilitiesRLP(t *testing.T) {
 		Id:  42,
 		Cap: []bool{true, false, true},
 	}
-	c.add(cap1)
+	c.Add(cap1)
 	cap2 := &Capability{
 		Id:  666,
 		Cap: []bool{true, false, true, false, true, true, false, false, true},
 	}
-	c.add(cap2)
+	c.Add(cap2)
 	buf := bytes.NewBuffer(nil)
 	err := rlp.Encode(buf, &c)
 	if err != nil {
@@ -140,15 +156,15 @@ func TestCapabilitiesRLP(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cap1Restored := cRestored.get(cap1.Id)
+	cap1Restored := cRestored.Get(cap1.Id)
 	if cap1Restored.Id != cap1.Id {
 		t.Fatalf("cap 1 id not correct, expected %d, got %d", cap1.Id, cap1Restored.Id)
 	}
 	if !cap1.IsSameAs(cap1Restored) {
 		t.Fatalf("cap 1 caps not correct, expected %v, got %v", cap1.Cap, cap1Restored.Cap)
 	}
 
-	cap2Restored := cRestored.get(cap2.Id)
+	cap2Restored := cRestored.Get(cap2.Id)
 	if cap2Restored.Id != cap2.Id {
 		t.Fatalf("cap 1 id not correct, expected %d, got %d", cap2.Id, cap2Restored.Id)
 	}

network/protocol.go

@@ -28,6 +28,7 @@ import (
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/ethersphere/swarm/log"
+	"github.com/ethersphere/swarm/network/capability"
 	"github.com/ethersphere/swarm/p2p/protocols"
 	"github.com/ethersphere/swarm/state"
 )
@@ -40,8 +41,8 @@ var (
 	capabilitiesStorer        = 15
 
 	// temporary presets to emulate the legacy LightNode/full node regime
-	fullCapability  *Capability
-	lightCapability *Capability
+	fullCapability  *capability.Capability
+	lightCapability *capability.Capability
 )
 
 const (
@@ -80,19 +81,19 @@ func init() {
 }
 
 // temporary convenience functions for legacy "LightNode"
-func newLightCapability() *Capability {
-	c := NewCapability(0, 16)
+func newLightCapability() *capability.Capability {
+	c := capability.NewCapability(0, 16)
 	c.Set(capabilitiesRetrieve)
 	c.Set(capabilitiesPush)
 	return c
 }
-func isLightCapability(c *Capability) bool {
+func isLightCapability(c *capability.Capability) bool {
 	return lightCapability.IsSameAs(c)
 }
 
 // temporary convenience functions for legacy "full node"
-func newFullCapability() *Capability {
-	c := NewCapability(0, 16)
+func newFullCapability() *capability.Capability {
+	c := capability.NewCapability(0, 16)
 	c.Set(capabilitiesRetrieve)
 	c.Set(capabilitiesPush)
 	c.Set(capabilitiesRelayRetrieve)
@@ -101,7 +102,7 @@ func newFullCapability() *Capability {
 	return c
 }
 
-func isFullCapability(c *Capability) bool {
+func isFullCapability(c *capability.Capability) bool {
 	return fullCapability.IsSameAs(c)
 }
 
@@ -124,7 +125,7 @@ type Bzz struct {
 	handshakes   map[enode.ID]*HandshakeMsg
 	streamerSpec *protocols.Spec
 	streamerRun  func(*BzzPeer) error
-	capabilities *Capabilities // capabilities control and state
+	capabilities *capability.Capabilities // capabilities control and state
 }
 
 // NewBzz is the swarm protocol constructor
@@ -140,7 +141,7 @@ func NewBzz(config *BzzConfig, kad *Kademlia, store state.Store, streamerSpec *p
 		handshakes:   make(map[enode.ID]*HandshakeMsg),
 		streamerRun:  streamerRun,
 		streamerSpec: streamerSpec,
-		capabilities: NewCapabilities(),
+		capabilities: capability.NewCapabilities(),
 	}
 
 	if config.BootnodeMode {
@@ -150,9 +151,9 @@ func NewBzz(config *BzzConfig, kad *Kademlia, store state.Store, streamerSpec *p
 
 	// temporary soon-to-be-legacy light/full, as above
 	if config.LightNode {
-		bzz.capabilities.add(newLightCapability())
+		bzz.capabilities.Add(newLightCapability())
 	} else {
-		bzz.capabilities.add(newFullCapability())
+		bzz.capabilities.Add(newFullCapability())
 	}
 
 	return bzz
@@ -250,7 +251,7 @@ func (b *Bzz) RunProtocol(spec *protocols.Spec, run func(*BzzPeer) error) func(*
 			Peer:       protocols.NewPeer(p, rw, spec),
 			BzzAddr:    handshake.peerAddr,
 			lastActive: time.Now(),
-			LightNode:  isLightCapability(handshake.Capabilities.get(0)), // this is a temporary member kept until kademlia code accommodates Capabilities instead
+			LightNode:  isLightCapability(handshake.Capabilities.Get(0)), // this is a temporary member kept until kademlia code accommodates Capabilities instead
 		}
 
 		log.Debug("peer created", "addr", handshake.peerAddr.String())
@@ -335,7 +336,7 @@ type HandshakeMsg struct {
 	Version      uint64
 	NetworkID    uint64
 	Addr         *BzzAddr
-	Capabilities *Capabilities
+	Capabilities *capability.Capabilities
 
 	// peerAddr is the address received in the peer handshake
 	peerAddr *BzzAddr
@@ -360,7 +361,7 @@ func (b *Bzz) checkHandshake(hs interface{}) error {
 		return fmt.Errorf("version mismatch %d (!= %d)", rhs.Version, BzzSpec.Version)
 	}
 	// temporary check for valid capability settings, legacy full/light
-	if !isFullCapability(rhs.Capabilities.get(0)) && !isLightCapability(rhs.Capabilities.get(0)) {
+	if !isFullCapability(rhs.Capabilities.Get(0)) && !isLightCapability(rhs.Capabilities.Get(0)) {
 		return fmt.Errorf("invalid capabilities setting: %s", rhs.Capabilities)
 	}
 	return nil