finished building the skeleton for the plugin, can now work on the argocd plugin itself. also moved it to external pkg incase anyone wants to use this skeleton themselves

Author: UrielCohen456

cmd/argocd-plugin/main.go

@@ -7,7 +7,7 @@ import (
 	"k8s.io/client-go/rest"
 
 	"github.com/UrielCohen456/argo-workflows-argocd-executor-plugin/common"
-	plugin "github.com/UrielCohen456/argo-workflows-argocd-executor-plugin/internal/argocd-plugin"
+	"github.com/UrielCohen456/argo-workflows-argocd-executor-plugin/pkg/plugin"
 )
 
 func main() {
@@ -21,6 +21,6 @@ func main() {
 		panic(err.Error())
 	}
 
-	http.HandleFunc("/api/v1/template.execute",  plugin.ArgocdPlugin(client, common.Namespace()))
-	http.ListenAndServe(":4355", nil)
+	http.HandleFunc("/api/v1/template.execute", plugin.ArgocdPlugin(client, common.Namespace()))
+	http.ListenAndServe(":3000", nil)
 }

deployments/plugin.yaml

@@ -13,7 +13,7 @@ spec:
       name: argocd-executor-plugin
       image: urielc12/argocd-plugin
       ports:
-        - containerPort: 4355
+        - containerPort: 3000
       resources:
         requests:
           cpu: 100m

internal/argocd-plugin/plugin.go

@@ -0,0 +1,26 @@
+package argocd
+
+
+
+// output, err := exec.Command("argocd").Output()
+// if err!=nil {
+// 		fmt.Println(err.Error())
+// }
+// fmt.Println(string(output))
+
+// pods, err := clientSet.CoreV1().Pods(ctx.Value("namespace").(string)).List(ctx, metav1.ListOptions{})
+// if err != nil {
+// 	panic(err.Error())
+// }
+// fmt.Printf("There are %d pods in the cluster\n", len(pods.Items))
+
+// _, err = clientSet.CoreV1().Pods("default").Get(ctx, "example-xxxxx", metav1.GetOptions{})
+// if errors.IsNotFound(err) {
+// 	fmt.Printf("Pod example-xxxxx not found in default namespace\n")
+// } else if statusError, isStatus := err.(*errors.StatusError); isStatus {
+// 	fmt.Printf("Error getting pod %v\n", statusError.ErrStatus.Message)
+// } else if err != nil {
+// 	panic(err.Error())
+// } else {
+// 	fmt.Printf("Found example-xxxxx pod in default namespace\n")
+// }

internal/argocd.go

@@ -1,4 +1,4 @@
-package types
+package argocd
 
 // wfv1 "github.com/argoproj/argo-workflows/v3/pkg/apis/workflow/v1alpha1"
 //  "github.com/argoproj/argo-workflows/v3/pkg/plugins/executor"

internal/types.go

@@ -0,0 +1,68 @@
+package plugin
+
+import (
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"log"
+	"net/http"
+
+	"k8s.io/client-go/kubernetes"
+	// metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	executor "github.com/argoproj/argo-workflows/v3/pkg/plugins/executor"
+)
+
+var (
+	ErrWrongContentType		= errors.New("Content-Type header is not set to 'appliaction/json'")
+	ErrReadingBody		 		= errors.New("Couldn't read request body")
+	ErrMarshallingBody		= errors.New("Couldn't unmrashal request body")
+	ErrExecutingPlugin 		= errors.New("Error occured while executing plugin")
+)
+
+// The plugin's logic
+type PluginExecutor interface {
+	// Executes commands based on the args provided from the workflow
+	Execute(args executor.ExecuteTemplateArgs) (executor.ExecuteTemplateResponse, error)
+} 
+
+func ArgocdPlugin(plugin PluginExecutor, kubeClient kubernetes.Interface, namespace string) func(w http.ResponseWriter, req *http.Request) {
+	return func(w http.ResponseWriter, req *http.Request) {
+		if header := req.Header.Get("Content-Type"); header == "" || header != "application/json" {
+			log.Print(ErrWrongContentType)
+			http.Error(w, ErrWrongContentType.Error(), http.StatusBadRequest)
+			return
+		}
+
+		body, err := ioutil.ReadAll(req.Body)
+		if err != nil {
+			log.Printf("%v: %v", ErrReadingBody.Error(), err)
+			http.Error(w, ErrReadingBody.Error(), http.StatusBadRequest)
+			return
+		}
+
+		args := executor.ExecuteTemplateArgs{}
+		if err := json.Unmarshal(body, &args); err != nil || args.Workflow == nil || args.Template == nil {
+			log.Printf("%v: %v", ErrMarshallingBody.Error(), err)
+			http.Error(w, ErrMarshallingBody.Error(), http.StatusBadRequest)
+			return
+		}
+
+		resp, err := plugin.Execute(args)
+		if err != nil {
+			log.Printf("%v: %v", ErrExecutingPlugin.Error(), err)
+			http.Error(w, ErrExecutingPlugin.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		jsonResp, err := json.Marshal(resp)
+		if err != nil {
+			log.Printf("Error marshalling result: %v", err)
+			http.Error(w, "something went wrong", http.StatusBadRequest)
+		}
+
+		w.WriteHeader(http.StatusOK)
+		w.Write(jsonResp)
+		return
+	}
+}

pkg/.keep

@@ -1,4 +1,4 @@
-package argocd
+package plugin
 
 import (
 	"bytes"
@@ -10,13 +10,31 @@ import (
 	"testing"
 
 	"github.com/UrielCohen456/argo-workflows-argocd-executor-plugin/common"
+	"github.com/argoproj/argo-workflows/v3/pkg/plugins/executor"
 	"k8s.io/client-go/kubernetes/fake"
 )
 
 var (
 	headerEmpty				 			= map[string]string{}
 	headerContentJson 			= map[string]string{"Content-Type": "application/json"}
 	headerContentEncoded		= map[string]string{"Content-Type": "application/x-www-form-urlencoded"}
+	validWorkflowBody 			= []byte(
+`{
+  "workflow": {
+	  "metadata": {
+      "name": "test-template"
+    }
+  },
+  "template": {
+    "name": "plugin",
+    "inputs": {},
+    "outputs": {},
+    "plugin": {
+      "any": {
+      }
+    }
+	}
+}`)
 )
 
 type errReader int
@@ -25,12 +43,29 @@ func (errReader) Read(p []byte) (n int, err error) {
     return 0, errors.New("Read error")
 }
 
+type executorSpy struct {
+
+	Called 	bool
+	Fail		bool
+}
+
+func (e *executorSpy) Execute(args executor.ExecuteTemplateArgs) (executor.ExecuteTemplateResponse, error) {
+	var err error = nil
+
+	if e.Fail {
+		err = ErrExecutingPlugin
+	}
+	e.Called = true
+
+	return executor.ExecuteTemplateResponse{}, err
+}
+
 func TestArgocdPlugin(t *testing.T) {
-	// test trying to invoke execute on argocd action
 	// test returning currect result based on input
 
 	kubeClient := fake.NewSimpleClientset()
-	argocdPlugin := ArgocdPlugin(kubeClient, "argo")
+  spy := executorSpy{}
+	argocdPlugin := ArgocdPlugin(&spy, kubeClient, "argo")
 	handler := http.HandlerFunc(argocdPlugin)
 
 	var failTests = []struct {
@@ -80,38 +115,47 @@ func TestArgocdPlugin(t *testing.T) {
 			handler.ServeHTTP(response, request)
 
 			got := strings.Trim(response.Body.String(), "\n")
-			gotStatus := response.Code
+			gotStatus := response.Result().StatusCode
 
 			common.AssertResponseBody(t, got, tt.want)
 			common.AssertStatus(t, gotStatus, tt.status)
 		})
 	}
 
-  t.Run("succeed marshalling body and execute the request", func(t *testing.T) {
-    body := bytes.NewReader([]byte(
-`{
-  "workflow": {
-	  "metadata": {
-      "name": "test-template"
-    }
-  },
-  "template": {
-    "name": "argocd-plugin",
-    "inputs": {},
-    "outputs": {},
-    "plugin": {
-      "argocd": {
-      }
-    }
+	var execTests = []struct {
+		name string
+		fail bool
+		status int
+	}{
+		{
+			name: "exec without fail",
+			fail: false,
+			status: http.StatusOK,
+		},
+		{
+			name: "exec fails",
+			fail: true,
+			status: http.StatusInternalServerError,
+		},
 	}
-}`))
-    request, _ := http.NewRequest(http.MethodPost, "/api/v1/template.execute", body)
-    request.Header.Set("Content-Type", "application/json")
-    response := httptest.NewRecorder()
-    handler.ServeHTTP(response, request)
-    
-    got := response.Code
-
-    common.AssertStatus(t, got, http.StatusOK)
-  })
+
+	body := validWorkflowBody
+	for _, tt := range execTests {
+		t.Run(tt.name, func(t *testing.T) {
+			spy.Called = false
+			spy.Fail = tt.fail
+			request, _ := http.NewRequest(http.MethodPost, "/api/v1/template.execute", bytes.NewReader(body))
+			request.Header.Set("Content-Type", "application/json")
+			response := httptest.NewRecorder()
+			handler.ServeHTTP(response, request)
+			
+			if !spy.Called && !tt.fail {
+				t.Error("Executor was not called")
+			}
+
+			got := response.Result().StatusCode
+
+			common.AssertStatus(t, got, tt.status)
+		})
+  }
 }