feat: remove legacy monorepo-related code

Author: Camila-B

cmd/nomos/status/client.go

@@ -164,67 +164,10 @@ func (c *ClusterClient) clusterStatus(ctx context.Context, cluster, namespace st
 		cs.Error = c.namespaceRepoClusterStatus(ctx, cs, namespace)
 	} else if isOss || (cs.isMulti != nil && *cs.isMulti) {
 		c.multiRepoClusterStatus(ctx, cs)
-	} else {
-		c.monoRepoClusterStatus(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

@@ -148,9 +148,10 @@ func clusterStates(ctx context.Context, clientMap map[string]*ClusterClient) (ma
 			stateMap[name] = unavailableCluster(name)
 		} else {
 			cs := client.clusterStatus(ctx, name, namespace)
-			stateMap[name] = cs
 			if cs.isMulti != nil && !*cs.isMulti {
 				monoRepoClusters = append(monoRepoClusters, name)
+			} else {
+				stateMap[name] = cs
 			}
 		}
 	}

pkg/bugreport/bugreport.go

@@ -65,7 +65,7 @@ const (
 // bug report
 type BugReporter struct {
 	client    client.Reader
-	clientSet *kubernetes.Clientset
+	clientSet kubernetes.Interface
 	cm        *unstructured.Unstructured
 	enabled   map[Product]bool
 	util.ConfigManagementClient
@@ -79,7 +79,7 @@ type BugReporter struct {
 }
 
 // New creates a new BugReport
-func New(ctx context.Context, c client.Client, cs *kubernetes.Clientset) (*BugReporter, error) {
+func New(ctx context.Context, c client.Client, cs kubernetes.Interface) (*BugReporter, error) {
 	cm := &unstructured.Unstructured{}
 	cm.SetGroupVersionKind(schema.GroupVersionKind{
 		Group: configmanagement.GroupName,
@@ -94,22 +94,23 @@ func New(ctx context.Context, c client.Client, cs *kubernetes.Clientset) (*BugRe
 		errorList = append(errorList, err)
 	}
 
-	if err := c.Get(ctx, types.NamespacedName{Name: util.ConfigManagementName}, cm); err != nil {
+	err = c.Get(ctx, types.NamespacedName{Name: util.ConfigManagementName}, cm)
+
+	if err != nil {
 		if meta.IsNoMatchError(err) {
 			fmt.Println("kind <<" + configmanagement.OperatorKind + ">> is not registered with the cluster")
 		} else if errors.IsNotFound(err) {
 			fmt.Println("ConfigManagement object not found")
 		} else {
 			errorList = append(errorList, err)
 		}
-	}
-
-	isMulti, _, err := unstructured.NestedBool(cm.UnstructuredContent(), "spec", "enableMultiRepo")
-	if err != nil {
-		fmt.Println("ConfigManagement parsing error", err)
-	}
-	if !isMulti {
-		util.MonoRepoNotice(os.Stdout, currentk8sContext)
+	} else {
+		isMulti, _, err := unstructured.NestedBool(cm.UnstructuredContent(), "spec", "enableMultiRepo")
+		if err != nil {
+			fmt.Println("ConfigManagement parsing error", err)
+		} else if !isMulti {
+			util.MonoRepoNotice(os.Stdout, currentk8sContext)
+		}
 	}
 
 	return &BugReporter{
@@ -282,7 +283,7 @@ type resourcesToReadables func(*unstructured.UnstructuredList, string) []Readabl
 // fetchResources provides a set of Readables for resources with a given group and version
 // toReadables: the function that converts the resources to readables.
 func (b *BugReporter) fetchResources(ctx context.Context, gv schema.GroupVersion, toReadables resourcesToReadables) (rd []Readable) {
-	rl, err := b.clientSet.ServerResourcesForGroupVersion(gv.String())
+	rl, err := b.clientSet.Discovery().ServerResourcesForGroupVersion(gv.String())
 	if err != nil {
 		if errors.IsNotFound(err) {
 			fmt.Printf("No %s resources found on cluster\n", gv.Group)