Feat: added API for updated Application details page (#23)

* added new api for application details page using application CR

* provide commit info - author, message and commit hash

* fixed https client

* added unit tests

Author: Shubhama19

pkg/httpapi/api.go

@@ -1,16 +1,20 @@
 package httpapi
 
 import (
+	"bytes"
 	"context"
+	"crypto/tls"
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"net/http"
 	"net/url"
 	"strings"
 
 	argoV1aplha1 "github.com/argoproj/argo-cd/pkg/apis/application/v1alpha1"
 	"github.com/julienschmidt/httprouter"
+	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/types"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/yaml"
@@ -26,7 +30,13 @@ var DefaultSecretRef = types.NamespacedName{
 	Namespace: "pipelines-app-delivery",
 }
 
-const defaultRef = "HEAD"
+const (
+	defaultRef             = "HEAD"
+	defaultArgoCDInstance  = "openshift-gitops"
+	defaultArgocdNamespace = "openshift-gitops"
+)
+
+var baseURL = fmt.Sprintf("https://%s-server.%s.svc.cluster.local", defaultArgoCDInstance, defaultArgocdNamespace)
 
 // APIRouter is an HTTP API for accessing app configurations.
 type APIRouter struct {
@@ -51,9 +61,16 @@ func NewRouter(c git.ClientFactory, s secrets.SecretGetter, kc ctrlclient.Client
 	api.HandlerFunc(http.MethodGet, "/pipelines", api.GetPipelines)
 	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)
 	return api
 }
 
+type RevisionMeta struct {
+	Author   string `json:"author"`
+	Message  string `json:"message"`
+	Revision string `json:"revision"`
+}
+
 // GetPipelines fetches and returns the pipeline body.
 func (a *APIRouter) GetPipelines(w http.ResponseWriter, r *http.Request) {
 	urlToFetch := r.URL.Query().Get("url")
@@ -201,6 +218,86 @@ func (a *APIRouter) ListApplications(w http.ResponseWriter, r *http.Request) {
 	marshalResponse(w, applicationsToAppsResponse(apps, parsedRepoURL.String()))
 }
 
+func (a *APIRouter) GetApplicationDetails(w http.ResponseWriter, r *http.Request) {
+	params := httprouter.ParamsFromContext(r.Context())
+	envName, appName := params.ByName("env"), params.ByName("app")
+	app := &argoV1aplha1.Application{}
+	var lastDeployed, revision string
+
+	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
+	}
+
+	if len(app.Status.History) > 0 {
+		revision = app.Status.History[len(app.Status.History)-1].Revision
+		t := app.Status.History[len(app.Status.History)-1].DeployedAt
+		if !t.IsZero() {
+			lastDeployed = 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)
+		return
+	}
+
+	revisionMeta := RevisionMeta{
+		Author:   strings.Split(commitInfo["author"], " ")[0],
+		Message:  commitInfo["message"],
+		Revision: revision,
+	}
+
+	appEnv := map[string]interface{}{
+		"environment":  app.Spec.Destination.Namespace,
+		"cluster":      app.Spec.Destination.Server,
+		"lastDeployed": lastDeployed,
+		"status":       app.Status.Sync.Status,
+		"revision":     revisionMeta,
+	}
+
+	marshalResponse(w, appEnv)
+}
+
 func (a *APIRouter) getAuthToken(ctx context.Context, req *http.Request) (string, error) {
 	token := AuthToken(ctx)
 	secret, ok := secretRefFromQuery(req.URL.Query())
@@ -253,3 +350,72 @@ func marshalResponse(w http.ResponseWriter, v interface{}) {
 		log.Printf("failed to encode response: %s", err)
 	}
 }
+
+func (a *APIRouter) getCommitInfo(app, revision string) (map[string]string, error) {
+	client := &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}}
+	argocdCreds := &corev1.Secret{}
+	err := a.k8sClient.Get(context.TODO(),
+		types.NamespacedName{
+			Name:      defaultArgoCDInstance + "-cluster",
+			Namespace: defaultArgocdNamespace,
+		}, argocdCreds)
+	if err != nil {
+		return nil, err
+	}
+
+	payload := map[string]string{
+		"username": "admin",
+		"password": string(argocdCreds.Data["admin.password"]),
+	}
+	payloadBytes, err := json.Marshal(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := client.Post(fmt.Sprintf("%s/api/v1/session", baseURL),
+		"application/json", bytes.NewBuffer(payloadBytes))
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	bodyBytes, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	m := make(map[string]string)
+	err = json.Unmarshal(bodyBytes, &m)
+	if err != nil {
+		return nil, err
+	}
+
+	if token, ok := m["token"]; !ok || token == "" {
+		return nil, fmt.Errorf("failed to retrieve JWT from the api-server")
+	}
+
+	u := fmt.Sprintf("%s/api/v1/applications/%s/revisions/%s/metadata", baseURL, app, revision)
+	req, err := http.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", m["token"]))
+	req.Header.Add("content-type", "application/json")
+
+	resp, err = client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+
+	defer resp.Body.Close()
+	bodyBytes, err = ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal(bodyBytes, &m)
+	if err != nil {
+		return nil, err
+	}
+	return m, nil
+}

pkg/httpapi/api_test.go

@@ -19,6 +19,8 @@ import (
 	"github.com/redhat-developer/gitops-backend/pkg/git"
 	"github.com/redhat-developer/gitops-backend/pkg/parser"
 	"github.com/redhat-developer/gitops-backend/test"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/kubernetes/scheme"
 	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"
@@ -400,6 +402,88 @@ func TestListApplications_badURL(t *testing.T) {
 	assertHTTPError(t, resp, http.StatusBadRequest, "please provide a valid GitOps repo URL")
 }
 
+func TestGetApplicationDetails(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/application.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/environment/%s/application/%s?%s", ts.URL, "dev", "test-app", options.Encode()))
+	res, err := ts.Client().Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assertJSONResponse(t, res, map[string]interface{}{
+		"cluster":      "https://kubernetes.default.svc",
+		"environment":  "dev",
+		"status":       "Synced",
+		"lastDeployed": time.Date(2021, time.Month(5), 15, 2, 12, 13, 0, time.UTC).Local().String(),
+		"revision": map[string]interface{}{
+			"author":   "test",
+			"message":  "testMessage",
+			"revision": "123456789",
+		},
+	})
+
+	//reset BaseURL
+	baseURL = tmp
+}
+
 func testArgoApplication(appCr string) (*argoV1aplha1.Application, error) {
 	applicationYaml, _ := ioutil.ReadFile(appCr)
 	app := &argoV1aplha1.Application{}

pkg/httpapi/conversion.go

@@ -39,7 +39,7 @@ func applicationsToAppsResponse(appSet []*argoV1aplha1.Application, repoURL stri
 
 	for _, app := range appSet {
 		if repoURL != strings.TrimSuffix(app.Spec.Source.RepoURL, ".git") {
-			log.Printf("repoURL[%v], doesn not match with Source Repo URL[%v]", repoURL, strings.TrimSuffix(app.Spec.Source.RepoURL, ".git"))
+			log.Printf("repoURL[%v], does not match with Source Repo URL[%v]", repoURL, strings.TrimSuffix(app.Spec.Source.RepoURL, ".git"))
 			continue
 		}
 		if app.ObjectMeta.Labels != nil {

pkg/httpapi/testdata/application.yaml

@@ -16,5 +16,6 @@ spec:
 status:
   history:
     - deployedAt: "2021-05-15T02:12:13Z"
+      revision: "123456789"
   sync:
     status: Synced