client/getDevices: fix filling doxm values for owned devices

client/core/device.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"crypto/tls"
 	"crypto/x509"
+	"errors"
 	"fmt"
+	goNet "net"
 	"sync"
 
 	"github.com/pion/dtls/v2"
@@ -74,23 +76,23 @@ func (d *Device) popConnections() []*coap.ClientCloseHandler {
 
 // Close closes open connections to the device.
 func (d *Device) Close(ctx context.Context) error {
-	var errors []error
+	var errs []error
 	err := d.stopObservations(ctx)
 	if err != nil {
-		errors = append(errors, err)
+		errs = append(errs, err)
 	}
 
 	for _, conn := range d.popConnections() {
 		err = conn.Close()
-		if err != nil {
-			errors = append(errors, err)
+		if err != nil && !errors.Is(err, goNet.ErrClosed) {
+			errs = append(errs, err)
 		}
 		// wait for closing socket
 		<-conn.Done()
 	}
 
-	if len(errors) > 0 {
-		return MakeInternal(fmt.Errorf("cannot close device %v: %v", d.DeviceID(), errors))
+	if len(errs) > 0 {
+		return MakeInternal(fmt.Errorf("cannot close device %v: %v", d.DeviceID(), errs))
 	}
 	return nil
 }

client/getDevices.go

@@ -43,41 +43,44 @@ func (c *Client) GetDevices(
 	for _, o := range opts {
 		cfg = o.applyOnGetDevices(cfg)
 	}
+	var m sync.Mutex
+	resOwnerships := make(map[string]doxm.Doxm)
+	ownerships := func(d doxm.Doxm) {
+		m.Lock()
+		defer m.Unlock()
+		resOwnerships[d.DeviceID] = d
+	}
+
 	getDetails := func(ctx context.Context, d *core.Device, links schema.ResourceLinks) (interface{}, error) {
-		return cfg.getDetails(ctx, d, patchResourceLinksEndpoints(links, c.disableUDPEndpoints))
+		links = patchResourceLinksEndpoints(links, c.disableUDPEndpoints)
+		details, err := cfg.getDetails(ctx, d, links)
+		if err == nil && d.IsSecured() {
+			doxm, err := d.GetOwnership(ctx, links)
+			if err == nil {
+				ownerships(doxm)
+			}
+		}
+		return details, err
 	}
 
-	var m sync.Mutex
 	var res []DeviceDetails
 	devices := func(d DeviceDetails) {
 		m.Lock()
 		defer m.Unlock()
 		res = append(res, d)
 	}
 
-	resOwnerships := make(map[string]doxm.Doxm)
-	ownerships := func(d doxm.Doxm) {
-		m.Lock()
-		defer m.Unlock()
-		resOwnerships[d.DeviceID] = d
-	}
-
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
-	ownershipsHandler := newDiscoveryOwnershipsHandler(ctx, cfg.err, ownerships)
-	go c.client.GetOwnerships(ctx, cfg.discoveryConfiguration, core.DiscoverAllDevices, ownershipsHandler)
-
 	handler := newDiscoveryHandler(ctx, cfg.resourceTypes, cfg.err, devices, getDetails, c.deviceCache, c.disableUDPEndpoints)
 	if err := c.client.GetDevicesV2(ctx, cfg.discoveryConfiguration, handler); err != nil {
 		return nil, err
 	}
 
 	m.Lock()
 	defer m.Unlock()
-
 	ownerID, _ := c.client.GetSdkOwnerID()
-
 	return setOwnership(ownerID, mergeDevices(res), resOwnerships), nil
 }
 

client/getDevices_test.go

@@ -18,15 +18,15 @@ func TestDeviceDiscovery(t *testing.T) {
 	secureDeviceID := test.MustFindDeviceByName(test.DevsimName)
 	c, err := NewTestSecureClient()
 	require.NoError(t, err)
+	defer func() {
+		err := c.Close(context.Background())
+		require.NoError(t, err)
+	}()
 
 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
 	defer cancel()
 	devices, err := c.GetDevices(ctx)
 	require.NoError(t, err)
-	defer func() {
-		err := c.Close(context.Background())
-		require.NoError(t, err)
-	}()
 
 	d := devices[deviceID]
 	require.NotEmpty(t, d)
@@ -38,6 +38,26 @@ func TestDeviceDiscovery(t *testing.T) {
 	assert.Equal(t, test.DevsimName, d.Details.(*device.Device).Name)
 	require.NotNil(t, d.Ownership)
 	assert.Equal(t, d.Ownership.OwnerID, "00000000-0000-0000-0000-000000000000")
+
+	ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	secureDeviceID, err = c.OwnDevice(ctx, secureDeviceID, client.WithOTM(client.OTMType_JustWorks))
+	require.NoError(t, err)
+	devices, err = c.GetDevices(ctx)
+	require.NoError(t, err)
+
+	d = devices[secureDeviceID]
+	fmt.Println(d)
+	require.NotNil(t, d)
+	require.NotNil(t, d.Ownership)
+	sdkID, err := c.CoreClient().GetSdkOwnerID()
+	require.NoError(t, err)
+	assert.Equal(t, d.Ownership.OwnerID, sdkID)
+
+	ctx, cancel = context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+	err = c.DisownDevice(ctx, secureDeviceID)
+	require.NoError(t, err)
 }
 
 func TestDeviceDiscoveryWithFilter(t *testing.T) {