snowblock.Snowblock API implementation

Implemented the `pkg/api/snowblock.Snowblock` interface (designed in
GH-70) that represents a snowblock. It stores task data and metadata of
a snowblock, validates it and dispatches the tasks to a registered
`TaskRunner` (designed in GH-70) if one matches the task name, otherwise
skips the unknown task.

Epic GH-33
Resolves GH-72

Author: arcticicestudio

pkg/snowblock/snowblock.go

@@ -0,0 +1,140 @@
+// Copyright (C) 2017-present Arctic Ice Studio <[email protected]>
+// Copyright (C) 2017-present Sven Greb <[email protected]>
+//
+// Project:    snowsaw
+// Repository: https://github.com/arcticicestudio/snowsaw
+// License:    MIT
+
+// Author: Arctic Ice Studio <[email protected]>
+// Author: Sven Greb <[email protected]>
+// Since: 0.4.0
+
+// Package snowblock provides the implementation of the snowblock API.
+package snowblock
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+
+	"github.com/fatih/color"
+
+	api "github.com/arcticicestudio/snowsaw/pkg/api/snowblock"
+	"github.com/arcticicestudio/snowsaw/pkg/config/encoder"
+	"github.com/arcticicestudio/snowsaw/pkg/config/encoder/json"
+	"github.com/arcticicestudio/snowsaw/pkg/config/source/file"
+	"github.com/arcticicestudio/snowsaw/pkg/prt"
+	"github.com/arcticicestudio/snowsaw/pkg/util/filesystem"
+)
+
+// Configuration i
+type Configuration []map[string]interface{}
+
+// Snowblock represents the state and actions of a snowblock.
+// It implements the snowblock API interface.
+type Snowblock struct {
+	// IsValid indicates if this snowblock is valid.
+	IsValid bool
+
+	// Path is the path of this snowblock.
+	Path string
+
+	// TaskObjects is a list of task objects this snowblock configuration consists of.
+	TaskObjects []api.Task
+
+	// TaskRunnerMapping contains the assignments from task objects to a matching task runner.
+	TaskRunnerMapping map[api.TaskRunner]api.TaskConfiguration
+
+	// UnsupportedTasks is a list of task names that are not supported by an registered task runner.
+	UnsupportedTasks []api.TaskConfiguration
+}
+
+// NewSnowblock returns a new snowblock.
+func NewSnowblock(path string) *Snowblock {
+	return &Snowblock{
+		Path:              path,
+		TaskObjects:       make([]api.Task, 0),
+		TaskRunnerMapping: make(map[api.TaskRunner]api.TaskConfiguration),
+	}
+}
+
+// Dispatch handles the processing of the snowblock by dispatching the configured tasks to a registered runner that can
+// handle it.
+func (s *Snowblock) Dispatch() error {
+	for runner, instructions := range s.TaskRunnerMapping {
+		if err := runner.Run(instructions, s.Path); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Validate ensures the snowblock and the configuration file exist.
+// It returns false along with an corresponding error if the snowblock path doesn't exist or is not a directory.
+// The snowblock is also not valid either when the given directory does not contain a configuration file or the file
+// is not parsable.
+// Defined tasks that are not supported by any of the given task runners are filtered into the separate array.
+func (s *Snowblock) Validate(taskRunner map[string]api.TaskRunner) error {
+	// Expand the given snowblock path and convert it into an absolute path.
+	expandedPath, expPathErr := filesystem.ExpandPath(s.Path)
+	if expPathErr != nil {
+		return fmt.Errorf("could not dissolve path: %v", expPathErr)
+	}
+	expandedAbsPath, expAbsPathErr := filepath.Abs(expandedPath)
+	if expAbsPathErr != nil {
+		return fmt.Errorf("could not convert into absolute path: %v", expAbsPathErr)
+	}
+
+	// Ensure the path is a directory and exists.
+	dirExists, dirExistsErr := filesystem.DirExists(expandedAbsPath)
+	if dirExistsErr != nil {
+		return dirExistsErr
+	}
+	if !dirExists {
+		return fmt.Errorf("no such directory: %s", expandedAbsPath)
+	}
+	s.Path = expandedAbsPath
+
+	// Try to read and encode the task objects when the directory contains a configuration file.
+	configFilePath := filepath.Join(s.Path, fmt.Sprintf("%s.%s", api.ConfigurationFileName, encoder.ExtensionsJson))
+	if configLoadErr := loadConfigFile(configFilePath, &s.TaskObjects); configLoadErr != nil {
+		prt.Debugf("Ignoring snowblock directory %s without valid configuration file: %s: %v",
+			color.CyanString(filepath.Base(s.Path)), color.BlueString(configFilePath), configLoadErr)
+		return nil
+	}
+
+	// Assign each task object to a registered task runner when matching, otherwise add to list of unsupported tasks.
+	for _, taskObject := range s.TaskObjects {
+		for taskName, taskConfigMap := range taskObject {
+			runner, exists := taskRunner[taskName]
+			if exists {
+				s.TaskRunnerMapping[runner] = taskConfigMap
+				continue
+			}
+			s.UnsupportedTasks = append(s.UnsupportedTasks, taskName)
+			prt.Debugf("Ignoring task without registered runner: %s", color.RedString(taskName))
+		}
+	}
+
+	s.IsValid = true
+	return nil
+}
+
+func loadConfigFile(absPath string, tasks *[]api.Task) error {
+	f := file.NewFile(absPath).WithEncoder(json.NewJsonEncoder())
+	// Check if the file exists...
+	if exists, _ := filesystem.FileExists(f.Path); !exists {
+		return fmt.Errorf("no such snowblock configuration file: %s", color.RedString(f.Path))
+	}
+	// ...and decode the file content with the given tasks using the assigned encoder.
+	content, err := ioutil.ReadFile(f.Path)
+	if err != nil {
+		return err
+	}
+	if encErr := f.Encoder.Decode(content, tasks); encErr != nil {
+		return fmt.Errorf("could not load snowblock configuration file: %s: %v", f.Path, encErr)
+	}
+
+	return nil
+}