Avancement parser

internal/ansible/play.go

@@ -1,15 +1,24 @@
 package ansible
 
 import (
+	"fmt"
 	"github.com/ca-gip/dploy/internal/utils"
 )
 
 type Play struct {
-	Hosts   string      `json:"hosts" yaml:"hosts"`
-	Roles   []Role      `yaml:"roles,omitempty"`
-	RawTags interface{} `json:"tags,inline" yaml:"tags,inline"`
+	Hosts string    `yaml:"hosts"`
+	Roles []Role    `yaml:"roles"`
+	Tags  utils.Set `yaml:"tags"`
 }
 
-func (play *Play) Tags() []string {
-	return utils.InferSlice(play.RawTags)
+func (play *Play) AllTags() (tags *utils.Set) {
+	tags = utils.NewSet()
+	for _, role := range play.Roles {
+		tags = tags.Concat(role.AllTags().List())
+		fmt.Println("role loop tags list is: ", tags.List())
+
+	}
+	tags.Concat(play.Tags.List())
+	fmt.Println("play tags list is: ", tags.List())
+	return
 }

internal/ansible/playbook.go

@@ -10,41 +10,52 @@ import (
 	"strings"
 )
 
-type Tasks struct {
-	Tags interface{} `yaml:"tags,omitempty"`
-}
-
 type Playbook struct {
-	AbsolutePath string
-	RootPath     *string
+	absolutePath string
+	rootPath     *string
 	Plays        []Play
-	AllTags      utils.Set
+}
+
+const decoderTagName = "tags"
+
+func (playbook *Playbook) AllTags() (tags *utils.Set) {
+	tags = utils.NewSet()
+	for _, play := range playbook.Plays {
+		tags.Concat(play.AllTags().List())
+	}
+	return
 }
 
 func (playbook *Playbook) RelativePath() string {
-	return strings.TrimPrefix(playbook.AbsolutePath, *playbook.RootPath+"/")
+	return strings.TrimPrefix(playbook.absolutePath, *playbook.rootPath+"/")
 }
 
-func ReadFromFile(osPathname string) (plays []Play) {
+func ReadFromFile(osPathname string) (playbook Playbook) {
 	// Try to check playbook content
 	binData, err := ioutil.ReadFile(osPathname)
+
+	// IMPORTANT: Yaml and Json parser need a root element,
+	// They can't read a raw list.
+	content := fmt.Sprintf("plays:\n%s", string(binData))
+
 	if err != nil {
-		klog.Error("Cannot read playbook", osPathname, ". Error: ", err.Error())
+		fmt.Println("Cannot read playbook", osPathname, ". Error: ", err.Error())
 		return
 	}
-	err = yaml.Unmarshal([]byte(binData), plays)
+	err = yaml.Unmarshal([]byte(content), &playbook)
 	if err != nil {
-		klog.Error("Skip", osPathname, " not an inventory ")
+		fmt.Println("Skip", osPathname, " not a playbook ", err.Error())
 		return
 	}
-	if plays == nil || len(plays) == 0 {
-		klog.Info("No play found inside the playbook: ", osPathname)
+	if len(playbook.Plays) == 0 {
+		fmt.Println("No play found inside the playbook: ", osPathname)
 		return
 	}
-	if (plays[0]).Hosts == utils.EmptyString {
-		klog.V(8).Info("No play found inside the playbook: ", osPathname)
+	if playbook.Plays[0].Hosts == utils.EmptyString {
+		fmt.Println("No play found inside the playbook: ", osPathname)
 		return
 	}
+
 	return
 }
 
@@ -58,6 +69,7 @@ func readPlaybook(rootPath string) (result []*Playbook, err error) {
 		return
 	}
 
+	fmt.Println("reading playbook")
 	// Merge Play, Role and Task Tags for a playbook
 	allTags := utils.NewSet()
 
@@ -72,28 +84,25 @@ func readPlaybook(rootPath string) (result []*Playbook, err error) {
 			}
 
 			// Try to check playbook content
-			plays := ReadFromFile(osPathname)
+			playbook := ReadFromFile(osPathname)
 
 			// Browse Role Tags
-			for _, play := range plays {
+			for _, play := range playbook.Plays {
 
-				allTags.Concat(play.Tags())
-				fmt.Println("Play tags are: ", play.Tags())
+				allTags.Concat(play.AllTags().List())
+				fmt.Println("Play tags are: ", play.Tags)
 				for _, role := range play.Roles {
-					role.ReadRole(rootPath)
-					log.Info("  Role info", role.Tags())
-					allTags.Concat(role.Tags())
+					role.ReadRoleTasks(rootPath)
+					fmt.Println("  Role info", role.AllTags())
+					allTags.Concat(role.AllTags().List())
 				}
 			}
 
-			playbook := Playbook{
-				RootPath:     &rootPath,
-				AbsolutePath: osPathname,
-				Plays:        plays,
-				AllTags:      *allTags,
-			}
+			playbook.absolutePath = osPathname
+			playbook.rootPath = &rootPath
+
 			result = append(result, &playbook)
-			log.Debug("Available tags are :", playbook.AllTags)
+			fmt.Println("Available tags are :", playbook.AllTags())
 			return nil
 		},
 		ErrorCallback: func(osPathname string, err error) godirwalk.ErrorAction {

internal/ansible/playbook_test.go

@@ -1,13 +1,14 @@
 package ansible
 
 import (
-	"github.com/ghodss/yaml"
+	"github.com/ca-gip/dploy/internal/utils"
 	"github.com/go-test/deep"
 	"github.com/stretchr/testify/assert"
+	"gopkg.in/yaml.v2"
 	"testing"
 )
 
-const validPlaybook = `
+const validPlaybook1 = `
 - hosts: aws-node
   gather_facts: no
   roles:
@@ -17,24 +18,70 @@ const validPlaybook = `
   tags: always,alwaystest
 `
 
-func TestReadFromFile(t *testing.T) {
+var expectedValidPlaybook1 = Play{
+	Hosts: "aws-node",
+	Roles: []Role{
+		{
+			Name: "add-aws-facts",
+			Tags: *utils.NewSetFromSlice("add-aws-facts"),
+		},
+	},
+	Tags: *utils.NewSetFromSlice("always", "alwaystest"),
+}
+
+func Test(t *testing.T) {
 
-	t.Run("with a valid play and tags", func(t *testing.T) {
-		binData := []byte(validPlaybook)
+	t.Run("with a valid play data", func(t *testing.T) {
+		binData := []byte(validPlaybook1)
 		var plays []Play
 		err := yaml.Unmarshal([]byte(binData), &plays)
 		assert.Nil(t, err)
 		assert.NotNil(t, plays)
 		assert.NotEmpty(t, plays)
 
-		deep.Equal(plays[0], Play{
+		//deep.CompareUnexportedFields = false
+		if diff := deep.Equal(plays[0], expectedValidPlaybook1); diff != nil {
+			t.Error(diff)
+		}
+		assert.Equal(t, plays[0], expectedValidPlaybook1)
+
+		// Not so deep ?
+		if diff := deep.Equal(plays[0].Roles[0].Tags.List(), expectedValidPlaybook1.Roles[0].Tags.List()); diff != nil {
+			t.Error(diff)
+		}
+
+		if diff := deep.Equal(plays[0].Roles[0].Tags.List(), expectedValidPlaybook1.Roles[0].Tags.List()); diff != nil {
+			t.Error(diff)
+		}
+	})
+
+	t.Run("with two different play should be different deep.Equals", func(t *testing.T) {
+		//deep.CompareUnexportedFields = false
+		var left = Play{
 			Hosts: "aws-node",
 			Roles: []Role{
-				{Name: "add-aws-facts"},
+				{
+					Name: "add-aws-facts",
+					Tags: *utils.NewSetFromSlice("left"),
+				},
 			},
-			RawTags: []string{"add-aws-facts"},
-		})
+			Tags: *utils.NewSetFromSlice("left", "Left"),
+		}
 
+		var right = Play{
+			Hosts: "aws-node",
+			Roles: []Role{
+				{
+					Name: "add-aws-facts",
+					Tags: *utils.NewSetFromSlice("left"),
+				},
+			},
+			Tags: *utils.NewSetFromSlice("right", "Right"),
+		}
+		// Not so deep ?
+		if diff := deep.Equal(left, right); len(diff) != 0 {
+			t.Error(diff)
+		}
 	})
 
 }

internal/ansible/role.go

@@ -1,66 +1,76 @@
 package ansible
 
 import (
+	"fmt"
 	"github.com/ca-gip/dploy/internal/utils"
-	"github.com/ghodss/yaml"
 	"github.com/karrick/godirwalk"
+	"gopkg.in/yaml.v2"
 	"io/ioutil"
-	"k8s.io/klog/v2"
 	"path/filepath"
 	"strings"
 )
 
 type Role struct {
 	AbsolutePath string
-	Name         string      `json:"name" yaml:"role,flow"`
-	rawTags      interface{} `json:"tags" yaml:"tags,flow"`
-	Tasks        []Tasks
+	Name         string    `yaml:"role"`
+	Tasks        []Task    `yaml:"tasks"`
+	Tags         utils.Set `yaml:"tags"`
 }
 
-func (role *Role) Tags() []string {
-	return utils.InferSlice(role.rawTags)
+func (role *Role) AllTags() (tags *utils.Set) {
+	tags = utils.NewSet()
+	for _, task := range role.Tasks {
+		tags.Concat(task.Tags.List())
+	}
+	fmt.Println("tags:::", tags.List())
+	tags.Concat(role.Tags.List())
+	return
 }
 
 // Gather inventory files from a Parent directory
 // Using a recursive scan. All non inventory files are ignored ( not .ini file )
 // All sub parent directory added like label in the inventory
-func (role *Role) ReadRole(rootPath string, pathTags ...string) (err error) {
+func (role *Role) ReadRoleTasks(rootPath string, pathTags ...string) (err error) {
 	absRoot, err := filepath.Abs(rootPath + "/roles/" + role.Name)
+	fmt.Println("reading ", role.Name, "at: ", absRoot)
 
 	if err != nil {
-		klog.Error("The role ", role.Name, "can't be read. Error:", err.Error())
+		fmt.Println("The role ", role.Name, "can't be read. Error:", err.Error())
 		return
 	}
 
+	fmt.Println(role.Name)
 	err = godirwalk.Walk(absRoot, &godirwalk.Options{
 		Callback: func(osPathname string, de *godirwalk.Dirent) error {
 
-			tags := utils.NewSet()
-
 			if !strings.Contains(filepath.Base(osPathname), ".yml") {
 				return nil
 			}
 
 			binData, err := ioutil.ReadFile(osPathname)
 			if err != nil {
-				klog.Error("Cannot read file: ", osPathname, ". Error:", err.Error())
+				fmt.Println("Cannot read file: ", osPathname, ". Error:", err.Error())
 			}
 
 			var tasks []Task
 			err = yaml.Unmarshal([]byte(binData), &tasks)
+
+			if err != nil {
+				fmt.Println("error readin role", osPathname, "err:", err.Error())
+			} else {
+				fmt.Println("task is", tasks)
+			}
+
 			for _, task := range tasks {
-				tags.Concat(task.Tags())
+				role.Tasks = append(role.Tasks, task)
 			}
 
-			klog.Info("tags in role tags:", role.rawTags)
+			fmt.Println(osPathname, "tags in role tags:", role.AllTags())
 
-			tasks = append(tasks, Task{rawTags: tags.List()})
-			if len(tags.List()) > 0 {
-				klog.Info("Task tags:", tags.List())
-			}
 			return nil
 		},
 		ErrorCallback: func(osPathname string, err error) godirwalk.ErrorAction {
+			fmt.Println(err.Error())
 			return godirwalk.SkipNode
 		},
 		Unsorted: true,

internal/ansible/task.go

@@ -3,10 +3,6 @@ package ansible
 import "github.com/ca-gip/dploy/internal/utils"
 
 type Task struct {
-	Role    string      `json:"role"`
-	rawTags interface{} `json:"tags,omitempty" yaml:"tags,omitempty"`
-}
-
-func (task *Task) Tags() []string {
-	return utils.InferSlice(task.rawTags)
+	Name string `yaml:"name,omitempty"`
+	Tags utils.Set
 }

internal/ansible/task_test.go

@@ -20,15 +20,6 @@ const validTaskWithoutName = `
   tags: tasktag1
 `
 
-const validMultiTask = `
-- template: src="source" dest="destination" owner=root
-  tags: tasktag1
-
-- name: task2
-  template: src="source" dest="destination" owner=root
-  tags: tasktag2
-`
-
 var expectedValidTask1 = Task{
 	Name: "Task1",
 	Tags: *utils.NewSetFromSlice("tasktag1"),
@@ -109,22 +100,4 @@ func TestTask(t *testing.T) {
 		}
 	})
 
-	t.Run("with multitask should have tags", func(t *testing.T) {
-		binData := []byte(validMultiTask)
-		var tasks []Task
-		err := yaml.Unmarshal([]byte(binData), &tasks)
-
-		assert.Nil(t, err)
-		assert.NotNil(t, tasks)
-		assert.NotEmpty(t, tasks)
-		assert.Len(t, tasks, 2)
-
-		expected := *utils.NewSetFromSlice("tasktag1", "tasktag2")
-		actual := utils.NewSet().Concat(tasks[0].Tags.List()).Concat(tasks[1].Tags.List())
-
-		if diff := deep.Equal(expected.List(), actual.List()); len(diff) != 0 {
-			t.Error(diff)
-		}
-	})
-
 }

internal/utils/converter.go

@@ -22,6 +22,9 @@ func InferSlice(input interface{}) (slice []string) {
 		return
 	case reflect.String:
 		slice = strings.Split(value.String(), ",")
+		fmt.Println("String find type for", value)
+		fmt.Println("String find type for", slice)
+		return slice
 	default:
 		fmt.Println("cannot find type for", value)
 	}