implement onboard/offboard device to/from cloud

.travis.yml

@@ -3,14 +3,22 @@ language: minimal
 services:
   - docker
 
-install:                                                                 
+install:
+  - if [ "${TRAVIS_OS_NAME}" == "linux" ]; then
+      sudo sh -c 'echo 0 > /proc/sys/net/ipv6/conf/all/disable_ipv6';
+    fi
   - docker build . --network=host -t sdk:build
+  - docker build . -f Dockerfile.device-simulator --network=host -t sdk:device-simulator
+  - docker run -d --network=host sdk:device-simulator /device-simulator
+  - sleep 2
+after_failure:
+  - docker logs $(docker ps -a -q --filter ancestor=sdk:device-simulator --format="{{.ID}}")
 
 jobs:
   include:
     - stage: test
       if: type == pull_request
-      script: 
+      script:
         - docker run --network=host sdk:build go test ./...
 
     - stage: test_and_cover

Dockerfile.device-simulator

@@ -0,0 +1,9 @@
+FROM ubuntu:18.04 AS device-simulator
+
+RUN apt-get update
+RUN apt-get install -y git gcc make
+RUN git clone --recursive https://github.com/iotivity/iotivity-lite.git
+RUN make -C /iotivity-lite/port/linux CLOUD=1 SECURE=0 DEBUG=1 cloud_linux
+RUN cp /iotivity-lite/port/linux/cloud_linux /device-simulator
+
+ENTRYPOINT ["/device-simulator"]

local/client_test.go

@@ -11,7 +11,7 @@ var testCfg = ocf.Config{
 	Protocol: "tcp",
 	Resource: resource.Config{
 		ResourceHrefExpiration: time.Hour,
-		DiscoveryTimeout:       time.Second,
+		DiscoveryTimeout:       time.Second * 3,
 		DiscoveryDelay:         100 * time.Millisecond,
 
 		Errors: func(error) {},

local/device/client.go

@@ -73,9 +73,9 @@ func (it *QueryResourceIterator) Next(ctx context.Context, v interface{}) bool {
 	return true
 }
 
-// DeviceID
-func (c *Client) DeviceID() {
-	return
+// DeviceID returns id of device
+func (c *Client) DeviceID() string {
+	return c.links.ID
 }
 
 // GetResourceLinks returns all resource links.

local/getResource.go

@@ -6,6 +6,7 @@ import (
 	gocoap "github.com/go-ocf/go-coap"
 	"github.com/go-ocf/kit/codec/coap"
 	"github.com/go-ocf/sdk/local/resource"
+	"github.com/go-ocf/sdk/schema"
 )
 
 // coapContentFormat values can be found here
@@ -39,6 +40,19 @@ func (c *Client) GetResourceCBOR(
 	return nil
 }
 
+func (c *Client) GetResourceDiscovery(
+	ctx context.Context,
+	deviceID string,
+	response *[]schema.DeviceLinks,
+) error {
+	codec := resource.DiscoveryResourceCodec{}
+	err := c.getResource(ctx, deviceID, "/oic/res", "", codec, response)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 func (c *Client) getResource(
 	ctx context.Context,
 	deviceID, href string,

local/offboardDevice.go

@@ -0,0 +1,16 @@
+package local
+
+import (
+	"context"
+	"fmt"
+)
+
+func (c *Client) OffboardDevice(
+	ctx context.Context,
+	deviceID string,
+) error {
+	const errMsg = "cannot offboard device %v: %v"
+	return c.onboardOffboardDevice(ctx, deviceID, "", "", "", func(err error) error {
+		return fmt.Errorf(errMsg, deviceID, err)
+	})
+}

local/offboardDevice_test.go

@@ -0,0 +1,37 @@
+package local_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	ocf "github.com/go-ocf/sdk/local"
+	"github.com/stretchr/testify/require"
+)
+
+func TestClient_OffboardDevice(t *testing.T) {
+	testCfg.Protocol = "tcp"
+	testCfg.Resource.DiscoveryTimeout = time.Second * 3
+
+	c, err := ocf.NewClientFromConfig(testCfg, nil)
+	require := require.New(t)
+	require.NoError(err)
+
+	timeout, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+	h := testOnboardDeviceHandler{}
+	err = c.GetDevices(timeout, []string{"oic.d.cloudDevice"}, &h)
+	require.NoError(err)
+	deviceIds := h.PopDeviceIds()
+	require.NotEmpty(deviceIds)
+
+	func() {
+		for deviceId, _ := range deviceIds {
+			timeout, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+			defer cancel()
+			err = c.OffboardDevice(timeout, deviceId)
+			require.NoError(err)
+		}
+	}()
+
+}

local/onboardDevice.go

@@ -0,0 +1,71 @@
+package local
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/go-ocf/sdk/schema"
+)
+
+func (c *Client) onboardOffboardDevice(
+	ctx context.Context,
+	deviceID, authorizationProvider, authorizationCode, url string, errFunc func(err error) error,
+) error {
+	switch {
+	case deviceID == "":
+		return errFunc(fmt.Errorf("invalid deviceID"))
+	}
+
+	var devices []schema.DeviceLinks
+	err := c.GetResourceDiscovery(ctx, deviceID, &devices)
+	if err != nil {
+		return errFunc(err)
+	}
+
+	cloudResourceHref := ""
+Loop:
+	for _, device := range devices {
+		for _, link := range device.Links {
+			for _, resType := range link.ResourceTypes {
+				if resType == schema.CloudResourceType {
+					cloudResourceHref = link.Href
+					break Loop
+				}
+			}
+		}
+	}
+
+	if cloudResourceHref == "" {
+		return errFunc(fmt.Errorf("cloud resource not found"))
+	}
+
+	req := schema.CloudUpdateRequest{
+		AuthorizationProvider: authorizationProvider,
+		AuthorizationCode:     authorizationCode,
+		URL:                   url,
+	}
+	var resp schema.CloudResponse
+	err = c.UpdateResourceCBOR(ctx, deviceID, cloudResourceHref, "", req, &resp)
+	if err != nil {
+		return errFunc(err)
+	}
+	return nil
+}
+
+func (c *Client) OnboardDevice(
+	ctx context.Context,
+	deviceID, authorizationProvider, authorizationCode, url string,
+) error {
+	const errMsg = "cannot onboard device %v: %v"
+	switch {
+	case authorizationProvider == "":
+		return fmt.Errorf(errMsg, deviceID, "invalid authorizationProvider")
+	case authorizationCode == "":
+		return fmt.Errorf(errMsg, deviceID, "invalid authorizationCode")
+	case url == "":
+		return fmt.Errorf(errMsg, deviceID, "invalid url")
+	}
+	return c.onboardOffboardDevice(ctx, deviceID, authorizationProvider, authorizationCode, url, func(err error) error {
+		return fmt.Errorf(errMsg, deviceID, err)
+	})
+}

local/onboardDevice_test.go

@@ -0,0 +1,114 @@
+package local_test
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	ocf "github.com/go-ocf/sdk/local"
+	"github.com/go-ocf/sdk/local/device"
+	"github.com/stretchr/testify/require"
+)
+
+type testOnboardDeviceHandler struct {
+	lock      sync.Mutex
+	deviceIds map[string]bool
+}
+
+func (h *testOnboardDeviceHandler) Handle(ctx context.Context, client *device.Client) {
+	h.lock.Lock()
+	defer h.lock.Unlock()
+	if h.deviceIds == nil {
+		h.deviceIds = make(map[string]bool)
+	}
+	h.deviceIds[client.DeviceID()] = true
+}
+
+func (h *testOnboardDeviceHandler) PopDeviceIds() map[string]bool {
+	h.lock.Lock()
+	defer h.lock.Unlock()
+	tmp := h.deviceIds
+	h.deviceIds = nil
+	return tmp
+}
+
+func (h *testOnboardDeviceHandler) Error(err error) {
+}
+
+func TestClient_OnboardDevice(t *testing.T) {
+	type args struct {
+		authorizationProvider string
+		authorizationCode     string
+		url                   string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name: "invalid authorizationProvider",
+			args: args{
+				authorizationCode: "b",
+				url:               "c",
+			},
+			wantErr: true,
+		},
+		{
+			name: "invalid authorizationCode",
+			args: args{
+				authorizationProvider: "a",
+				url: "c",
+			},
+			wantErr: true,
+		},
+		{
+			name: "invalid url",
+			args: args{
+				authorizationProvider: "a",
+				authorizationCode:     "b",
+			},
+			wantErr: true,
+		},
+		{
+			name: "valid",
+			args: args{
+				authorizationProvider: "a",
+				authorizationCode:     "b",
+				url:                   "c",
+			},
+		},
+	}
+
+	testCfg.Protocol = "tcp"
+	testCfg.Resource.DiscoveryTimeout = time.Second * 3
+
+	c, err := ocf.NewClientFromConfig(testCfg, nil)
+	require := require.New(t)
+	require.NoError(err)
+
+	timeout, cancel := context.WithTimeout(context.Background(), time.Second*3)
+	defer cancel()
+	h := testOnboardDeviceHandler{}
+	err = c.GetDevices(timeout, []string{"oic.d.cloudDevice"}, &h)
+	require.NoError(err)
+	deviceIds := h.PopDeviceIds()
+	require.NotEmpty(deviceIds)
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			for deviceId, _ := range deviceIds {
+				timeout, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+				err := c.OnboardDevice(timeout, deviceId, tt.args.authorizationProvider, tt.args.authorizationCode, tt.args.url)
+				cancel()
+				if tt.wantErr {
+					require.Error(err)
+				} else {
+					require.NoError(err)
+				}
+
+			}
+		})
+	}
+}

local/resource/discoverDevices.go

@@ -116,14 +116,16 @@ func runDiscovery(
 }
 
 func handleResponse(ctx context.Context, handler DiscoveryHandler) func(req *gocoap.Request) {
-	codec := coap.CBORCodec{}
 	return func(req *gocoap.Request) {
 		if req.Msg.Code() != gocoap.Content {
 			handler.Error(fmt.Errorf("request failed: %s", coap.Dump(req.Msg)))
 			return
 		}
+
 		var devices []schema.DeviceLinks
-		if err := codec.Decode(req.Msg, &devices); err != nil {
+		var codec DiscoveryResourceCodec
+		err := codec.Decode(req.Msg, &devices)
+		if err != nil {
 			handler.Error(fmt.Errorf("decoding failed: %v: %s", err, coap.DumpHeader(req.Msg)))
 			return
 		}