b19583e7d3
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.
137 lines
3.4 KiB
Go
137 lines
3.4 KiB
Go
// 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)
|
|
}
|