Add update-codec-server (#216)

* update codec server

* nit fix

* update not import

* https fix

Author: shivam-ajmera

app/namespace.go

@@ -829,6 +829,63 @@ func NewNamespaceCommand(getNamespaceClientFn GetNamespaceClientFn) (CommandOut,
 				},
 			},
 		},
+		{
+			Name:    "update-codec-server",
+			Usage:   "Update codec server config used to decode encoded payloads through remote endpoint",
+			Aliases: []string{"ucs"},
+			Flags: []cli.Flag{
+				NamespaceFlag,
+				&cli.StringFlag{
+					Name:     "endpoint",
+					Usage:    "The codec server endpoint to decode payloads for all users interacting with this Namespace, must be https",
+					Aliases:  []string{"e"},
+					Required: true,
+				},
+				&cli.BoolFlag{
+					Name:    "pass-access-token",
+					Usage:   "Pass the user access token with the remote endpoint",
+					Aliases: []string{"pat"},
+				},
+				&cli.BoolFlag{
+					Name:    "include-credentials",
+					Usage:   "Include cross-origin credentials",
+					Aliases: []string{"ic"},
+				},
+			},
+			Action: func(ctx *cli.Context) error {
+				n, err := c.getNamespace(ctx.String(NamespaceFlagName))
+				if err != nil {
+					return err
+				}
+
+				replacement := &namespace.CodecServerPropertySpec{
+					Endpoint:           ctx.String("endpoint"),
+					PassAccessToken:    ctx.Bool("pass-access-token"),
+					IncludeCredentials: ctx.Bool("include-credentials"),
+				}
+
+				difference, err := compareCodecSpec(n.Spec.CodecSpec, replacement)
+				if err != nil {
+					return err
+				}
+
+				fmt.Println("this update will result in the following changes to the codec server config:")
+				fmt.Println(difference)
+
+				confirmed, err := ConfirmPrompt(ctx, "confirm codec server update operation")
+				if err != nil {
+					return err
+				}
+
+				if confirmed {
+					n.Spec.CodecSpec = replacement
+					return c.updateNamespace(ctx, n)
+				}
+
+				fmt.Println("operation canceled")
+				return nil
+			},
+		},
 		{
 			Name:    "retention",
 			Usage:   "Manages configuration of the length of time (in days) a closed workflow will be preserved before deletion",
@@ -1071,6 +1128,20 @@ func compareCertificateFilters(existing, replacement certificateFiltersConfig) (
 	return diff.Diff(string(existingBytes), string(replacementBytes)), nil
 }
 
+func compareCodecSpec(existing, replacement *namespace.CodecServerPropertySpec) (string, error) {
+	existingBytes, err := FormatJson(existing)
+	if err != nil {
+		return "", err
+	}
+
+	replacementBytes, err := FormatJson(replacement)
+	if err != nil {
+		return "", err
+	}
+
+	return diff.Diff(string(existingBytes), string(replacementBytes)), nil
+}
+
 func validateNamespaceRegion(region string) error {
 	for _, r := range namespaceRegions {
 		if r == region {

app/namespace_test.go

@@ -4,12 +4,13 @@ import (
 	"context"
 	"encoding/base64"
 	"errors"
-	"github.com/temporalio/tcld/protogen/api/auth/v1"
-	"github.com/temporalio/tcld/protogen/api/authservice/v1"
 	"os"
 	"strings"
 	"testing"
 
+	"github.com/temporalio/tcld/protogen/api/auth/v1"
+	"github.com/temporalio/tcld/protogen/api/authservice/v1"
+
 	"github.com/golang/mock/gomock"
 	"github.com/stretchr/testify/suite"
 	"github.com/temporalio/tcld/protogen/api/namespace/v1"
@@ -1063,6 +1064,108 @@ func (s *NamespaceTestSuite) TestClearCertificateFilters() {
 	}
 }
 
+func (s *NamespaceTestSuite) TestUpdateCodecServer() {
+	ns := "ns1"
+	type morphGetResp func(*namespaceservice.GetNamespaceResponse)
+	type morphUpdateReq func(*namespaceservice.UpdateNamespaceRequest)
+
+	tests := []struct {
+		args         []string
+		expectGet    morphGetResp
+		expectErr    bool
+		expectUpdate morphUpdateReq
+	}{
+		{
+
+			args:      []string{"namespace", "update-codec-server"},
+			expectErr: true,
+		},
+		{
+			args:      []string{"namespace", "update-codec-server", "--namespace", ns},
+			expectErr: true,
+		},
+		{
+			args:      []string{"n", "ucs", "-n", ns, "-endpoint", "fakehost:9999"},
+			expectGet: func(g *namespaceservice.GetNamespaceResponse) {},
+			expectUpdate: func(r *namespaceservice.UpdateNamespaceRequest) {
+				r.Spec.CodecSpec = &namespace.CodecServerPropertySpec{Endpoint: "fakehost:9999"}
+			},
+		},
+		{
+			args:      []string{"n", "ucs", "-n", ns, "-e", "fakehost:9999", "--pass-access-token"},
+			expectGet: func(g *namespaceservice.GetNamespaceResponse) {},
+			expectUpdate: func(r *namespaceservice.UpdateNamespaceRequest) {
+				r.Spec.CodecSpec = &namespace.CodecServerPropertySpec{
+					Endpoint:        "fakehost:9999",
+					PassAccessToken: true,
+				}
+			},
+		},
+		{
+			args:      []string{"n", "ucs", "-n", ns, "-e", "fakehost:9999", "--pat", "--include-credentials"},
+			expectGet: func(g *namespaceservice.GetNamespaceResponse) {},
+			expectUpdate: func(r *namespaceservice.UpdateNamespaceRequest) {
+				r.Spec.CodecSpec = &namespace.CodecServerPropertySpec{
+					Endpoint:           "fakehost:9999",
+					PassAccessToken:    true,
+					IncludeCredentials: true,
+				}
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		s.Run(strings.Join(tc.args, " "), func() {
+			getResp := namespaceservice.GetNamespaceResponse{
+				Namespace: &namespace.Namespace{
+					Namespace: ns,
+					Spec: &namespace.NamespaceSpec{
+						AcceptedClientCa: "cert1",
+						SearchAttributes: map[string]namespace.SearchAttributeType{
+							"attr1": namespace.SEARCH_ATTRIBUTE_TYPE_BOOL,
+						},
+						RetentionDays: 7,
+						CertificateFilters: []*namespace.CertificateFilterSpec{
+							{
+								CommonName: "test0",
+							},
+						},
+					},
+					State:           namespace.STATE_ACTIVE,
+					ResourceVersion: "ver1",
+				},
+			}
+			if tc.expectGet != nil {
+				tc.expectGet(&getResp)
+				s.mockService.EXPECT().GetNamespace(gomock.Any(), &namespaceservice.GetNamespaceRequest{
+					Namespace: ns,
+				}).Return(&getResp, nil).Times(1)
+			}
+
+			if tc.expectUpdate != nil {
+				spec := *(getResp.Namespace.Spec)
+				req := namespaceservice.UpdateNamespaceRequest{
+					Namespace:       ns,
+					Spec:            &spec,
+					ResourceVersion: getResp.Namespace.ResourceVersion,
+				}
+				tc.expectUpdate(&req)
+				s.mockService.EXPECT().UpdateNamespace(gomock.Any(), &req).
+					Return(&namespaceservice.UpdateNamespaceResponse{
+						RequestStatus: &request.RequestStatus{},
+					}, nil).Times(1)
+			}
+
+			err := s.RunCmd(tc.args...)
+			if tc.expectErr {
+				s.Error(err)
+			} else {
+				s.NoError(err)
+			}
+		})
+	}
+}
+
 func (s *NamespaceTestSuite) TestUpdateNamespaceRetention() {
 
 	ns := "ns1"