Add getState to protoClient

cli/cmd/protoclient.go

@@ -5,10 +5,12 @@ import (
 
 	"github.com/edgelesssys/constellation/cli/proto"
 	"github.com/edgelesssys/constellation/coordinator/atls"
+	"github.com/edgelesssys/constellation/coordinator/state"
 )
 
 type protoClient interface {
 	Connect(ip, port string, validators []atls.Validator) error
 	Close() error
+	GetState(ctx context.Context) (state.State, error)
 	Activate(ctx context.Context, userPublicKey, masterSecret []byte, nodeIPs, coordinatorIPs, autoscalingNodeGroups []string, cloudServiceAccountURI string) (proto.ActivationResponseClient, error)
 }

cli/cmd/protoclient_test.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/edgelesssys/constellation/cli/proto"
 	"github.com/edgelesssys/constellation/coordinator/atls"
+	"github.com/edgelesssys/constellation/coordinator/state"
 )
 
 type stubProtoClient struct {
@@ -15,8 +16,10 @@ type stubProtoClient struct {
 	respClient  proto.ActivationResponseClient
 	connectErr  error
 	closeErr    error
+	getStateErr error
 	activateErr error
 
+	getStateState                 state.State
 	activateUserPublicKey         []byte
 	activateMasterSecret          []byte
 	activateNodeIPs               []string
@@ -35,6 +38,10 @@ func (c *stubProtoClient) Close() error {
 	return c.closeErr
 }
 
+func (c *stubProtoClient) GetState(_ context.Context) (state.State, error) {
+	return c.getStateState, c.getStateErr
+}
+
 func (c *stubProtoClient) Activate(ctx context.Context, userPublicKey, masterSecret []byte, nodeIPs, coordinatorIPs []string, autoscalingNodeGroups []string, cloudServiceAccountURI string) (proto.ActivationResponseClient, error) {
 	c.activateUserPublicKey = userPublicKey
 	c.activateMasterSecret = masterSecret
@@ -112,7 +119,14 @@ func (c *fakeProtoClient) Close() error {
 	return nil
 }
 
-func (c *fakeProtoClient) Activate(ctx context.Context, userPublicKey, masterSecret []byte, nodeIPs, coordinatorIPs []string, autoscalingNodeGroups []string, cloudServiceAccountURI string) (proto.ActivationResponseClient, error) {
+func (c *fakeProtoClient) GetState(_ context.Context) (state.State, error) {
+	if !c.conn {
+		return state.Uninitialized, errors.New("client is not connected")
+	}
+	return state.IsNode, nil
+}
+
+func (c *fakeProtoClient) Activate(ctx context.Context, userPublicKey, masterSecret []byte, nodeIPs, coordinatorIPs, autoscalingNodeGroups []string, cloudServiceAccountURI string) (proto.ActivationResponseClient, error) {
 	if !c.conn {
 		return nil, errors.New("client is not connected")
 	}

cli/proto/client.go

@@ -9,6 +9,7 @@ import (
 	"github.com/edgelesssys/constellation/coordinator/atls"
 	"github.com/edgelesssys/constellation/coordinator/kms"
 	"github.com/edgelesssys/constellation/coordinator/pubapi/pubproto"
+	"github.com/edgelesssys/constellation/coordinator/state"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -59,6 +60,19 @@ func (c *Client) Close() error {
 	return nil
 }
 
+// GetState returns the state of the connected server.
+func (c *Client) GetState(ctx context.Context) (state.State, error) {
+	if c.pubapi == nil {
+		return state.Uninitialized, errors.New("client is not connected")
+	}
+
+	resp, err := c.pubapi.GetState(ctx, &pubproto.GetStateRequest{})
+	if err != nil {
+		return state.Uninitialized, err
+	}
+	return state.State(resp.State), nil
+}
+
 // Activate activates the Constellation coordinator via a grpc call.
 // The handed IP addresses must be the private IP addresses of running AWS or GCP instances,
 // and the userPublicKey is the VPN key of the users WireGuard interface.

cli/proto/client_test.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/edgelesssys/constellation/coordinator/pubapi/pubproto"
+	"github.com/edgelesssys/constellation/coordinator/state"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"google.golang.org/grpc"
@@ -65,6 +66,48 @@ func TestClose(t *testing.T) {
 	assert.Equal(connectivity.Shutdown, conn.GetState())
 }
 
+func TestGetState(t *testing.T) {
+	someErr := errors.New("some error")
+
+	testCases := map[string]struct {
+		pubAPIClient pubproto.APIClient
+		wantErr      bool
+		wantState    state.State
+	}{
+		"success": {
+			pubAPIClient: &stubPubAPIClient{getStateState: state.IsNode},
+			wantState:    state.IsNode,
+		},
+		"getState error": {
+			pubAPIClient: &stubPubAPIClient{getStateErr: someErr},
+			wantErr:      true,
+		},
+		"uninitialized": {
+			wantErr: true,
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			assert := assert.New(t)
+
+			client := Client{}
+			if tc.pubAPIClient != nil {
+				client.pubapi = tc.pubAPIClient
+			}
+
+			state, err := client.GetState(context.Background())
+
+			if tc.wantErr {
+				assert.Error(err)
+			} else {
+				assert.NoError(err)
+				assert.Equal(tc.wantState, state)
+			}
+		})
+	}
+}
+
 func TestActivate(t *testing.T) {
 	testKey := base64.StdEncoding.EncodeToString([]byte("32bytesWireGuardKeyForTheTesting"))
 	someErr := errors.New("failed")
@@ -135,6 +178,8 @@ func TestActivate(t *testing.T) {
 }
 
 type stubPubAPIClient struct {
+	getStateState                     state.State
+	getStateErr                       error
 	activateAsCoordinatorErr          error
 	activateAdditionalNodesErr        error
 	activateAsCoordinatorReqKey       []byte
@@ -145,6 +190,10 @@ type stubPubAPIClient struct {
 	pubproto.APIClient
 }
 
+func (s *stubPubAPIClient) GetState(ctx context.Context, in *pubproto.GetStateRequest, opts ...grpc.CallOption) (*pubproto.GetStateResponse, error) {
+	return &pubproto.GetStateResponse{State: uint32(s.getStateState)}, s.getStateErr
+}
+
 func (s *stubPubAPIClient) ActivateAsCoordinator(ctx context.Context, in *pubproto.ActivateAsCoordinatorRequest,
 	opts ...grpc.CallOption,
 ) (pubproto.API_ActivateAsCoordinatorClient, error) {