Merge pull request #134 from nicholasSUSE/lifecycle-status

Add feature lifecycle-status

Author: nicholasSUSE

.github/workflows/pull-request.yaml

@@ -24,6 +24,7 @@ jobs:
       - uses: golangci/golangci-lint-action@v4
         with:
           version: v1.57
+          args: --timeout 5m
 
   build:
     runs-on: ubuntu-latest

main.go

@@ -257,6 +257,12 @@ func main() {
 			Action: lifecycleAssetsClean,
 			Flags:  []cli.Flag{branchVersionFlag, chartFlag, debugFlag},
 		},
+		{
+			Name:   "lifecycle-status",
+			Usage:  "Get the status of the current assets and charts based on the branch version and chart version according to the lifecycle rules",
+			Action: lifecycleStatus,
+			Flags:  []cli.Flag{branchVersionFlag, chartFlag},
+		},
 	}
 
 	if err := app.Run(os.Args); err != nil {
@@ -571,3 +577,18 @@ func lifecycleAssetsClean(c *cli.Context) {
 		logrus.Fatalf("Failed to apply versioning rules for lifecycle-assets-clean: %s", err)
 	}
 }
+
+func lifecycleStatus(c *cli.Context) {
+	// Initialize dependencies with branch-version and current chart
+	rootFs := filesystem.GetFilesystem(getRepoRoot())
+	lifeCycleDep, err := lifecycle.InitDependencies(rootFs, c.String("branch-version"), CurrentChart, false)
+	if err != nil {
+		logrus.Fatalf("encountered error while initializing dependencies for lifecycle-assets-clean: %s", err)
+	}
+
+	// Execute lifecycle status check and save the logs
+	err = lifeCycleDep.CheckLifecycleStatusAndSave(CurrentChart)
+	if err != nil {
+		logrus.Fatalf("Failed to check lifecycle status: %s", err)
+	}
+}

pkg/lifecycle/git.go

@@ -4,8 +4,62 @@ import (
 	"fmt"
 	"os"
 	"os/exec"
+
+	"github.com/sirupsen/logrus"
 )
 
+// Git struct holds necessary data to work with the current git repository
+type Git struct {
+	Dir string
+}
+
+// cloneAtDir clones a repository at a given directory
+func cloneAtDir(url, dir string) (*Git, error) {
+	logrus.Infof("Cloning repository %s into %s", url, dir)
+	cmd := exec.Command("git", "clone", "--depth", "1", url, dir)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		logrus.Errorf("error while cloning repository: %s; err: %v", url, err)
+		return nil, fmt.Errorf("error while cloning repository: %s", err)
+	}
+	return &Git{Dir: dir}, nil
+}
+
+// fetchAndCheckoutBranch fetches and checks out a branch
+func (g *Git) fetchAndCheckoutBranch(branch string) error {
+	logrus.Infof("Fetching and checking out at: %s", branch)
+	err := g.fetchBranch(branch)
+	if err != nil {
+		return err
+	}
+	return g.checkoutBranch(branch)
+}
+
+func (g *Git) fetchBranch(branch string) error {
+	cmd := exec.Command("git", "-C", g.Dir, "fetch", "origin", branch+":"+branch)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		logrus.Errorf("error while fetching branch: %s; err: %v", branch, err)
+		return fmt.Errorf("error while fetching branch: %s", err)
+	}
+	return nil
+}
+
+func (g *Git) checkoutBranch(branch string) error {
+	cmd := exec.Command("git", "-C", g.Dir, "checkout", branch)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		logrus.Errorf("error while checking out branch: %s; err: %v", branch, err)
+		return fmt.Errorf("error while checking out branch: %s", err)
+	}
+	return nil
+}
+
+// checkIfGitIsClean checks if the git repository is clean and,
+// returns true if it is clean, false otherwise
 func checkIfGitIsClean(debug bool) (bool, error) {
 	cmd := exec.Command("git", "status", "--porcelain")
 	if debug {
@@ -24,8 +78,9 @@ func checkIfGitIsClean(debug bool) (bool, error) {
 	return true, nil
 }
 
+// gitAddAndCommit stages all changes and commits them with a given message,
+// equivalent to: git add -A && git commit -m message
 func gitAddAndCommit(message string) error {
-
 	// Stage all changes, including deletions
 	cmd := exec.Command("git", "add", "-A")
 	if err := cmd.Run(); err != nil {

pkg/lifecycle/logs.go

@@ -0,0 +1,111 @@
+package lifecycle
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+type logs struct {
+	file     *os.File
+	filePath string
+}
+
+const separator = "\n"
+const ender = "\n__________________________________________________________________\n"
+
+// createLogs creates a new log file and returns a logs struct with the file and file path
+func createLogs(fileName string) (*logs, error) {
+	filePath := fmt.Sprintf("logs/%s", fileName)
+
+	// Create the logs directory if it doesn't exist
+	err := os.MkdirAll("logs", 0755)
+	if err != nil {
+		logrus.Errorf("Error while creating logs directory: %s", err)
+	}
+
+	// Open the file in append mode
+	file, err := os.OpenFile(filePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+	if err != nil {
+		return nil, err
+	}
+
+	return &logs{file: file, filePath: filePath}, nil
+}
+
+// writeHEAD writes the header of the log file with the version rules, dates and necessary information
+// to help analyze the current situation on the charts versions regarding the release process.
+func (l *logs) writeHEAD(versionRules *VersionRules, title string) {
+	l.write(title, "INFO")
+	currentTime := time.Now()
+	l.write(currentTime.Format("2006-01-02 15:04:05"), "INFO")
+	l.write(fmt.Sprintf("Branch Version: %.1f", versionRules.branchVersion), "INFO")
+	l.write(fmt.Sprintf("minimal version: %d", versionRules.minVersion), "INFO")
+	l.write(fmt.Sprintf("max version: %d", versionRules.maxVersion), "INFO")
+	l.write(fmt.Sprintf("development branch: %s", versionRules.devBranch), "INFO")
+	l.write(fmt.Sprintf("production branch: %s", versionRules.prodBranch), "INFO")
+
+	rules := make(map[string]string, len(versionRules.rules))
+	for k, v := range versionRules.rules {
+		rules[fmt.Sprintf("%.1f", k)] = fmt.Sprintf("min: %s, max: %s", v.min, v.max)
+	}
+
+	rulesJSON, err := json.MarshalIndent(rules, "", "    ")
+	if err != nil {
+		logrus.Errorf("JSON marshaling failed: %s", err)
+		l.write(fmt.Sprintf("rules: %v\n", versionRules.rules), "INFO")
+	} else {
+		l.write(fmt.Sprintf("rules: %s\n", rulesJSON), "INFO")
+	}
+}
+
+// write writes the data to the log file and prints it to the console with customizations.
+func (l *logs) write(data string, logType string) {
+	switch logType {
+	case "INFO":
+		logrus.Info(data)
+		if _, err := l.file.WriteString("INFO=" + data + "\n"); err != nil {
+			logrus.Errorf("Error while writing logs: %s", err)
+		}
+	case "WARN":
+		logrus.Warn(data)
+		if _, err := l.file.WriteString("WARN=" + data + "\n"); err != nil {
+			logrus.Errorf("Error while writing logs: %s", err)
+		}
+	case "ERROR":
+		logrus.Error(data)
+		if _, err := l.file.WriteString("ERROR=" + data + "\n"); err != nil {
+			logrus.Errorf("Error while writing logs: %s", err)
+		}
+	case "SEPARATE":
+		fmt.Printf(separator)
+		if _, err := l.file.WriteString(separator); err != nil {
+			logrus.Errorf("Error while writing logs: %s", err)
+		}
+	case "END":
+		fmt.Printf(ender)
+		if _, err := l.file.WriteString("\n" + ender + "\n"); err != nil {
+			logrus.Errorf("Error while writing logs: %s", err)
+		}
+	default:
+		fmt.Printf(data)
+		if _, err := l.file.WriteString(data + "\n"); err != nil {
+			logrus.Errorf("Error while writing logs: %s", err)
+		}
+	}
+}
+
+// writeVersions receives the loaded assets versions map and writes it to the log file
+// in human-readable format
+func (l *logs) writeVersions(assetsVersions map[string][]Asset, logType string) {
+	for asset, versions := range assetsVersions {
+		l.write("", "SEPARATE")
+		l.write(asset, logType)
+		for _, version := range versions {
+			l.write(version.version, "")
+		}
+	}
+}