add demo github pipeline to runtime installation (#119)

* added github demo pipeline to runtime install

Author: daniel-codefresh

Makefile

@@ -1,4 +1,4 @@
-VERSION=v0.0.111
+VERSION=v0.0.112
 OUT_DIR=dist
 YEAR?=$(shell date +"%Y")
 

cmd/commands/git-source.go

@@ -18,32 +18,36 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
-	apicommon "github.com/argoproj/argo-events/pkg/apis/common"
-	sensorreg "github.com/argoproj/argo-events/pkg/apis/sensor"
 	"github.com/codefresh-io/cli-v2/pkg/log"
 	"github.com/codefresh-io/cli-v2/pkg/runtime"
 	"github.com/codefresh-io/cli-v2/pkg/store"
 	"github.com/codefresh-io/cli-v2/pkg/util"
 	apu "github.com/codefresh-io/cli-v2/pkg/util/aputil"
+	ingressutil "github.com/codefresh-io/cli-v2/pkg/util/ingress"
 	wfutil "github.com/codefresh-io/cli-v2/pkg/util/workflow"
-	"github.com/juju/ansiterm"
 
 	apcmd "github.com/argoproj-labs/argocd-autopilot/cmd/commands"
 	"github.com/argoproj-labs/argocd-autopilot/pkg/application"
 	"github.com/argoproj-labs/argocd-autopilot/pkg/fs"
 	"github.com/argoproj-labs/argocd-autopilot/pkg/git"
 	apstore "github.com/argoproj-labs/argocd-autopilot/pkg/store"
 	aputil "github.com/argoproj-labs/argocd-autopilot/pkg/util"
+	apicommon "github.com/argoproj/argo-events/pkg/apis/common"
 	eventsourcereg "github.com/argoproj/argo-events/pkg/apis/eventsource"
 	eventsourcev1alpha1 "github.com/argoproj/argo-events/pkg/apis/eventsource/v1alpha1"
+	sensorreg "github.com/argoproj/argo-events/pkg/apis/sensor"
 	sensorsv1alpha1 "github.com/argoproj/argo-events/pkg/apis/sensor/v1alpha1"
 	wf "github.com/argoproj/argo-workflows/v3/pkg/apis/workflow"
 	wfv1alpha1 "github.com/argoproj/argo-workflows/v3/pkg/apis/workflow/v1alpha1"
+	"github.com/juju/ansiterm"
 	"github.com/spf13/cobra"
-	v1 "k8s.io/api/core/v1"
+	corev1 "k8s.io/api/core/v1"
+	netv1 "k8s.io/api/networking/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
 type (
@@ -74,6 +78,12 @@ type (
 		gsCloneOpts *git.CloneOptions
 		gsFs        fs.FS
 	}
+
+	gitSourceGithubExampleOptions struct {
+		runtimeName string
+		gsCloneOpts *git.CloneOptions
+		gsFs        fs.FS
+	}
 )
 
 func NewGitSourceCommand() *cobra.Command {
@@ -184,11 +194,20 @@ func RunGitSourceCreate(ctx context.Context, opts *GitSourceCreateOptions) error
 			return fmt.Errorf("failed to create cron example pipeline. Error: %w", err)
 		}
 
-		commitMsg := fmt.Sprintf("Created demo workflow template in %s Directory", opts.GsCloneOpts.Path())
+		err = createGithubExamplePipeline(&gitSourceGithubExampleOptions{
+			runtimeName: opts.RuntimeName,
+			gsCloneOpts: opts.GsCloneOpts,
+			gsFs:        gsFs,
+		})
+		if err != nil {
+			return fmt.Errorf("failed to create github example pipeline. Error: %w", err)
+		}
+
+		commitMsg := fmt.Sprintf("Created demo pipelines in %s Directory", opts.GsCloneOpts.Path())
 
-		log.G(ctx).Info("Pushing a demo workflow-template to the new git-source repo")
+		log.G(ctx).Info("Pushing demo pipelines to the new git-source repo")
 		if err := apu.PushWithMessage(ctx, gsRepo, commitMsg); err != nil {
-			return fmt.Errorf("failed to push demo workflow-template to git-source repo: %w", err)
+			return fmt.Errorf("failed to push demo pipelines to git-source repo: %w", err)
 		}
 	}
 
@@ -215,24 +234,7 @@ func createCronExamplePipeline(opts *gitSourceCronExampleOptions) error {
 	eventSourceFilePath := opts.gsFs.Join(opts.gsCloneOpts.Path(), store.Get().CronExampleEventSourceFileName)
 	sensorFilePath := opts.gsFs.Join(opts.gsCloneOpts.Path(), store.Get().CronExampleSensorFileName)
 
-	eventSource := &eventsourcev1alpha1.EventSource{
-		TypeMeta: metav1.TypeMeta{
-			Kind:       eventsourcereg.Kind,
-			APIVersion: eventsourcereg.Group + "/v1alpha1",
-		},
-		ObjectMeta: metav1.ObjectMeta{
-			Name: store.Get().CronExampleEventSourceName,
-		},
-		Spec: eventsourcev1alpha1.EventSourceSpec{
-			EventBusName: store.Get().EventBusName,
-			Calendar: map[string]eventsourcev1alpha1.CalendarEventSource{
-				store.Get().CronExampleEventName: {
-					Interval: "5m",
-				},
-			},
-		},
-	}
-
+	eventSource := createCronExampleEventSource()
 	err = opts.gsCloneOpts.FS.WriteYamls(eventSourceFilePath, eventSource)
 	if err != nil {
 		return fmt.Errorf("failed to write yaml of eventsource. Error: %w", err)
@@ -257,6 +259,26 @@ func createCronExamplePipeline(opts *gitSourceCronExampleOptions) error {
 	return nil
 }
 
+func createCronExampleEventSource() *eventsourcev1alpha1.EventSource {
+	return &eventsourcev1alpha1.EventSource{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       eventsourcereg.Kind,
+			APIVersion: eventsourcereg.Group + "/v1alpha1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: store.Get().CronExampleEventSourceName,
+		},
+		Spec: eventsourcev1alpha1.EventSourceSpec{
+			EventBusName: store.Get().EventBusName,
+			Calendar: map[string]eventsourcev1alpha1.CalendarEventSource{
+				store.Get().CronExampleEventName: {
+					Interval: "5m",
+				},
+			},
+		},
+	}
+}
+
 func createCronExampleSensor(triggers []sensorsv1alpha1.Trigger, runtimeName string) (*sensorsv1alpha1.Sensor, error) {
 	dependencies := []sensorsv1alpha1.EventDependency{
 		{
@@ -557,7 +579,7 @@ func createDemoWorkflowTemplate(gsFs fs.FS, runtimeName string) error {
 							Parameters: []wfv1alpha1.Parameter{{Name: "message", Value: wfv1alpha1.AnyStringPtr("hello world")}},
 							Artifacts:  wfv1alpha1.Artifacts{},
 						},
-						Container: &v1.Container{
+						Container: &corev1.Container{
 							Image:   "docker/whalesay:latest",
 							Command: []string{"cowsay"},
 							Args:    []string{"{{inputs.parameters.message}}"},
@@ -570,3 +592,179 @@ func createDemoWorkflowTemplate(gsFs fs.FS, runtimeName string) error {
 
 	return gsFs.WriteYamls(store.Get().CronExampleWfTemplateFileName, wfTemplate)
 }
+
+func createGithubExamplePipeline(opts *gitSourceGithubExampleOptions) error {
+	// Create an ingress that will manage external access to the github eventsource service
+	ingress := createGithubExampleIngress()
+	ingressFilePath := opts.gsFs.Join(opts.gsCloneOpts.Path(), store.Get().GithubExampleIngressFileName)
+	err := opts.gsCloneOpts.FS.WriteYamls(ingressFilePath, ingress)
+	if err != nil {
+		return fmt.Errorf("failed to write yaml of github example ingress. Error: %w", err)
+	}
+
+	// Create a github eventsource that will listen to push events in the git source repo
+	gsRepoURL := opts.gsCloneOpts.URL()
+	eventSource := createGithubExampleEventSource(gsRepoURL)
+	eventSourceFilePath := opts.gsFs.Join(opts.gsCloneOpts.Path(), store.Get().GithubExampleEventSourceFileName)
+	err = opts.gsCloneOpts.FS.WriteYamls(eventSourceFilePath, eventSource)
+	if err != nil {
+		return fmt.Errorf("failed to write yaml of secret. Error: %w", err)
+	}
+
+	// Create a sensor that will listen to the events published by the github eventsource, and trigger workflows
+	sensor := createGithubExampleSensor()
+	sensorFilePath := opts.gsFs.Join(opts.gsCloneOpts.Path(), store.Get().GithubExampleSensorFileName)
+	err = opts.gsCloneOpts.FS.WriteYamls(sensorFilePath, sensor)
+	if err != nil {
+		return fmt.Errorf("failed to write yaml of github example sensor. Error: %w", err)
+	}
+
+	return nil
+}
+
+func createGithubExampleIngress() *netv1.Ingress {
+	return ingressutil.CreateIngress(&ingressutil.CreateIngressOptions{
+		Name: store.Get().GithubExampleIngressObjectName,
+		Paths: []ingressutil.IngressPath{
+			{
+				Path:        store.Get().GithubExampleEventSourceEndpointPath,
+				PathType:    netv1.PathTypeImplementationSpecific,
+				ServiceName: store.Get().GithubExampleEventSourceObjectName + "-eventsource-svc",
+				ServicePort: store.Get().GithubExampleEventSourceServicePort,
+			},
+		},
+	})
+}
+
+func getRepoOwnerAndNameFromRepoURL(repoURL string) (owner string, name string) {
+	_, repoRef, _, _, _, _, _ := aputil.ParseGitUrl(repoURL)
+	splitRepoRef := strings.Split(repoRef, "/")
+	owner = splitRepoRef[0]
+	name = splitRepoRef[1]
+	return owner, name
+}
+
+func createGithubExampleEventSource(repoURL string) *eventsourcev1alpha1.EventSource {
+	repoOwner, repoName := getRepoOwnerAndNameFromRepoURL(repoURL)
+
+	return &eventsourcev1alpha1.EventSource{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       eventsourcereg.Kind,
+			APIVersion: eventsourcereg.Group + "/v1alpha1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: store.Get().GithubExampleEventSourceObjectName,
+		},
+		Spec: eventsourcev1alpha1.EventSourceSpec{
+			EventBusName: store.Get().EventBusName,
+			Service: &eventsourcev1alpha1.Service{
+				Ports: []corev1.ServicePort{
+					{
+						Port:       store.Get().GithubExampleEventSourceServicePort,
+						TargetPort: intstr.IntOrString{StrVal: store.Get().GithubExampleEventSourceTargetPort},
+					},
+				},
+			},
+			Github: map[string]eventsourcev1alpha1.GithubEventSource{
+				store.Get().GithubExampleEventName: {
+					Webhook: &eventsourcev1alpha1.WebhookContext{
+						Endpoint: store.Get().GithubExampleEventSourceEndpointPath,
+						URL:      "http://replace-with-real-public-url",
+						Port:     store.Get().GithubExampleEventSourceTargetPort,
+						Method:   "POST",
+					},
+					Repositories: []eventsourcev1alpha1.OwnedRepositories{
+						{
+							Owner: repoOwner,
+							Names: []string{
+								repoName,
+							},
+						},
+					},
+					Events: []string{
+						"push",
+					},
+					APIToken: &corev1.SecretKeySelector{
+						Key: store.Get().GithubAccessTokenSecretKey,
+						LocalObjectReference: corev1.LocalObjectReference{
+							Name: store.Get().GithubAccessTokenSecretObjectName,
+						},
+					},
+					ContentType: "json",
+					Active:      true,
+					Insecure:    true,
+				},
+			},
+		},
+	}
+}
+
+func createGithubExampleTrigger() sensorsv1alpha1.Trigger {
+	workflow := wfutil.CreateWorkflow(&wfutil.CreateWorkflowOptions{
+		GenerateName:          "github-",
+		SpecWfTemplateRefName: store.Get().GithubExampleTriggerTemplateName,
+		Parameters: []string{
+			"message",
+		},
+	})
+
+	workflowResource := apicommon.NewResource(workflow)
+
+	return sensorsv1alpha1.Trigger{
+		Template: &sensorsv1alpha1.TriggerTemplate{
+			Name: store.Get().CronExampleTriggerTemplateName,
+			ArgoWorkflow: &sensorsv1alpha1.ArgoWorkflowTrigger{
+				GroupVersionResource: metav1.GroupVersionResource{
+					Group:    "argoproj.io",
+					Version:  "v1alpha1",
+					Resource: "workflows",
+				},
+				Operation: sensorsv1alpha1.Submit,
+				Source: &sensorsv1alpha1.ArtifactLocation{
+					Resource: &workflowResource,
+				},
+				Parameters: []sensorsv1alpha1.TriggerParameter{
+					{
+						Src: &sensorsv1alpha1.TriggerParameterSource{
+							DependencyName: store.Get().GithubExampleDependencyName,
+							DataKey:        "body.hook_id",
+						},
+						Dest: "spec.arguments.parameters.0.value",
+					},
+				},
+			},
+		},
+		RetryStrategy: &apicommon.Backoff{Steps: 3},
+	}
+}
+
+func createGithubExampleSensor() *sensorsv1alpha1.Sensor {
+	triggers := []sensorsv1alpha1.Trigger{
+		createGithubExampleTrigger(),
+	}
+	dependencies := []sensorsv1alpha1.EventDependency{
+		{
+			Name:            store.Get().GithubExampleDependencyName,
+			EventSourceName: store.Get().GithubExampleEventSourceObjectName,
+			EventName:       store.Get().GithubExampleEventName,
+		},
+	}
+
+	return &sensorsv1alpha1.Sensor{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       sensorreg.Kind,
+			APIVersion: sensorreg.Group + "/v1alpha1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: store.Get().GithubExampleSensorObjectName,
+		},
+		Spec: sensorsv1alpha1.SensorSpec{
+			EventBusName: store.Get().EventBusName,
+			Template: &sensorsv1alpha1.Template{
+				ServiceAccountName: store.Get().WorkflowTriggerServiceAccount,
+			},
+			Dependencies: dependencies,
+			Triggers:     triggers,
+		},
+	}
+}

cmd/commands/runtime.go

@@ -52,6 +52,7 @@ import (
 	"github.com/spf13/cobra"
 	appsv1 "k8s.io/api/apps/v1"
 	v1 "k8s.io/api/core/v1"
+	netv1 "k8s.io/api/networking/v1"
 	rbacv1 "k8s.io/api/rbac/v1"
 	kerrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
@@ -257,19 +258,17 @@ func RunRuntimeInstall(ctx context.Context, opts *RuntimeInstallOptions) error {
 	componentNames := getComponents(rt, opts)
 
 	token, err := createRuntimeOnPlatform(ctx, &model.RuntimeInstallationArgs{
-		RuntimeName: opts.RuntimeName,
-		Cluster: server,
+		RuntimeName:    opts.RuntimeName,
+		Cluster:        server,
 		RuntimeVersion: runtimeVersion,
-		IngressHost: &opts.IngressHost,
+		IngressHost:    &opts.IngressHost,
 		ComponentNames: componentNames,
 	})
-
 	if err != nil {
 		return fmt.Errorf("failed to create a new runtime: %w", err)
 	}
 
 	opts.RuntimeToken = token
-
 	rt.Spec.Cluster = server
 	rt.Spec.IngressHost = opts.IngressHost
 
@@ -743,11 +742,21 @@ func createWorkflowsIngress(ctx context.Context, cloneOpts *git.CloneOptions, rt
 
 	overlaysDir := fs.Join(apstore.Default.AppsDir, "workflows", apstore.Default.OverlaysDir, rt.Name)
 	ingress := ingressutil.CreateIngress(&ingressutil.CreateIngressOptions{
-		Name:        rt.Name + store.Get().IngressName,
-		Namespace:   rt.Namespace,
-		Path:        store.Get().IngressPath,
-		ServiceName: store.Get().ArgoWFServiceName,
-		ServicePort: store.Get().ArgoWFServicePort,
+		Name:      rt.Name + store.Get().IngressName,
+		Namespace: rt.Namespace,
+		Annotations: map[string]string{
+			"kubernetes.io/ingress.class":                  "nginx",
+			"nginx.ingress.kubernetes.io/rewrite-target":   "/$2",
+			"nginx.ingress.kubernetes.io/backend-protocol": "https",
+		},
+		Paths: []ingressutil.IngressPath{
+			{
+				Path:        fmt.Sprintf("/%s(/|$)(.*)", store.Get().IngressPath),
+				PathType:    netv1.PathTypePrefix,
+				ServiceName: store.Get().ArgoWFServiceName,
+				ServicePort: store.Get().ArgoWFServicePort,
+			},
+		},
 	})
 	if err = fs.WriteYamls(fs.Join(overlaysDir, "ingress.yaml"), ingress); err != nil {
 		return err