Add target package, Add conf validator for pipelines and targets

Signed-off-by: kunalvirwal <kunalvirwal@gmail.com>

Author: kunalvirwal

cmd/main.go

@@ -17,7 +17,7 @@ func initServices() {
 
 	logger := utils.NewLogger(utils.DebugLevel, true)
 	pipelineService := pipeline.NewPipelineService(logger)
-
+	pipelineService.LoadPipeline("./examples/pipeline.yaml")
 	// Initialize main application
 	app := app.NewApp(pipelineService, logger)
 

examples/pipeline.yaml

@@ -36,4 +36,4 @@ spec:
               target: cluster1
               files:
                   - "services/api/compose.yml"
-                  - "..."
+                  - "...yaml"

examples/target.yaml

@@ -5,5 +5,8 @@ metadata:
     type: cluster # or server
 spec:
     host: prod1.example.com
+    user: api
+    port: 6443
     # This secret should point to either the ssh key in case of server or the kube config in case of cluster
-    access-key-secret: prod1-ssh-key
+    access-key-secret: prod1-kube-conf
+    

internal/pipeline/loader.go

@@ -2,7 +2,9 @@ package pipeline
 
 import (
 	"os"
+	"strings"
 
+	pipelineSteps "github.com/kunalvirwal/shogun-cd/internal/pipeline/steps"
 	"go.yaml.in/yaml/v3"
 )
 
@@ -20,11 +22,130 @@ func (p *Service) LoadPipeline(path string) {
 	}
 
 	// [TODO]: Validate the pipeline structure here if needed
+	if !p.validatePipeline(&pipeline) {
+		return
+	}
 
 	for i, sw := range pipeline.Spec.Steps {
-		p.logger.LogInfo("Step %d: Type=%s, Details=%+v", i+1, sw.Step.Type(), sw.Step)
+		p.logger.Log("Step %d: Type=%s, Details=%+v", i+1, sw.Step.Type(), sw.Step)
 	}
-	p.logger.Log("Pipeline %v loaded successfully", pipeline.Metadata.Name)
+	p.logger.LogInfo("Pipeline %v loaded successfully", pipeline.Metadata.Name)
 
 	// [TODO]: Further processing of the loaded pipeline, store into DB and all
 }
+
+func (p *Service) validatePipeline(pipeline *Pipeline) bool {
+	// [TODO]: Implement validation logic
+	if pipeline.ApiVersion != "shogun.dev/v1" {
+		p.logger.LogNewError("invalid apiVersion: %s", pipeline.ApiVersion)
+		return false
+	}
+	if pipeline.Kind != PipelineKind {
+		p.logger.LogNewError("invalid kind: %s", pipeline.Kind)
+		return false
+	}
+	// [TODO]: Check is name is unique
+	if pipeline.Metadata.Name == "" {
+		p.logger.LogNewError("metadata.name cannot be empty")
+		return false
+	}
+	if len(pipeline.Spec.Triggers) == 0 {
+		p.logger.LogNewError("at least one trigger must be specified")
+		return false
+	}
+	for _, trigger := range pipeline.Spec.Triggers {
+		if trigger.Type == string(WebhookTriggerKind) {
+			continue
+		}
+		if trigger.Type == string(GitChangesTriggerKind) {
+			if len(trigger.Paths) == 0 {
+				p.logger.LogNewError("git_changes trigger must specify atleast one path")
+				return false
+			}
+			continue
+		}
+		p.logger.LogNewError("invalid trigger type")
+		return false
+	}
+
+	for i, sw := range pipeline.Spec.Steps {
+		if sw.Step == nil {
+			p.logger.LogNewError("step %d is nil", i+1)
+			return false
+		}
+
+		switch sw.Step.Type() {
+		case pipelineSteps.MutateType:
+			step := sw.Step.(*pipelineSteps.MutateStep)
+			if !p.validTrigger(step.TriggerWhen, i) {
+				return false
+			}
+			if step.File == "" {
+				p.logger.LogNewError("step %d mutate file cannot be empty", i+1)
+				return false
+			}
+			if step.UpdateField == "" {
+				p.logger.LogNewError("step %d mutate update_field cannot be empty", i+1)
+				return false
+			}
+
+		case pipelineSteps.SyncType:
+			step := sw.Step.(*pipelineSteps.SyncStep)
+			if !p.validTrigger(step.TriggerWhen, i) {
+				return false
+			}
+			if step.Target == "" {
+				p.logger.LogNewError("step %d exec target cannot be empty", i+1)
+				return false
+			}
+
+		case pipelineSteps.ExecType:
+			step := sw.Step.(*pipelineSteps.ExecStep)
+			if !p.validTrigger(step.TriggerWhen, i) {
+				return false
+			}
+			if step.Target == "" {
+				p.logger.LogNewError("step %d exec target cannot be empty", i+1)
+				return false
+			}
+			if len(step.Commands) == 0 {
+				p.logger.LogNewError("step %d exec commands cannot be empty", i+1)
+				return false
+			}
+
+		case pipelineSteps.ApplyType:
+			step := sw.Step.(*pipelineSteps.ApplyStep)
+			if !p.validTrigger(step.TriggerWhen, i) {
+				return false
+			}
+			if step.Target == "" {
+				p.logger.LogNewError("step %d exec target cannot be empty", i+1)
+				return false
+			}
+			if len(step.Files) == 0 {
+				p.logger.LogNewError("step %d apply files cannot be empty", i+1)
+				return false
+			}
+			for j, file := range step.Files {
+				if !strings.HasSuffix(file, ".yaml") && !strings.HasSuffix(file, ".yml") && !strings.HasSuffix(file, ".json") {
+					p.logger.LogNewError("step %d apply has a file with invalid extension at index %d", i+1, j)
+					return false
+				}
+			}
+
+		default:
+			p.logger.LogNewError("step %d has unknown type: %s", i+1, sw.Step.Type())
+			return false
+		}
+
+	}
+	return true
+}
+
+func (p *Service) validTrigger(trigger string, i int) bool {
+	if trigger == "" || trigger == string(WebhookTriggerKind) || trigger == string(GitChangesTriggerKind) {
+		return true
+	}
+	p.logger.LogNewError("step %d has invalid trigger_when: %s", i+1, trigger)
+	return false
+}

internal/pipeline/pipeline.go

@@ -4,7 +4,11 @@ import pipelineSteps "github.com/kunalvirwal/shogun-cd/internal/pipeline/steps"
 
 type Kind string
 
-const PipelineKind Kind = "Pipeline"
+const (
+	PipelineKind          Kind = "Pipeline"
+	WebhookTriggerKind    Kind = "ci_webhook"
+	GitChangesTriggerKind Kind = "git_changes"
+)
 
 type Pipeline struct {
 	ApiVersion string   `yaml:"apiVersion"`

internal/pipeline/steps/apply.go

@@ -1,9 +1,9 @@
 package pipelineSteps
 
 type ApplyStep struct {
-	TriggerWhen string `yaml:"trigger_when,omitempty"`
-	Target      string `yaml:"target"` // [TODO]: change this to pointer if needed
-	Files       []string
+	TriggerWhen string   `yaml:"trigger_when,omitempty"`
+	Target      string   `yaml:"target"` // [TODO]: change this to pointer if needed
+	Files       []string `yaml:"files"`
 }
 
 func (*ApplyStep) Type() string {

internal/target/target.go

@@ -0,0 +1,85 @@
+package target
+
+import (
+	"os"
+
+	"github.com/kunalvirwal/shogun-cd/internal/utils"
+	"go.yaml.in/yaml/v3"
+)
+
+type Kind string
+
+const TargetKind Kind = "Target"
+
+const (
+	ServerType  = "server"
+	ClusterType = "cluster"
+)
+
+type Target struct {
+	ApiVersion string   `yaml:"apiVersion"`
+	Kind       Kind     `yaml:"kind"`
+	Metadata   Metadata `yaml:"metadata"`
+	Spec       Spec     `yaml:"spec"`
+}
+
+type Metadata struct {
+	Name string `yaml:"name"`
+	Type string `yaml:"type"` // server or cluster
+}
+
+type Spec struct {
+	Host         string `yaml:"host"`
+	User         string `yaml:"user"`
+	Port         int    `yaml:"port"`
+	AccessSecret string `yaml:"access-key-secret"`
+}
+
+func LoadTarget(logger utils.Logger, path string) *Target {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		logger.LogNewError("failed to read target file: %v", err)
+		return nil
+	}
+
+	var target Target
+	if err := yaml.Unmarshal(data, &target); err != nil {
+		logger.LogNewError("failed to unmarshal target YAML: %v", err)
+		return nil
+	}
+
+	// [TODO]: Validate the target structure here if needed
+	if !validateTarget(logger, &target) {
+		return nil
+	}
+
+	logger.LogInfo("Target loaded: Name=%s, Type=%s, Host=%s", target.Metadata.Name, target.Metadata.Type, target.Spec.Host)
+
+	// [TODO]: Further processing of the loaded target, store into DB and all
+
+	return &target
+}
+
+func validateTarget(logger utils.Logger, target *Target) bool {
+	if target.ApiVersion != "shogun/v1" {
+		logger.LogNewError("invalid apiVersion: %s", target.ApiVersion)
+		return false
+	}
+	if target.Kind != TargetKind {
+		logger.LogNewError("invalid kind: %s", target.Kind)
+		return false
+	}
+	if target.Metadata.Type != ServerType && target.Metadata.Type != ClusterType {
+		logger.LogNewError("invalid target type: %s", target.Metadata.Type)
+		return false
+	}
+	if target.Spec.Host == "" || target.Spec.User == "" || target.Spec.AccessSecret == "" {
+		logger.LogNewError("host, user, and access-key-secret must be provided")
+		return false
+	}
+	if target.Spec.Port <= 0 || target.Spec.Port > 65535 {
+		logger.LogNewError("invalid port number: %d", target.Spec.Port)
+		return false
+	}
+	return true
+}