API changes related to design review

Signed-off-by: Jakub Dzon <[email protected]>

Author: Jakub Dzon

internal/edgeapi/backend/api.go

@@ -6,44 +6,44 @@ import (
 	"github.com/project-flotta/flotta-operator/models"
 )
 
+const (
+	Registered   = RegistrationStatus("registered")
+	Unregistered = RegistrationStatus("unregistered")
+	Unknown      = RegistrationStatus("unknown")
+)
+
+type RegistrationStatus string
+
 type Notification struct {
 	DeviceID  string
 	Namespace string
 	Heartbeat *models.Heartbeat
 	Retry     int32
 }
 
-//go:generate mockgen -package=backend -destination=mock_heartbeat-handler.go . HeartbeatHandler
-type HeartbeatHandler interface {
-	Process(ctx context.Context, notification Notification) (bool, error)
-}
-
-// Backend represents API provided by data storage service to support edge device lifecycle.
-type Backend interface {
-	// ShouldEdgeDeviceBeUnregistered responds with true, when the device identified with name and namespace should be
-	// instructed to execute de-registration procedure
-	ShouldEdgeDeviceBeUnregistered(ctx context.Context, name, namespace string) (bool, error)
+// EdgeDeviceBackend represents API provided by data storage service to support edge device lifecycle.
+type EdgeDeviceBackend interface {
+	// GetRegistrationStatus responds with status of a device registration: {enrolled, registered, unregistered}
+	GetRegistrationStatus(ctx context.Context, name, namespace string) (RegistrationStatus, error)
 
-	// GetDeviceConfiguration provides complete Edge Device configuration that should be applied to the device
-	GetDeviceConfiguration(ctx context.Context, name, namespace string) (*models.DeviceConfigurationMessage, error)
+	// GetConfiguration provides complete Edge Device configuration that should be applied to the device
+	GetConfiguration(ctx context.Context, name, namespace string) (*models.DeviceConfigurationMessage, error)
 
-	// EnrolEdgeDevice records device willingness to be connected to the cluster.
-	EnrolEdgeDevice(ctx context.Context, name string, enrolmentInfo *models.EnrolmentInfo) (bool, error)
+	// Enrol records device willingness to be connected to the cluster.
+	Enrol(ctx context.Context, name string, enrolmentInfo *models.EnrolmentInfo) (bool, error)
 
-	// InitializeEdgeDeviceRegistration is called when device sends registration request (either to issue the mTLS certificate
-	// for the first time or renew it) and has to return information whether it is handling first registration request from the device,
-	// and namespace the device should be created in.
-	InitializeEdgeDeviceRegistration(ctx context.Context, name, namespace string, matchesCertificate bool) (bool, string, error)
+	// GetTargetNamespace returns the namespace the device should belong to.
+	GetTargetNamespace(ctx context.Context, name, namespace string, matchesCertificate bool) (string, error)
 
-	// FinalizeEdgeDeviceRegistration is called during device registration request handling, after mTLS certificate has
+	// FinalizeRegistration is called during device registration request handling, after mTLS certificate has
 	// been correctly issued.
 	// The responsibility of the method is to potentially record information that the device is finally registered and
 	// what hardware configuration it has.
-	FinalizeEdgeDeviceRegistration(ctx context.Context, name, namespace string, registrationInfo *models.RegistrationInfo) error
+	FinalizeRegistration(ctx context.Context, name, namespace string, registrationInfo *models.RegistrationInfo) error
 
-	// GetHeartbeatHandler provides implementation of a HeartbeatHandler that should record current state of the device sent in
+	// UpdateStatus records current state of the device sent in a heartbeat message
 	// (i.e. workload status, events reported by the device, OS upgrade status).
-	GetHeartbeatHandler() HeartbeatHandler
+	UpdateStatus(ctx context.Context, notification Notification) (bool, error)
 }
 
 type NotApproved struct {

internal/edgeapi/backend/factory/factory.go

@@ -18,7 +18,7 @@ import (
 	"github.com/project-flotta/flotta-operator/internal/edgeapi/k8sclient"
 )
 
-func CreateBackend(initialDeviceNamespace string, client kubeclient.Client, logger *zap.SugaredLogger, eventRecorder record.EventRecorder) backend.Backend {
+func CreateBackend(initialDeviceNamespace string, client kubeclient.Client, logger *zap.SugaredLogger, eventRecorder record.EventRecorder) backend.EdgeDeviceBackend {
 	// For now just one implementation is supported
 	k8sClient := k8sclient.NewK8sClient(client)
 

internal/edgeapi/backend/k8s/backend.go

@@ -31,38 +31,38 @@ type backend struct {
 	repository       RepositoryFacade
 	assembler        *ConfigurationAssembler
 	initialNamespace string
-	heartbeatHandler backendapi.HeartbeatHandler
+	heartbeatHandler *SynchronousHandler
 }
 
 func NewBackend(repository RepositoryFacade, assembler *ConfigurationAssembler,
-	logger *zap.SugaredLogger, initialNamespace string, recorder record.EventRecorder) backendapi.Backend {
+	logger *zap.SugaredLogger, initialNamespace string, recorder record.EventRecorder) backendapi.EdgeDeviceBackend {
 	return &backend{repository: repository,
 		assembler:        assembler,
 		logger:           logger,
 		initialNamespace: initialNamespace,
 		heartbeatHandler: NewSynchronousHandler(repository, recorder, logger)}
 }
 
-func (b *backend) ShouldEdgeDeviceBeUnregistered(ctx context.Context, name, namespace string) (bool, error) {
+func (b *backend) GetRegistrationStatus(ctx context.Context, name, namespace string) (backendapi.RegistrationStatus, error) {
 	edgeDevice, err := b.repository.GetEdgeDevice(ctx, name, namespace)
 	if err != nil {
-		return false, err
+		return backendapi.Unknown, err
 	}
 
 	if edgeDevice.DeletionTimestamp == nil || utils.HasFinalizer(&edgeDevice.ObjectMeta, YggdrasilWorkloadFinalizer) {
-		return false, nil
+		return backendapi.Registered, nil
 	}
 
 	if utils.HasFinalizer(&edgeDevice.ObjectMeta, YggdrasilConnectionFinalizer) {
 		err = b.repository.RemoveEdgeDeviceFinalizer(ctx, edgeDevice, YggdrasilConnectionFinalizer)
 		if err != nil {
-			return false, err
+			return backendapi.Registered, err
 		}
 	}
-	return true, nil
+	return backendapi.Unregistered, nil
 }
 
-func (b *backend) GetDeviceConfiguration(ctx context.Context, name, namespace string) (*models.DeviceConfigurationMessage, error) {
+func (b *backend) GetConfiguration(ctx context.Context, name, namespace string) (*models.DeviceConfigurationMessage, error) {
 	logger := b.logger.With("DeviceID", name)
 	edgeDevice, err := b.repository.GetEdgeDevice(ctx, name, namespace)
 	if err != nil {
@@ -80,7 +80,7 @@ func (b *backend) GetDeviceConfiguration(ctx context.Context, name, namespace st
 	return b.assembler.GetDeviceConfiguration(ctx, edgeDevice, logger)
 }
 
-func (b *backend) EnrolEdgeDevice(ctx context.Context, name string, enrolmentInfo *models.EnrolmentInfo) (bool, error) {
+func (b *backend) Enrol(ctx context.Context, name string, enrolmentInfo *models.EnrolmentInfo) (bool, error) {
 	targetNamespace := b.initialNamespace
 	if enrolmentInfo.TargetNamespace != nil {
 		targetNamespace = *enrolmentInfo.TargetNamespace
@@ -122,14 +122,14 @@ func (b *backend) EnrolEdgeDevice(ctx context.Context, name string, enrolmentInf
 	return false, b.repository.CreateEdgeDeviceSignedRequest(ctx, edsr)
 }
 
-func (b *backend) InitializeEdgeDeviceRegistration(ctx context.Context, name, identityNamespace string, matchesCertificate bool) (bool, string, error) {
+func (b *backend) GetTargetNamespace(ctx context.Context, name, identityNamespace string, matchesCertificate bool) (string, error) {
 	logger := b.logger.With("DeviceID", name)
 	namespace := identityNamespace
 	if identityNamespace == b.initialNamespace && !matchesCertificate {
 		// check if it's a valid device, shouldn't match
 		esdr, err := b.repository.GetEdgeDeviceSignedRequest(ctx, name, b.initialNamespace)
 		if err != nil {
-			return false, "", err
+			return "", err
 		}
 		if esdr.Spec.TargetNamespace != "" {
 			namespace = esdr.Spec.TargetNamespace
@@ -138,13 +138,13 @@ func (b *backend) InitializeEdgeDeviceRegistration(ctx context.Context, name, id
 	dvc, err := b.repository.GetEdgeDevice(ctx, name, namespace)
 	if err != nil {
 		if errors.IsNotFound(err) {
-			return false, "", backendapi.NewNotApproved(err)
+			return "", backendapi.NewNotApproved(err)
 		}
-		return false, "", err
+		return "", err
 	}
 
 	if dvc == nil {
-		return false, "", fmt.Errorf("device not found")
+		return "", fmt.Errorf("device not found")
 	}
 
 	isInit := false
@@ -159,13 +159,18 @@ func (b *backend) InitializeEdgeDeviceRegistration(ctx context.Context, name, id
 		// At this moment, the registration certificate it's no longer valid,
 		// because the CR is already created, and need to be a device
 		// certificate.
-		return false, "", fmt.Errorf("forbidden")
+		return "", fmt.Errorf("forbidden")
 	}
 
-	return isInit, namespace, nil
+	if isInit {
+		logger.Info("EdgeDevice registered correctly for first time")
+	} else {
+		logger.Info("EdgeDevice renew registration correctly")
+	}
+	return namespace, nil
 }
 
-func (b *backend) FinalizeEdgeDeviceRegistration(ctx context.Context, name, namespace string, registrationInfo *models.RegistrationInfo) error {
+func (b *backend) FinalizeRegistration(ctx context.Context, name, namespace string, registrationInfo *models.RegistrationInfo) error {
 	logger := b.logger.With("DeviceID", name)
 	dvc, err := b.repository.GetEdgeDevice(ctx, name, namespace)
 	deviceCopy := dvc.DeepCopy()
@@ -187,8 +192,8 @@ func (b *backend) FinalizeEdgeDeviceRegistration(ctx context.Context, name, name
 	return err
 }
 
-func (b *backend) GetHeartbeatHandler() backendapi.HeartbeatHandler {
-	return b.heartbeatHandler
+func (b *backend) UpdateStatus(ctx context.Context, notification backendapi.Notification) (bool, error){
+	return b.heartbeatHandler.Process(ctx, notification)
 }
 
 func (b *backend) updateDeviceStatus(ctx context.Context, device *v1alpha1.EdgeDevice, updateFunc func(d *v1alpha1.EdgeDevice)) error {

internal/edgeapi/backend/mock_heartbeat-handler.go

@@ -7,11 +7,16 @@ import (
 	"github.com/project-flotta/flotta-operator/internal/edgeapi/backend"
 )
 
+//go:generate mockgen -package=yggdrasil -destination=mock_status-updater.go . StatusUpdater
+type StatusUpdater interface {
+	UpdateStatus(ctx context.Context, notification backend.Notification) (bool, error)
+}
+
 type RetryingDelegatingHandler struct {
-	delegate backend.HeartbeatHandler
+	delegate StatusUpdater
 }
 
-func NewRetryingDelegatingHandler(delegate backend.HeartbeatHandler) *RetryingDelegatingHandler {
+func NewRetryingDelegatingHandler(delegate StatusUpdater) *RetryingDelegatingHandler {
 	return &RetryingDelegatingHandler{delegate: delegate}
 }
 
@@ -20,7 +25,7 @@ func (h *RetryingDelegatingHandler) Process(ctx context.Context, notification ba
 	var err error
 	var retry bool
 	for i := 1; i < 5; i++ {
-		retry, err = h.delegate.Process(ctx, notification)
+		retry, err = h.delegate.UpdateStatus(ctx, notification)
 		if err == nil {
 			return nil
 		}

internal/edgeapi/yggdrasil/heartbeat-handler.go

@@ -16,13 +16,13 @@ var _ = Describe("Heartbeat handler", func() {
 
 	var (
 		mockCtrl     *gomock.Controller
-		mockDelegate *backend.MockHeartbeatHandler
+		mockDelegate *yggdrasil.MockStatusUpdater
 		handler      *yggdrasil.RetryingDelegatingHandler
 	)
 
 	BeforeEach(func() {
 		mockCtrl = gomock.NewController(GinkgoT())
-		mockDelegate = backend.NewMockHeartbeatHandler(mockCtrl)
+		mockDelegate = yggdrasil.NewMockStatusUpdater(mockCtrl)
 
 		handler = yggdrasil.NewRetryingDelegatingHandler(mockDelegate)
 	})
@@ -37,7 +37,7 @@ var _ = Describe("Heartbeat handler", func() {
 		notification := backend.Notification{DeviceID: "1234"}
 
 		mockDelegate.EXPECT().
-			Process(ctx, notification).
+			UpdateStatus(ctx, notification).
 			Return(false, nil)
 
 		// when
@@ -54,10 +54,10 @@ var _ = Describe("Heartbeat handler", func() {
 		notification := backend.Notification{DeviceID: "1234"}
 		retryNotification := backend.Notification{DeviceID: "1234", Retry: 1}
 		errorCall := mockDelegate.EXPECT().
-			Process(ctx, notification).
+			UpdateStatus(ctx, notification).
 			Return(true, fmt.Errorf("boom"))
 		mockDelegate.EXPECT().
-			Process(ctx, retryNotification).
+			UpdateStatus(ctx, retryNotification).
 			Return(false, nil).
 			After(errorCall)
 
@@ -74,7 +74,7 @@ var _ = Describe("Heartbeat handler", func() {
 		notification := backend.Notification{DeviceID: "1234"}
 
 		mockDelegate.EXPECT().
-			Process(ctx, gomock.AssignableToTypeOf(notification)).
+			UpdateStatus(ctx, gomock.AssignableToTypeOf(notification)).
 			Return(true, fmt.Errorf("boom")).
 			Times(4)