feat: Backend to provide REST APIs can to pull sync history (#1890) (#26)

Signed-off-by: Keith Chong <[email protected]>

Co-authored-by: Chetan Banavikalmutt <[email protected]>

Author: keithchong

pkg/httpapi/api.go

@@ -70,6 +70,7 @@ func NewRouter(c git.ClientFactory, s secrets.SecretGetter, kc ctrlclient.Client
 	api.HandlerFunc(http.MethodGet, "/applications", api.ListApplications)
 	api.HandlerFunc(http.MethodGet, "/environments/:env/application/:app", api.GetApplication)
 	api.HandlerFunc(http.MethodGet, "/environment/:env/application/:app", api.GetApplicationDetails)
+	api.HandlerFunc(http.MethodGet, "/history/environment/:env/application/:app", api.GetApplicationHistory)
 	return api
 }
 
@@ -226,6 +227,80 @@ func (a *APIRouter) ListApplications(w http.ResponseWriter, r *http.Request) {
 	marshalResponse(w, applicationsToAppsResponse(apps, parsedRepoURL.String()))
 }
 
+func (a *APIRouter) GetApplicationHistory(w http.ResponseWriter, r *http.Request) {
+	params := httprouter.ParamsFromContext(r.Context())
+	envName, appName := params.ByName("env"), params.ByName("app")
+	app := &argoV1aplha1.Application{}
+
+	repoURL := strings.TrimSpace(r.URL.Query().Get("url"))
+	if repoURL == "" {
+		log.Println("ERROR: please provide a valid GitOps repo URL")
+		http.Error(w, "please provide a valid GitOps repo URL", http.StatusBadRequest)
+		return
+	}
+
+	parsedRepoURL, err := url.Parse(repoURL)
+	if err != nil {
+		log.Printf("ERROR: failed to parse URL, error: %v", err)
+		http.Error(w, fmt.Sprintf("failed to parse URL, error: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	parsedRepoURL.RawQuery = ""
+
+	appList := &argoV1aplha1.ApplicationList{}
+	var listOptions []ctrlclient.ListOption
+
+	listOptions = append(listOptions, ctrlclient.InNamespace(""), ctrlclient.MatchingFields{
+		"metadata.name": fmt.Sprintf("%s-%s", envName, appName),
+	})
+
+	err = a.k8sClient.List(r.Context(), appList, listOptions...)
+	if err != nil {
+		log.Printf("ERROR: failed to get application list: %v", err)
+		http.Error(w, fmt.Sprintf("failed to get list of application, err: %v", err), http.StatusBadRequest)
+		return
+	}
+
+	for _, a := range appList.Items {
+		if a.Spec.Source.RepoURL == parsedRepoURL.String() {
+			app = &a
+		}
+	}
+
+	if app == nil {
+		log.Printf("ERROR: failed to get application %s: %v", appName, err)
+		http.Error(w, fmt.Sprintf("failed to get the application %s, err: %v", appName, err), http.StatusBadRequest)
+		return
+	}
+
+	var deployedTime, revision string
+	hist := app.Status.History
+	var historyList = make([]envHistory, 0)
+	for _, h := range hist {
+		revision = h.Revision
+		t := h.DeployedAt
+		if !t.IsZero() {
+			deployedTime = t.String()
+		}
+		commitInfo, err := a.getCommitInfo(app.Name, revision)
+		if err != nil {
+			log.Printf("ERROR: failed to retrieve revision metadata for app %s: %v", appName, err)
+			http.Error(w, fmt.Sprintf("failed to retrieve revision metadata for app %s, err: %v", appName, err), http.StatusBadRequest)
+		}
+		hist := envHistory{
+			Author:      commitInfo["author"],
+			Message:     commitInfo["message"],
+			Revision:    revision,
+			RepoUrl:     h.Source.RepoURL,
+			Environment: envName,
+			DeployedAt:  deployedTime,
+		}
+		historyList = append([]envHistory{hist}, historyList...)
+	}
+	marshalResponse(w, historyList)
+}
+
 func (a *APIRouter) GetApplicationDetails(w http.ResponseWriter, r *http.Request) {
 	params := httprouter.ParamsFromContext(r.Context())
 	envName, appName := params.ByName("env"), params.ByName("app")

pkg/httpapi/api_test.go

@@ -509,6 +509,129 @@ func TestGetApplicationDetails(t *testing.T) {
 	baseURL = tmp
 }
 
+func TestGetApplicationHistory(t *testing.T) {
+	err := argoV1aplha1.AddToScheme(scheme.Scheme)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	builder := fake.NewClientBuilder()
+	kc := builder.Build()
+
+	ts, _ := makeServer(t, func(router *APIRouter) {
+		router.k8sClient = kc
+	})
+
+	// create test ArgoCD Server to handle http requests
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		u := r.URL.String()
+		if strings.Contains(u, "session") {
+			m := map[string]string{
+				"token": "testing",
+			}
+			marshalResponse(w, m)
+		} else if strings.Contains(u, "metadata") {
+			m := map[string]string{
+				"author":  "test",
+				"message": "testMessage",
+			}
+			marshalResponse(w, m)
+		}
+	}))
+	defer server.Close()
+	tmp := baseURL
+	baseURL = server.URL
+
+	var createOptions []ctrlclient.CreateOption
+	app, _ := testArgoApplication("testdata/application3.yaml")
+	// create argocd test-app
+	err = kc.Create(context.TODO(), app, createOptions...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// create argocd instance creds secret
+	secret := &corev1.Secret{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      defaultArgoCDInstance + "-cluster",
+			Namespace: defaultArgocdNamespace,
+		},
+		Data: map[string][]byte{
+			"admin.password": []byte("abc"),
+		},
+	}
+	err = kc.Create(context.TODO(), secret, createOptions...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	options := url.Values{
+		"url": []string{"https://github.com/test-repo/gitops.git"},
+	}
+	req := makeClientRequest(t, "Bearer testing",
+		fmt.Sprintf("%s/history/environment/%s/application/%s?%s", ts.URL, "dev", "app-taxi", options.Encode()))
+	res, err := ts.Client().Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fmt.Println("history res is ", res)
+
+	want := []envHistory{
+		{
+			Author:      "test",
+			Message:     "testMessage",
+			Revision:    "a0c7298faead28f7f60a5106afbb18882ad220a7",
+			Environment: "dev",
+			RepoUrl:     "https://github.com/test-repo/gitops.git",
+			DeployedAt:  time.Date(2022, time.Month(4), 22, 17, 11, 29, 0, time.UTC).Local().String(),
+		},
+		{
+			Author:      "test",
+			Message:     "testMessage",
+			Revision:    "3f6965bd65d9294b8fec5d6e2dc3dad08e33a8fe",
+			Environment: "dev",
+			RepoUrl:     "https://github.com/test-repo/gitops.git",
+			DeployedAt:  time.Date(2022, time.Month(4), 21, 14, 17, 49, 0, time.UTC).Local().String(),
+		},
+		{
+			Author:      "test",
+			Message:     "testMessage",
+			Revision:    "e5585fcf22366e2d066e0936cbd8a0508756d02d",
+			Environment: "dev",
+			RepoUrl:     "https://github.com/test-repo/gitops.git",
+			DeployedAt:  time.Date(2022, time.Month(4), 21, 14, 16, 51, 0, time.UTC).Local().String(),
+		},
+		{
+			Author:      "test",
+			Message:     "testMessage",
+			Revision:    "3f6965bd65d9294b8fec5d6e2dc3dad08e33a8fe",
+			Environment: "dev",
+			RepoUrl:     "https://github.com/test-repo/gitops.git",
+			DeployedAt:  time.Date(2022, time.Month(4), 21, 14, 16, 50, 0, time.UTC).Local().String(),
+		},
+		{
+			Author:      "test",
+			Message:     "testMessage",
+			Revision:    "e5585fcf22366e2d066e0936cbd8a0508756d02d",
+			Environment: "dev",
+			RepoUrl:     "https://github.com/test-repo/gitops.git",
+			DeployedAt:  time.Date(2022, time.Month(4), 21, 14, 14, 27, 0, time.UTC).Local().String(),
+		},
+		{
+			Author:      "test",
+			Message:     "testMessage",
+			Revision:    "e5585fcf22366e2d066e0936cbd8a0508756d02d",
+			Environment: "dev",
+			RepoUrl:     "https://github.com/test-repo/gitops.git",
+			DeployedAt:  time.Date(2022, time.Month(4), 19, 18, 19, 52, 0, time.UTC).Local().String(),
+		},
+	}
+	assertJSONResponseHistory(t, res, want)
+
+	//reset BaseURL
+	baseURL = tmp
+}
+
 func testArgoApplication(appCr string) (*argoV1aplha1.Application, error) {
 	applicationYaml, _ := ioutil.ReadFile(appCr)
 	app := &argoV1aplha1.Application{}
@@ -588,7 +711,7 @@ func makeServer(t *testing.T, opts ...routerOptionFunc) (*httptest.Server, *stub
 	return ts, sf.client
 }
 
-func assertJSONResponse(t *testing.T, res *http.Response, want map[string]interface{}) {
+func readBody(t *testing.T, res *http.Response) []byte {
 	t.Helper()
 	if res.StatusCode != http.StatusOK {
 		defer res.Body.Close()
@@ -609,9 +732,26 @@ func assertJSONResponse(t *testing.T, res *http.Response, want map[string]interf
 	if h := res.Header.Get("Access-Control-Allow-Origin"); h != "*" {
 		t.Fatalf("wanted '*' got %s", h)
 	}
+	return b
+}
+
+func assertJSONResponse(t *testing.T, res *http.Response, want map[string]interface{}) {
+	b := readBody(t, res)
 	got := map[string]interface{}{}
 
-	err = json.Unmarshal(b, &got)
+	err := json.Unmarshal(b, &got)
+	if err != nil {
+		t.Fatalf("failed to parse %s: %s", b, err)
+	}
+	if diff := cmp.Diff(want, got); diff != "" {
+		t.Fatalf("JSON response failed:\n%s", diff)
+	}
+}
+
+func assertJSONResponseHistory(t *testing.T, res *http.Response, want []envHistory) {
+	b := readBody(t, res)
+	got := make([]envHistory, 0)
+	err := json.Unmarshal(b, &got)
 	if err != nil {
 		t.Fatalf("failed to parse %s: %s", b, err)
 	}

pkg/httpapi/manifest.go

@@ -34,6 +34,15 @@ type envHealthResource struct {
 	Status string `json:"status,omitempty"`
 }
 
+type envHistory struct {
+	Author      string `json:"author,omitempty"`
+	Message     string `json:"message,omitempty"`
+	Revision    string `json:"revision,omitempty"`
+	Environment string `json:"environment,omitempty"`
+	RepoUrl     string `json:"repo_url,omitempty"`
+	DeployedAt  string `json:"deployed_at,omitempty"`
+}
+
 func (e environment) findService(n string) *service {
 	for _, a := range e.Apps {
 		for _, s := range a.Services {