lang: Initial implementation of the mgmt language

This is an initial implementation of the mgmt language. It is a
declarative (immutable) functional, reactive, domain specific
programming language. It is intended to be a language that is:

* safe
* powerful
* easy to reason about

With these properties, we hope this language, and the mgmt engine will
allow you to model the real-time systems that you'd like to automate.

This also includes a number of other associated changes. Sorry for the
large size of this patch.

util/afero.go

@@ -0,0 +1,136 @@
+// Mgmt
+// Copyright (C) 2013-2018+ James Shubin and the project contributors
+// Written by James Shubin <james@shubin.ca> and the project contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package util
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path"
+
+	"github.com/spf13/afero"
+)
+
+// FsTree returns a string representation of the file system tree similar to the
+// well-known `tree` command.
+func FsTree(fs afero.Fs, name string) (string, error) {
+	str := ".\n" // top level dir
+	s, err := stringify(fs, path.Clean(name), []bool{})
+	if err != nil {
+		return "", err
+	}
+	str += s
+	return str, nil
+}
+
+func stringify(fs afero.Fs, name string, indent []bool) (string, error) {
+	str := ""
+	dir, err := fs.Open(name)
+	if err != nil {
+		return "", err
+	}
+
+	fileinfo, err := dir.Readdir(-1)
+	if err != nil && err != io.EOF {
+		return "", err
+	}
+	for i, fi := range fileinfo {
+		for _, last := range indent {
+			if last {
+				str += "    "
+			} else {
+				str += "│   "
+			}
+		}
+
+		header := "├── "
+		var last bool
+		if i == len(fileinfo)-1 { // if last
+			header = "└── "
+			last = true
+		}
+
+		p := fi.Name()
+		if fi.IsDir() {
+			p += "/" // identify as a dir
+		}
+		str += fmt.Sprintf("%s%s\n", header, p)
+		if fi.IsDir() {
+			indented := append(indent, last)
+			s, err := stringify(fs, path.Join(name, p), indented)
+			if err != nil {
+				return "", err // TODO: return partial tree?
+			}
+			str += s
+		}
+	}
+	return str, nil
+}
+
+// CopyFs copies a dir from the srcFs to a dir on the dstFs. It expects that the
+// dst will be either empty, or that the force flag will be set to true. If the
+// dst has a different set of contents in the same location, the behaviour is
+// currently undefined.
+// TODO: this should be made more rsync like and robust!
+func CopyFs(srcFs, dstFs afero.Fs, src, dst string, force bool) error {
+	if src == "" {
+		src = "/"
+	}
+	if dst == "" {
+		dst = "/"
+	}
+	walkFn := func(name string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		//perm := info.Perm()
+		perm := info.Mode() // TODO: is this correct?
+		p := name
+		if dst != "/" {
+			p = path.Join(dst, name) // relative dest in dst
+		}
+		if info.IsDir() {
+			err := dstFs.Mkdir(p, perm)
+			if os.IsExist(err) && (name == "/" || force) {
+				return nil
+			}
+			return err
+		}
+
+		data, err := afero.ReadFile(srcFs, name)
+		if err != nil {
+			return err
+		}
+		// create file
+		return afero.WriteFile(dstFs, p, data, perm)
+	}
+
+	return afero.Walk(srcFs, src, walkFn)
+}
+
+// CopyFsToDisk performs exactly as CopyFs, except that the dst fs is our local
+// disk os fs.
+func CopyFsToDisk(srcFs afero.Fs, src, dst string, force bool) error {
+	return CopyFs(srcFs, afero.NewOsFs(), src, dst, force)
+}
+
+// CopyDiskToFs performs exactly as CopyFs, except that the src fs is our local
+// disk os fs.
+func CopyDiskToFs(dstFs afero.Fs, src, dst string, force bool) error {
+	return CopyFs(afero.NewOsFs(), dstFs, src, dst, force)
+}