Update version command to get version of particular component

This patch adds flag `component` to get the version of a particular component and also version command show available component versions Signed-off-by: Shiv Verma <[email protected]>
openshift-pipelines · May 25, 2023 · 18be3d7 · 18be3d7
1 parent b738bd2
commit 18be3d7
Show file tree

Hide file tree

Showing 3 changed files with 103 additions and 28 deletions.
diff --git a/main.go b/main.go
@@ -50,18 +50,17 @@ func main() {
 	paciostreams := paccli.NewIOStreams()
 	tkn.RemoveCommand(pacversion.Command(paciostreams)) // does not work 🤷🏽‍♂️, we do the hard way later on
 	tkn.RemoveCommand(tknversion.Command(tp))
-	tkn.AddCommand(opccli.VersionCommand(paciostreams))
+	tkn.AddCommand(opccli.VersionCommand(tp))
 
 	args := os.Args[1:]
 	var cmd *cobra.Command
 	if len(args) > 0 && args[0] == "version" {
-		cmd = opccli.VersionCommand(paciostreams)
+		cmd = opccli.VersionCommand(tp)
 		goto CoreTkn
 	}
 	if len(args) > 1 && args[0] == "pac" && args[1] == "version" {
 		// Arthur: "I've Got Nothing Left To Lose. Nothing Can Hurt Me Anymore. My Life Is Nothing But A Comedy." 🃏
-		os.Args = []string{"version"}
-		vcmd := opccli.VersionCommand(paciostreams)
+		vcmd := opccli.VersionCommand(tp)
 		_ = vcmd.Execute()
 		os.Exit(0)
 	}

diff --git a/pkg/version.go b/pkg/version.go
@@ -3,11 +3,11 @@ package opc
 import (
 	"encoding/json"
 	"fmt"
-	"html/template"
 
 	_ "embed"
 
-	paccli "github.com/openshift-pipelines/pipelines-as-code/pkg/cli"
+	tkncli "github.com/tektoncd/cli/pkg/cli"
+	"github.com/tektoncd/cli/pkg/version"
 
 	// paccli "github.com/openshift-pipelines/opc/pkg"
 	"github.com/spf13/cobra"
@@ -16,48 +16,127 @@ import (
 //go:embed version.json
 var versionFile string
 
-//go:embed version.tmpl
-var versionTmpl string
+var (
+	component = ""
+	namespace = ""
+	err       error
+)
 
 type versions struct {
 	Opc string `json:"opc"`
 	Tkn string `json:"tkn"`
 	Pac string `json:"pac"`
 }
 
-func VersionCommand(ioStreams *paccli.IOStreams) *cobra.Command {
+func VersionCommand(tp tkncli.Params) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "version",
 		Short: "Print opc version",
 		Long:  "Print OpenShift Pipeline Client version",
-		RunE: func(_ *cobra.Command, args []string) error {
+		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			component, err = cmd.Flags().GetString("component")
+			if err != nil {
+				return err
+			}
+			namespace, err = cmd.Flags().GetString("namespace")
+			if err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
 			var v versions
 			if err := json.Unmarshal([]byte(versionFile), &v); err != nil {
 				return fmt.Errorf("cannot unmarshall versions: %w", err)
 			}
-			if len(args) > 1 {
-				switch args[1] {
-				case "pac":
-					fmt.Fprintln(ioStreams.Out, v.Pac)
-				case "tkn":
-					fmt.Fprintln(ioStreams.Out, v.Tkn)
-				case "opc":
-					fmt.Fprintln(ioStreams.Out, v.Opc)
-				default:
-					return fmt.Errorf("unknown component: %v", args[1])
-				}
+			if args[0] == "pac" {
+				fmt.Fprintf(cmd.OutOrStdout(), "%s\n", v.Opc)
 				return nil
 			}
 
-			t, err := template.New("Describe Repository").Parse(versionTmpl)
-			if err != nil {
-				return err
+			cs, err := tp.Clients()
+			if err == nil {
+				switch component {
+				case "":
+					fmt.Fprintf(cmd.OutOrStdout(), "OpenShift Pipelines Client Verion: %s\n", v.Opc)
+					fmt.Fprintf(cmd.OutOrStdout(), "Tekton Client Verion: %s\n", v.Tkn)
+					fmt.Fprintf(cmd.OutOrStdout(), "Pipelines as Code CLI Verion: %s\n", v.Tkn)
+					chainsVersion, _ := version.GetChainsVersion(cs, namespace)
+					if chainsVersion != "" {
+						fmt.Fprintf(cmd.OutOrStdout(), "Chains version: %s\n", chainsVersion)
+					}
+
+					pipelineVersion, _ := version.GetPipelineVersion(cs, namespace)
+					if pipelineVersion == "" {
+						pipelineVersion = "unknown, " +
+							"pipeline controller may be installed in another namespace please use tkn version -n {namespace}"
+					}
+					fmt.Fprintf(cmd.OutOrStdout(), "Pipeline version: %s\n", pipelineVersion)
+
+					triggersVersion, _ := version.GetTriggerVersion(cs, namespace)
+					if triggersVersion != "" {
+						fmt.Fprintf(cmd.OutOrStdout(), "Triggers version: %s\n", triggersVersion)
+					}
+
+					dashboardVersion, _ := version.GetDashboardVersion(cs, namespace)
+					if dashboardVersion != "" {
+						fmt.Fprintf(cmd.OutOrStdout(), "Dashboard version: %s\n", dashboardVersion)
+					}
+
+					operatorVersion, _ := version.GetOperatorVersion(cs, namespace)
+					if operatorVersion != "" {
+						fmt.Fprintf(cmd.OutOrStdout(), "Operator version: %s\n", operatorVersion)
+					}
+				case "tkn":
+					fmt.Fprintf(cmd.OutOrStdout(), "%s\n", v.Tkn)
+				case "client":
+					fmt.Fprintf(cmd.OutOrStdout(), "%s\n", v.Opc)
+				case "chains":
+					chainsVersion, _ := version.GetChainsVersion(cs, namespace)
+					if chainsVersion == "" {
+						chainsVersion = "unknown"
+					}
+					fmt.Fprintf(cmd.OutOrStdout(), "%s\n", chainsVersion)
+
+				case "pipeline":
+					pipelineVersion, _ := version.GetPipelineVersion(cs, namespace)
+					if pipelineVersion == "" {
+						pipelineVersion = "unknown"
+					}
+					fmt.Fprintf(cmd.OutOrStdout(), "%s\n", pipelineVersion)
+
+				case "triggers":
+					triggersVersion, _ := version.GetTriggerVersion(cs, namespace)
+					if triggersVersion == "" {
+						triggersVersion = "unknown"
+					}
+					fmt.Fprintf(cmd.OutOrStdout(), "%s\n", triggersVersion)
+
+				case "dashboard":
+					dashboardVersion, _ := version.GetDashboardVersion(cs, namespace)
+					if dashboardVersion == "" {
+						dashboardVersion = "unknown"
+					}
+					fmt.Fprintf(cmd.OutOrStdout(), "%s\n", dashboardVersion)
+
+				case "operator":
+					operatorVersion, _ := version.GetOperatorVersion(cs, namespace)
+					if operatorVersion == "" {
+						operatorVersion = "unknown"
+					}
+					fmt.Fprintf(cmd.OutOrStdout(), "%s\n", operatorVersion)
+
+				default:
+					fmt.Fprintf(cmd.OutOrStdout(), "Invalid component value\n")
+				}
 			}
-			return t.Execute(ioStreams.Out, v)
+			return nil
 		},
 		Annotations: map[string]string{
 			"commandType": "main",
 		},
 	}
+	cmd.Flags().StringVarP(&namespace, "namespace", "n", namespace, "namespace to check installed controller version")
+	cmd.Flags().StringVarP(&component, "component", "c", "", "provide a particular component name for its version (client|tkn|chains|pipeline|triggers|dashboard)")
 	return cmd
 }
diff --git a/pkg/version.tmpl b/pkg/version.tmpl