Try to detect if pac is installed via operator

When installing via openshift-pipelines "downstream" operator. PAC would
get installed in openshift-pipelines.

Strategy to detection is then :

if user has a -n ns flag, try to see if pac is installed in ns
try to detect pac in openshift-pipelines ns (downstream)
try to detect pac in pipelines-as-code ns  (upstream)

The way to detect it is to check the configmap installed in the
openshift-pipelines namespace. This makes this detection compatible with
old way (via taskrun) and the new way via controller.

As far goes for for permissions usually the folks who tries to do
bootstrap will have to have anyway right access to that ns to be able to
bootstrap so we should be good.

Signed-off-by: Chmouel Boudjnah <[email protected]>

Author: chmouel

pkg/cmd/tknpac/bootstrap/bootstrap.go

@@ -14,6 +14,7 @@ import (
 const (
 	pacNS                  = "pipelines-as-code"
 	pacLabel               = "eventlistener=pipelines-as-code-interceptor"
+	openshiftpacNS         = "openshift-pipelines"
 	openShiftRouteGroup    = "route.openshift.io"
 	openShiftRouteVersion  = "v1"
 	openShiftRouteResource = "routes"
@@ -69,8 +70,17 @@ func install(ctx context.Context, run *params.Run, opts *bootstrapOpts) error {
 	if !tektonInstalled {
 		return errors.New("tekton API not found on the cluster. Please install Tekton first")
 	}
-	installed, _ := checkNS(ctx, run, opts)
-	if !opts.forceInstall && installed {
+
+	// if we gt a ns back it means it has been detected in here so keep it as is.
+	// or else just set the default to pacNS
+	ns, err := detectPacInstallation(ctx, opts.targetNamespace, run)
+	if ns != "" {
+		opts.targetNamespace = ns
+	} else if opts.targetNamespace == "" {
+		opts.targetNamespace = pacNS
+	}
+
+	if !opts.forceInstall && err == nil {
 		// nolint:forbidigo
 		fmt.Println("👌 Pipelines as Code is already installed.")
 	} else if err := installPac(ctx, opts); err != nil {
@@ -141,7 +151,7 @@ func Command(run *params.Run, ioStreams *cli.IOStreams) *cobra.Command {
 	}
 	cmd.AddCommand(GithubApp(run, ioStreams))
 
-	addCommonFlags(cmd, opts, ioStreams)
+	addCommonFlags(cmd, ioStreams)
 	addGithubAppFlag(cmd, opts)
 
 	cmd.PersistentFlags().BoolVar(&opts.forceInstall, "force-install", false, "whether we should force pac install even if it's already installed")
@@ -168,6 +178,12 @@ func GithubApp(run *params.Run, ioStreams *cli.IOStreams) *cobra.Command {
 				return err
 			}
 
+			var err error
+			opts.targetNamespace, err = detectPacInstallation(ctx, opts.targetNamespace, run)
+			if err != nil {
+				return err
+			}
+
 			if b, _ := askYN(false, "", "Are you using Github Enterprise?"); b {
 				opts.providerType = "github-enteprise-app"
 			}
@@ -178,11 +194,40 @@ func GithubApp(run *params.Run, ioStreams *cli.IOStreams) *cobra.Command {
 			"commandType": "main",
 		},
 	}
-	addCommonFlags(cmd, opts, ioStreams)
+	addCommonFlags(cmd, ioStreams)
 	addGithubAppFlag(cmd, opts)
+
+	cmd.PersistentFlags().StringVarP(&opts.targetNamespace, "namespace", "n", "", "target namespace where pac is installed")
 	return cmd
 }
 
+func detectPacInstallation(ctx context.Context, wantedNS string, run *params.Run) (string, error) {
+	// detect which namespace pac is installed in
+	// verify first if the targetNamespace actually exists
+	if wantedNS != "" {
+		installed, err := checkNS(ctx, run, wantedNS)
+		if err != nil {
+			return "", err
+		}
+		if !installed {
+			return "", fmt.Errorf("PAC is not installed in namespace: %s", wantedNS)
+		}
+		return wantedNS, nil
+		// if openshift pipelines ns is installed try it from there
+	}
+
+	if installed, _ := checkNS(ctx, run, openshiftpacNS); installed {
+		return openshiftpacNS, nil
+	}
+
+	if installed, _ := checkNS(ctx, run, pacNS); installed {
+		return pacNS, nil
+	}
+
+	return "", fmt.Errorf("could not detect an installation of Pipelines as Code, " +
+		"use the -n switch to specify a namespace")
+}
+
 func addGithubAppFlag(cmd *cobra.Command, opts *bootstrapOpts) {
 	cmd.PersistentFlags().StringVar(&opts.GithubOrganizationName, "github-organization-name", "", "Whether you want to target an organization instead of the current user")
 	cmd.PersistentFlags().StringVar(&opts.GithubApplicationName, "github-application-name", "", "Github Application Name")
@@ -195,7 +240,6 @@ func addGithubAppFlag(cmd *cobra.Command, opts *bootstrapOpts) {
 		fmt.Sprintf("target install type, choices are: %s ", strings.Join(providerTargets, ", ")))
 }
 
-func addCommonFlags(cmd *cobra.Command, opts *bootstrapOpts, ioStreams *cli.IOStreams) {
+func addCommonFlags(cmd *cobra.Command, ioStreams *cli.IOStreams) {
 	cmd.PersistentFlags().BoolP("no-color", "C", !ioStreams.ColorEnabled(), "disable coloring")
-	cmd.PersistentFlags().StringVarP(&opts.targetNamespace, "namespace", "n", pacNS, "target namespace where pac is installed")
 }

pkg/cmd/tknpac/bootstrap/install.go

@@ -58,7 +58,7 @@ func installPac(ctx context.Context, opts *bootstrapOpts) error {
 
 	if !opts.forceInstall {
 		doinstall, err := askYN(true,
-			"🕵️ Pipelines as Code doesn't seems to be installed",
+			fmt.Sprintf("🕵️ Pipelines as Code doesn't seems to be installed in %s namespace", opts.targetNamespace),
 			fmt.Sprintf("Do you want me to install Pipelines as Code %s?", latestversion))
 		if err != nil {
 			return err

pkg/cmd/tknpac/bootstrap/kubestuff.go

@@ -10,6 +10,8 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
+const configMapPacLabel = "app.kubernetes.io/part-of=pipelines-as-code"
+
 // deleteSecret delete secret first if it exists
 func deleteSecret(ctx context.Context, run *params.Run, opts *bootstrapOpts) error {
 	return run.Clients.Kube.CoreV1().Secrets(opts.targetNamespace).Delete(ctx, secretName, metav1.DeleteOptions{})
@@ -39,14 +41,26 @@ func createPacSecret(ctx context.Context, run *params.Run, opts *bootstrapOpts,
 
 // checkSecret checks if the secret exists
 func checkSecret(ctx context.Context, run *params.Run, opts *bootstrapOpts) bool {
-	secret, _ := run.Clients.Kube.CoreV1().Secrets(opts.targetNamespace).Get(ctx, secretName, metav1.GetOptions{})
-	return secret.GetName() != ""
+	_, err := run.Clients.Kube.CoreV1().Secrets(opts.targetNamespace).Get(ctx, secretName, metav1.GetOptions{})
+	return err == nil
 }
 
 // check if we have the namespace created
-func checkNS(ctx context.Context, run *params.Run, opts *bootstrapOpts) (bool, error) {
-	ns, err := run.Clients.Kube.CoreV1().Namespaces().Get(ctx, opts.targetNamespace, metav1.GetOptions{})
-	return ns.GetName() != "", err
+func checkNS(ctx context.Context, run *params.Run, targetNamespace string) (bool, error) {
+	ns, err := run.Clients.Kube.CoreV1().Namespaces().Get(ctx, targetNamespace, metav1.GetOptions{})
+	if err != nil {
+		return false, err
+	}
+
+	// check if there is a configmap with the pipelines-as-code label in targetNamespace
+	cms, err := run.Clients.Kube.CoreV1().ConfigMaps(ns.GetName()).List(ctx, metav1.ListOptions{LabelSelector: configMapPacLabel})
+	if err != nil {
+		return false, err
+	}
+	if cms.Items == nil || len(cms.Items) == 0 {
+		return false, nil
+	}
+	return true, nil
 }
 
 func checkPipelinesInstalled(run *params.Run) (bool, error) {

pkg/cmd/tknpac/bootstrap/route.go

@@ -12,7 +12,6 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 
-// detectOpenShiftRoute detect the openshift route where the eventlistener is running
 func detectOpenShiftRoute(ctx context.Context, run *params.Run, opts *bootstrapOpts) (string, error) {
 	gvr := schema.GroupVersionResource{
 		Group: openShiftRouteGroup, Version: openShiftRouteVersion, Resource: openShiftRouteResource,