refactor: remove legacy monorepo-related code

Author: Camila-B

cmd/nomos/status/client.go

@@ -162,69 +162,12 @@ func (c *ClusterClient) clusterStatus(ctx context.Context, cluster, namespace st
 		cs.Error = c.rootRepoClusterStatus(ctx, cs)
 	} else if namespace != "" {
 		cs.Error = c.namespaceRepoClusterStatus(ctx, cs, namespace)
-	} else if isOss || (cs.isMulti != nil && *cs.isMulti) {
-		c.multiRepoClusterStatus(ctx, cs)
 	} else {
-		c.monoRepoClusterStatus(ctx, cs)
+		c.multiRepoClusterStatus(ctx, cs)
 	}
 	return cs
 }
 
-// monoRepoClusterStatus populates the given ClusterState with the sync status of
-// the mono repo on the ClusterClient's cluster.
-func (c *ClusterClient) monoRepoClusterStatus(ctx context.Context, cs *ClusterState) {
-	git, err := c.monoRepoGit(ctx)
-	if err != nil {
-		cs.status = util.ErrorMsg
-		cs.Error = err.Error()
-		return
-	}
-
-	repoList, err := c.repos.List(ctx, metav1.ListOptions{})
-	if err != nil {
-		cs.status = util.ErrorMsg
-		cs.Error = err.Error()
-		return
-	}
-
-	if len(repoList.Items) == 0 {
-		cs.status = util.UnknownMsg
-		cs.Error = "Repo resource is missing"
-		return
-	}
-
-	repoStatus := repoList.Items[0].Status
-	cs.repos = append(cs.repos, monoRepoStatus(git, repoStatus))
-}
-
-// monoRepoGit fetches the mono repo ConfigManagement resource from the cluster
-// and builds a Git config out of it.
-func (c *ClusterClient) monoRepoGit(ctx context.Context) (*v1beta1.Git, error) {
-	syncRepo, err := c.ConfigManagement.NestedString(ctx, "spec", "git", "syncRepo")
-	if err != nil {
-		return nil, err
-	}
-	syncBranch, err := c.ConfigManagement.NestedString(ctx, "spec", "git", "syncBranch")
-	if err != nil {
-		return nil, err
-	}
-	syncRev, err := c.ConfigManagement.NestedString(ctx, "spec", "git", "syncRev")
-	if err != nil {
-		return nil, err
-	}
-	policyDir, err := c.ConfigManagement.NestedString(ctx, "spec", "git", "policyDir")
-	if err != nil {
-		return nil, err
-	}
-
-	return &v1beta1.Git{
-		Repo:     syncRepo,
-		Branch:   syncBranch,
-		Revision: syncRev,
-		Dir:      policyDir,
-	}, nil
-}
-
 // syncingConditionSupported checks if the ACM version is v1.9.2 or later, which
 // has the high-level syncing condition.
 func (c *ClusterClient) syncingConditionSupported(ctx context.Context) bool {

cmd/nomos/status/cluster_state.go

@@ -24,7 +24,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"kpt.dev/configsync/cmd/nomos/util"
-	v1 "kpt.dev/configsync/pkg/api/configmanagement/v1"
 	"kpt.dev/configsync/pkg/api/configsync"
 	"kpt.dev/configsync/pkg/api/configsync/v1beta1"
 	"kpt.dev/configsync/pkg/reposync"
@@ -197,112 +196,6 @@ func helmString(helm *v1beta1.HelmBase) string {
 	return helmStr
 }
 
-// monoRepoStatus converts the given Git config and mono-repo status into a RepoState.
-func monoRepoStatus(git *v1beta1.Git, status v1.RepoStatus) *RepoState {
-	errors := syncStatusErrors(status)
-	totalErrorCount := len(errors)
-
-	result := &RepoState{
-		scope:  "<root>",
-		git:    git,
-		status: getSyncStatus(status),
-		commit: commitHash(status.Sync.LatestToken),
-		errors: errors,
-	}
-
-	if totalErrorCount > 0 {
-		result.errorSummary = &v1beta1.ErrorSummary{
-			TotalCount:                totalErrorCount,
-			Truncated:                 false,
-			ErrorCountAfterTruncation: totalErrorCount,
-		}
-	}
-	return result
-}
-
-// getSyncStatus returns the given RepoStatus formatted as a short summary string.
-func getSyncStatus(status v1.RepoStatus) string {
-	if hasErrors(status) {
-		return util.ErrorMsg
-	}
-	if len(status.Sync.LatestToken) == 0 {
-		return pendingMsg
-	}
-	if status.Sync.LatestToken == status.Source.Token && len(status.Sync.InProgress) == 0 {
-		return syncedMsg
-	}
-	return pendingMsg
-}
-
-// hasErrors returns true if there are any config management errors present in the given RepoStatus.
-func hasErrors(status v1.RepoStatus) bool {
-	if len(status.Import.Errors) > 0 {
-		return true
-	}
-	for _, syncStatus := range status.Sync.InProgress {
-		if len(syncStatus.Errors) > 0 {
-			return true
-		}
-	}
-	return false
-}
-
-// syncStatusErrors returns all errors reported in the given RepoStatus as a single array.
-func syncStatusErrors(status v1.RepoStatus) []string {
-	var errs []string
-	for _, err := range status.Source.Errors {
-		errs = append(errs, err.ErrorMessage)
-	}
-	for _, err := range status.Import.Errors {
-		errs = append(errs, err.ErrorMessage)
-	}
-	for _, syncStatus := range status.Sync.InProgress {
-		for _, err := range syncStatus.Errors {
-			errs = append(errs, err.ErrorMessage)
-		}
-	}
-
-	if getResourceStatus(status.Sync.ResourceConditions) != v1.ResourceStateHealthy {
-		errs = append(errs, getResourceStatusErrors(status.Sync.ResourceConditions)...)
-	}
-
-	return errs
-}
-
-func getResourceStatus(resourceConditions []v1.ResourceCondition) v1.ResourceConditionState {
-	resourceStatus := v1.ResourceStateHealthy
-
-	for _, resourceCondition := range resourceConditions {
-
-		if resourceCondition.ResourceState.IsError() {
-			return v1.ResourceStateError
-		} else if resourceCondition.ResourceState.IsReconciling() {
-			resourceStatus = v1.ResourceStateReconciling
-		}
-	}
-
-	return resourceStatus
-}
-
-func getResourceStatusErrors(resourceConditions []v1.ResourceCondition) []string {
-	if len(resourceConditions) == 0 {
-		return nil
-	}
-
-	var syncErrors []string
-
-	for _, resourceCondition := range resourceConditions {
-		for _, rcError := range resourceCondition.Errors {
-			syncErrors = append(syncErrors, fmt.Sprintf("%v\t%v\tError: %v", resourceCondition.Kind, resourceCondition.NamespacedName, rcError))
-		}
-		for _, rcReconciling := range resourceCondition.ReconcilingReasons {
-			syncErrors = append(syncErrors, fmt.Sprintf("%v\t%v\tReconciling: %v", resourceCondition.Kind, resourceCondition.NamespacedName, rcReconciling))
-		}
-	}
-
-	return syncErrors
-}
-
 // namespaceRepoStatus converts the given RepoSync into a RepoState.
 func namespaceRepoStatus(rs *v1beta1.RepoSync, rg *unstructured.Unstructured, syncingConditionSupported bool) *RepoState {
 	repostate := &RepoState{

cmd/nomos/status/cluster_state_test.go

@@ -23,7 +23,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"kpt.dev/configsync/cmd/nomos/util"
-	v1 "kpt.dev/configsync/pkg/api/configmanagement/v1"
 	"kpt.dev/configsync/pkg/api/configsync"
 	"kpt.dev/configsync/pkg/api/configsync/v1beta1"
 	"kpt.dev/configsync/pkg/core"
@@ -359,86 +358,6 @@ func TestRepoState_PrintRows(t *testing.T) {
 	}
 }
 
-func TestRepoState_MonoRepoStatus(t *testing.T) {
-	testCases := []struct {
-		name   string
-		git    *v1beta1.Git
-		status v1.RepoStatus
-		want   *RepoState
-	}{
-		{
-			"repo is pending first sync",
-			git,
-			v1.RepoStatus{
-				Source: v1.RepoSourceStatus{},
-				Import: v1.RepoImportStatus{},
-				Sync:   v1.RepoSyncStatus{},
-			},
-			&RepoState{
-				scope:  "<root>",
-				git:    git,
-				status: "PENDING",
-				commit: "N/A",
-			},
-		},
-		{
-			"repo is synced",
-			git,
-			v1.RepoStatus{
-				Source: v1.RepoSourceStatus{
-					Token: "abc123",
-				},
-				Import: v1.RepoImportStatus{
-					Token: "abc123",
-				},
-				Sync: v1.RepoSyncStatus{
-					LatestToken: "abc123",
-				},
-			},
-			&RepoState{
-				scope:  "<root>",
-				git:    git,
-				status: "SYNCED",
-				commit: "abc123",
-			},
-		},
-		{
-			"repo has errors",
-			git,
-			v1.RepoStatus{
-				Source: v1.RepoSourceStatus{
-					Token: "def456",
-				},
-				Import: v1.RepoImportStatus{
-					Token: "def456",
-					Errors: []v1.ConfigManagementError{
-						{ErrorMessage: "KNV2010: I am unhappy"},
-					},
-				},
-				Sync: v1.RepoSyncStatus{
-					LatestToken: "abc123",
-				},
-			},
-			&RepoState{
-				scope:        "<root>",
-				git:          git,
-				status:       "ERROR",
-				commit:       "abc123",
-				errors:       []string{"KNV2010: I am unhappy"},
-				errorSummary: errorSummayWithOneError,
-			},
-		},
-	}
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			got := monoRepoStatus(tc.git, tc.status)
-			if diff := cmp.Diff(tc.want, got, cmp.AllowUnexported(*tc.want)); diff != "" {
-				t.Error(diff)
-			}
-		})
-	}
-}
-
 func toGitStatus(git *v1beta1.Git) *v1beta1.GitStatus {
 	return &v1beta1.GitStatus{
 		Repo:     git.Repo,

cmd/nomos/status/status.go

@@ -139,22 +139,18 @@ func clusterNames(clientMap map[string]*ClusterClient) []string {
 }
 
 // clusterStates returns a map of clusterStates calculated from the given map of
-// clients, and a list of clusters running in the mono-repo mode.
-func clusterStates(ctx context.Context, clientMap map[string]*ClusterClient) (map[string]*ClusterState, []string) {
+// clients
+func clusterStates(ctx context.Context, clientMap map[string]*ClusterClient) map[string]*ClusterState {
 	stateMap := make(map[string]*ClusterState)
-	var monoRepoClusters []string
 	for name, client := range clientMap {
 		if client == nil {
 			stateMap[name] = unavailableCluster(name)
 		} else {
 			cs := client.clusterStatus(ctx, name, namespace)
 			stateMap[name] = cs
-			if cs.isMulti != nil && !*cs.isMulti {
-				monoRepoClusters = append(monoRepoClusters, name)
-			}
 		}
 	}
-	return stateMap, monoRepoClusters
+	return stateMap
 }
 
 // printStatus fetches ConfigManagementStatus and/or RepoStatus from each cluster in the given map
@@ -163,10 +159,7 @@ func clusterStates(ctx context.Context, clientMap map[string]*ClusterClient) (ma
 // nolint:errcheck
 func printStatus(ctx context.Context, writer *tabwriter.Writer, clientMap map[string]*ClusterClient, names []string) {
 	// First build up a map of all the states to display.
-	stateMap, monoRepoClusters := clusterStates(ctx, clientMap)
-
-	// Log a notice for the detected clusters that are running in the mono-repo mode.
-	util.MonoRepoNotice(writer, monoRepoClusters...)
+	stateMap := clusterStates(ctx, clientMap)
 
 	currentContext, err := restconfig.CurrentContextName()
 	if err != nil {

cmd/nomos/util/util.go

@@ -17,7 +17,6 @@ package util
 import (
 	"fmt"
 	"io"
-	"strings"
 )
 
 const (
@@ -40,21 +39,6 @@ const (
 	ColorCyan = "\033[36m"
 )
 
-// MonoRepoNotice logs a notice for the clusters that are running in the legacy mode.
-func MonoRepoNotice(writer io.Writer, monoRepoClusters ...string) {
-	clusterCount := len(monoRepoClusters)
-	if clusterCount != 0 {
-		if clusterCount == 1 {
-			MustFprintf(writer, "%sNotice: The cluster %q is still running in the legacy mode.\n",
-				ColorYellow, monoRepoClusters[0])
-		} else {
-			MustFprintf(writer, "%sNotice: The following clusters are still running in the legacy mode:\n%s%s\n",
-				ColorYellow, Bullet, strings.Join(monoRepoClusters, "\n"+Bullet))
-		}
-		MustFprintf(writer, "Run `nomos migrate` to enable multi-repo mode. It provides you with additional features and gives you the flexibility to sync to a single repository, or multiple repositories.%s\n", ColorDefault)
-	}
-}
-
 // MustFprintf prints a formatted string to the writer and panics on error.
 func MustFprintf(w io.Writer, format string, a ...any) {
 	if _, err := fmt.Fprintf(w, format, a...); err != nil {