send metadata command

Author: pasha-codefresh

cmd/processResult/process_result.go

@@ -0,0 +1,46 @@
+package processResult
+
+import (
+	argo "cf-argo-plugin/pkg/argo"
+	codefresh "cf-argo-plugin/pkg/codefresh"
+	"cf-argo-plugin/pkg/context"
+	"github.com/spf13/cobra"
+)
+
+var processResultArgsOptions struct {
+	PipelineId string
+}
+
+var Cmd = &cobra.Command{
+	Use:   "process-result [app]",
+	Short: "Process plugin execution result",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		name := args[0]
+
+		argoApi := argo.Argo{
+			Host:     context.PluginArgoCredentials.Host,
+			Username: context.PluginArgoCredentials.Username,
+			Password: context.PluginArgoCredentials.Password,
+		}
+
+		revision, _ := argoApi.GetLatestHistoryRevision(name)
+
+		cf := codefresh.New(&codefresh.ClientOptions{
+			Token: context.PluginCodefreshCredentials.Token,
+			Host:  context.PluginCodefreshCredentials.Host,
+		})
+
+		_ = cf.SendMetadata(&codefresh.ArgoApplicationMetadata{
+			PipelineId:      processResultArgsOptions.PipelineId,
+			Revision:        revision,
+			ApplicationName: name,
+		})
+
+		return nil
+	},
+}
+
+func init() {
+	f := Cmd.Flags()
+	f.StringVar(&processResultArgsOptions.PipelineId, "pipeline-id", "", "Pipeline id where argo sync was executed")
+}

cmd/root/root.go

@@ -1,6 +1,7 @@
 package root
 
 import (
+	"cf-argo-plugin/cmd/processResult"
 	"cf-argo-plugin/cmd/rollout"
 	"cf-argo-plugin/cmd/runTask"
 	"cf-argo-plugin/cmd/sync"
@@ -53,6 +54,8 @@ func init() {
 	rootCmd.AddCommand(sync.Cmd)
 	rootCmd.AddCommand(rollout.Cmd)
 	rootCmd.AddCommand(runTask.Cmd)
+	rootCmd.AddCommand(processResult.Cmd)
+
 }
 
 func fetchArgoCredentials(cmd *cobra.Command, args []string) error {

go.sum

@@ -37,6 +37,7 @@ github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmg
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=

pkg/argo/api.go

@@ -0,0 +1,121 @@
+package argo
+
+import (
+	"bytes"
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+func buildHttpClient() *http.Client {
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	}
+	return &http.Client{Transport: tr}
+}
+
+type Argo struct {
+	Host     string
+	Username string
+	Password string
+}
+
+type requestOptions struct {
+	path   string
+	method string
+}
+
+type History struct {
+	Status struct {
+		History []struct {
+			Revision string `json:"revision"`
+		} `json:"history"`
+	} `json:"status"`
+}
+
+func (c *Argo) GetLatestHistoryRevision(application string) (string, error) {
+
+	options := &requestOptions{
+		path:   "/api/v1/applications/" + application,
+		method: "GET",
+	}
+
+	result := &History{}
+	_ = c.requestAPI(options, result)
+
+	historyList := result.Status.History
+	return historyList[len(historyList)-1].Revision, nil
+}
+
+func (c *Argo) getToken() string {
+
+	client := buildHttpClient()
+
+	message := map[string]interface{}{
+		"username": c.Username,
+		"password": c.Password,
+	}
+
+	bytesRepresentation, err := json.Marshal(message)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	resp, err := client.Post(c.Host+"/api/v1/session", "application/json", bytes.NewBuffer(bytesRepresentation))
+	if err != nil {
+		fmt.Println(err)
+	}
+	var result map[string]interface{}
+
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	defer resp.Body.Close()
+
+	return result["token"].(string)
+}
+
+func (c *Argo) requestAPI(opt *requestOptions, target interface{}) error {
+	token := c.getToken()
+
+	client := buildHttpClient()
+
+	var body []byte
+	finalURL := fmt.Sprintf("%s%s", c.Host, opt.path)
+
+	request, err := http.NewRequest(opt.method, finalURL, bytes.NewBuffer(body))
+
+	if err != nil {
+		return err
+	}
+
+	request.Header.Set("Authorization", "Bearer "+token)
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err := client.Do(request)
+
+	if err != nil {
+		return err
+	}
+
+	if response.StatusCode < 200 || response.StatusCode > 299 {
+		argoError := make(map[string]interface{})
+		err = json.NewDecoder(response.Body).Decode(argoError)
+
+		if err != nil {
+			return err
+		}
+
+		return fmt.Errorf("%d: %v", response.StatusCode, argoError)
+	}
+
+	defer response.Body.Close()
+
+	err = json.NewDecoder(response.Body).Decode(target)
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/codefresh/api.go

@@ -10,6 +10,7 @@ import (
 type Codefresh interface {
 	GetIntegration(name string) (*ArgoIntegration, error)
 	StartSyncTask(name string) (*TaskResult, error)
+	SendMetadata(metadata *ArgoApplicationMetadata) error
 	requestAPI(*requestOptions, interface{}) error
 }
 
@@ -31,6 +32,12 @@ type ArgoIntegration struct {
 	Data ArgoIntegrationData `json:"data"`
 }
 
+type ArgoApplicationMetadata struct {
+	PipelineId      string `json:"pipelineId"`
+	Revision        string `json:"revision"`
+	ApplicationName string `json:"name"`
+}
+
 type TaskResult struct {
 	BuildId string `json:"id"`
 }
@@ -45,6 +52,7 @@ type ArgoIntegrationData struct {
 type requestOptions struct {
 	path   string
 	method string
+	body   []byte
 }
 
 type codefresh struct {
@@ -75,6 +83,23 @@ func (c *codefresh) GetIntegration(name string) (*ArgoIntegration, error) {
 	return r, nil
 }
 
+func (c *codefresh) SendMetadata(metadata *ArgoApplicationMetadata) error {
+	metadataBytes := new(bytes.Buffer)
+	json.NewEncoder(metadataBytes).Encode(metadata)
+
+	err := c.requestAPI(&requestOptions{
+		path:   fmt.Sprintf("/api/environments-v2/argo/metadata"),
+		method: "POST",
+		body:   metadataBytes.Bytes(),
+	}, nil)
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 func (c *codefresh) StartSyncTask(name string) (*TaskResult, error) {
 	r := &TaskResult{}
 	err := c.requestAPI(&requestOptions{
@@ -90,10 +115,9 @@ func (c *codefresh) StartSyncTask(name string) (*TaskResult, error) {
 }
 
 func (c *codefresh) requestAPI(opt *requestOptions, target interface{}) error {
-	var body []byte
 	finalURL := fmt.Sprintf("%s%s", c.host, opt.path)
 
-	request, err := http.NewRequest(opt.method, finalURL, bytes.NewBuffer(body))
+	request, err := http.NewRequest(opt.method, finalURL, bytes.NewBuffer(opt.body))
 
 	if err != nil {
 		return err