Moving server files to ./server

server/codegen/tool/main.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path"
+	"text/template"
+	"time"
+
+	"github.com/cortezaproject/corteza-server/pkg/cli"
+)
+
+type (
+	inOut struct {
+		Template string `json:"template"`
+		Output   string `json:"output"`
+		Syntax   string `json:"syntax"`
+	}
+
+	task struct {
+		inOut
+
+		Bulk []inOut `json:"bulk"`
+
+		Payload interface{} `json:"payload"`
+	}
+)
+
+var (
+	verbose     bool
+	showHelp    bool
+	tplRootPath string
+	outputBase  string
+)
+
+func init() {
+	flag.BoolVar(&showHelp, "h", false, "show help")
+	flag.BoolVar(&verbose, "v", false, "be verbose")
+	flag.StringVar(&tplRootPath, "p", "codegen/assets/templates", "location of the template files")
+	flag.StringVar(&outputBase, "b", ".", "base dir for output")
+	flag.Parse()
+}
+
+// Takes JSON input with codegen tasks and definitions and generates files
+func main() {
+	if showHelp {
+		flag.PrintDefaults()
+		os.Exit(0)
+	}
+
+	var (
+		input = json.NewDecoder(os.Stdin)
+		tasks = make([]*task, 0)
+		tpl   *template.Template
+		err   error
+	)
+
+	started := time.Now()
+	print("Waiting for stdin ...")
+	if err = input.Decode(&tasks); err != nil {
+		cli.HandleError(fmt.Errorf("failed to decode input from standard input: %v", err))
+	}
+
+	println(time.Now().Sub(started).Round(time.Second)/time.Second, "sec")
+
+	if tpl, err = loadTemplates(baseTemplate(), tplRootPath); err != nil {
+		cli.HandleError(fmt.Errorf("failed to load templates: %v", err))
+	}
+
+	for _, j := range tasks {
+		if len(j.Bulk) == 0 {
+			j.Bulk = append(j.Bulk, j.inOut)
+		}
+
+		for _, o := range j.Bulk {
+			output := path.Join(outputBase, o.Output)
+			print(fmt.Sprintf("generating %s (from %s) ...", output, o.Template))
+
+			switch o.Syntax {
+			case "go":
+				err = writeFormattedGo(output, tpl.Lookup(o.Template), j.Payload)
+			default:
+				err = write(output, tpl.Lookup(o.Template), j.Payload)
+			}
+
+			if err != nil {
+				cli.HandleError(fmt.Errorf("failed to write template: %v", err))
+			} else {
+				print("done\n")
+			}
+		}
+	}
+}
+
+func print(msg string) {
+	if verbose {
+		_, _ = fmt.Fprint(os.Stderr, msg)
+	}
+}

server/codegen/tool/templating.go

@@ -0,0 +1,105 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/template"
+
+	"github.com/Masterminds/sprig"
+)
+
+func baseTemplate() *template.Template {
+	return template.New("").
+		Funcs(sprig.TxtFuncMap())
+}
+
+func loadTemplates(rTpl *template.Template, rootDir string) (*template.Template, error) {
+	cleanRoot := filepath.Clean(rootDir)
+	pfx := len(cleanRoot) + 1
+
+	return rTpl, filepath.Walk(cleanRoot, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() || !strings.HasSuffix(path, ".tpl") || err != nil {
+			return err
+		}
+
+		b, err := ioutil.ReadFile(path)
+		if err != nil {
+			return err
+		}
+
+		name := path[pfx:]
+		rTpl, err = rTpl.New(name).Parse(string(b))
+
+		return err
+	})
+}
+
+func writeFormattedGo(dst string, tpl *template.Template, payload interface{}) error {
+	return write(dst, tpl, payload, func(in io.ReadWriter) (out io.ReadWriter, err error) {
+		var (
+			org, bb []byte
+		)
+
+		if org, err = ioutil.ReadAll(in); err != nil {
+			return
+		}
+
+		cp := bytes.NewBuffer(org)
+
+		if bb, err = format.Source(cp.Bytes()); err != nil {
+			// output error and return un-formatted source
+			_, _ = fmt.Fprintf(os.Stderr, "%s fmt warn: %v\n", dst, err)
+			return cp, nil
+		}
+
+		return bytes.NewBuffer(bb), nil
+	})
+}
+
+func write(dst string, tpl *template.Template, payload interface{}, pp ...func(io.ReadWriter) (io.ReadWriter, error)) (err error) {
+	var (
+		output io.WriteCloser
+		buf    io.ReadWriter
+	)
+
+	if tpl == nil {
+		return fmt.Errorf("could not find template for %s", dst)
+	}
+
+	buf = &bytes.Buffer{}
+	if err := tpl.Execute(buf, payload); err != nil {
+		return err
+	}
+
+	for _, proc := range pp {
+		if buf, err = proc(buf); err != nil {
+			return
+		}
+	}
+
+	if dst == "" || dst == "-" {
+		output = os.Stdout
+	} else {
+		if output, err = os.Create(dst); err != nil {
+			return err
+		}
+
+		defer output.Close()
+	}
+
+	if _, err = io.Copy(output, buf); err != nil {
+		return err
+	}
+
+	return nil
+}