flow.tmpl

package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"net/url"
	"os"
	"strconv"
	"strings"

	"github.com/gogap/config"
	"github.com/gogap/context"
	"github.com/gogap/flow"
	"github.com/gogap/logrus_mate"
	"github.com/sirupsen/logrus"
	"github.com/urfave/cli"
)

var (
	configStr = {{.config_str}}
)

func init() {
	if len(configStr) > 0 {
		configStrData, err := base64.StdEncoding.DecodeString(configStr)
		if err != nil {
			err = fmt.Errorf("decode config str failure: %s\n", err.Error())
			panic(err)
		}
		configStr = string(configStrData)
	}
}

func main() {

	conf := config.NewConfig(
		config.ConfigString(configStr),
	)

	appConf := conf.GetConfig("app")

	app := cli.NewApp()

	app.Version = appConf.GetString("version", "0.0.0")
	app.Author = appConf.GetString("author")
	app.Name = appConf.GetString("name", "app")
	app.Usage = appConf.GetString("usage")
	app.HelpName = app.Name

	if app.Version == "0.0.0" {
		app.HideVersion = true
	}

	commandsConf := appConf.GetConfig("commands")

	for _, key := range commandsConf.Keys() {
		generateCommands(&app.Commands, key, commandsConf.GetConfig(key))
	}

	app.RunAndExitOnError()

	return
}

func newAction(name string, conf config.Configuration) cli.ActionFunc {

	return func(ctx *cli.Context) (err error) {

		err = loadENV(ctx)

		if err != nil {
			return
		}

		skipSteps := ctx.StringSlice("skip")
		configFiles := ctx.StringSlice("config")
		logConfigFile := ctx.String("log-config")

		defaultConf := conf.GetConfig("default-config")

		mapConfigFile := map[string]string{}

		for _, configArg := range configFiles {
			v := strings.SplitN(configArg, ":", 2)
			if len(v) == 1 {
				mapConfigFile["default"] = v[0]
			} else if len(v) == 2 {
				mapConfigFile[v[0]] = v[1]
			}
		}

		if len(logConfigFile) > 0 {
			logrus_mate.Hijack(
				logrus.StandardLogger(),
				logrus_mate.ConfigFile(logConfigFile),
			)
		}

		flowCtx := context.NewContext()

		ctxList := ctx.StringSlice("ctx")
		ctxFiles := ctx.StringSlice("ctx-file")

		loadContext(ctxList, ctxFiles, flowCtx)

		inputFiles := ctx.StringSlice("input")

		for _, inputFile := range inputFiles {
			var inputFileData []byte
			inputFileData, err = ioutil.ReadFile(inputFile)
			if err != nil {
				return
			}

			var nameValues []flow.NameValue
			err = json.Unmarshal(inputFileData, &nameValues)
			if err != nil {
				return
			}

			flow.AppendOutput(flowCtx, nameValues...)
		}

		trans := flow.Begin(flowCtx, config.WithConfig(defaultConf))

		flowList := conf.GetStringList("flow")

		flowItemConfig := conf.GetConfig("config")

		mapSkipSteps := map[string]bool{}

		for _, step := range skipSteps {
			mapSkipSteps[step] = true
		}

		for i, strURL := range flowList {

			var flowURL *url.URL
			flowURL, err = url.Parse("flow://" + strURL)

			name := flowURL.Host

			id := flowURL.Query().Get("id")
			class := flowURL.Query().Get("class")

			if len(id) == 0 {
				id = strconv.Itoa(i)
			}

			if len(class) == 0 {
				class = "default"
			}

			if mapSkipSteps[id] {
				continue
			}

			if configFile, exist := mapConfigFile[class]; exist {
				trans.Then(name, config.ConfigFile(configFile))
			} else if flowItemConfig.HasPath(class) {
				handlerConf := flowItemConfig.GetConfig(class)
				trans.Then(name, config.WithConfig(handlerConf))
			} else {
				trans.Then(name)
			}
		}

		output := ctx.String("output")

		snapshotEnvsBegin := os.Environ()

		err = trans.Commit()

		snapshotEnvsEnd := os.Environ()

		deltaEnv := deltaEnvs(snapshotEnvsBegin, snapshotEnvsEnd)

		dumpEnvFile := ctx.String("dump-env")

		printToSTD := map[string]interface{}{}

		if len(dumpEnvFile) > 0 {

			dumpEnvData, errMarshal := json.MarshalIndent(
				deltaEnv,
				"",
				"    ")

			if errMarshal != nil {
				return
			}

			errWrite := ioutil.WriteFile(dumpEnvFile, dumpEnvData, 0644)
			if errWrite != nil {
				return
			}
		}

		if ctx.Bool("print-env") {
			printToSTD["environment"] = deltaEnv
		}

		nameValues := trans.Output()

		if ctx.Bool("print-output") {
			printToSTD["output"] = nameValues
		}

		if len(output) > 0 {
			outdata, errMarshal := json.MarshalIndent(
				nameValues,
				"",
				"    ")

			if errMarshal != nil {
				return
			}

			errWrite := ioutil.WriteFile(output, outdata, 0644)
			if errWrite != nil {
				return
			}
		}

		if len(printToSTD) > 0 {
			printData, errMarshal := json.MarshalIndent(
				printToSTD,
				"",
				"    ")

			printData = append(printData, '\n')

			io.Copy(os.Stdout, bytes.NewReader(printData))

			if errMarshal != nil {
				return
			}
		}

		if err != nil {
			return
		}

		return
	}
}

func deltaEnvs(envsA, envsB []string) map[string]string {

	mapEnvsA := map[string]string{}

	mapEnvsDelta := map[string]string{}

	for _, v := range envsA {
		env := strings.SplitN(v, "=", 2)
		if len(env) != 2 {
			continue
		}

		mapEnvsA[env[0]] = env[1]
	}

	for _, v := range envsB {
		env := strings.SplitN(v, "=", 2)
		if len(env) != 2 {
			continue
		}

		envAValue, exist := mapEnvsA[env[0]]

		if !exist {
			mapEnvsDelta[env[0]] = env[1]
		} else if envAValue != env[1] {
			mapEnvsDelta[env[0]] = env[1]
		}
	}

	return mapEnvsDelta
}

func loadENV(ctx *cli.Context) (err error) {
	envs := ctx.StringSlice("env")
	envFiles := ctx.StringSlice("env-file")

	if len(envs) == 0 && len(envFiles) == 0 {
		return
	}

	mapENV := map[string]string{}

	for _, env := range envs {
		v := strings.SplitN(env, ":", 2)
		if len(v) != 2 {
			err = fmt.Errorf("env format error:%s", env)
			return
		}

		mapENV[v[0]] = v[1]
	}

	for _, f := range envFiles {

		var data []byte
		data, err = ioutil.ReadFile(f)
		if err != nil {
			return
		}

		buf := bytes.NewBuffer(data)
		decoder := json.NewDecoder(buf)
		decoder.UseNumber()

		tmpMap := map[string]string{}
		err = decoder.Decode(&tmpMap)
		if err != nil {
			return
		}

		for k, v := range tmpMap {
			mapENV[k] = v
		}
	}

	for k, v := range mapENV {
		os.Setenv(k, v)
	}

	return
}

func loadContext(ctxList []string, ctxFiles []string, flowCtx context.Context) (err error) {

	if len(ctxList) == 0 && len(ctxFiles) == 0 {
		return
	}

	mapCtx := map[string]string{}

	for _, c := range ctxList {
		v := strings.SplitN(c, ":", 2)
		if len(v) != 2 {
			err = fmt.Errorf("ctx format error:%s", c)
			return
		}

		mapCtx[v[0]] = v[1]
	}

	for _, f := range ctxFiles {

		var data []byte
		data, err = ioutil.ReadFile(f)
		if err != nil {
			return
		}

		buf := bytes.NewBuffer(data)
		decoder := json.NewDecoder(buf)
		decoder.UseNumber()

		tmpMap := map[string]string{}
		err = decoder.Decode(&tmpMap)
		if err != nil {
			return
		}

		for k, v := range tmpMap {
			mapCtx[k] = v
		}
	}

	for k, v := range mapCtx {
		flowCtx.WithValue(k, v)
	}

	return
}

func generateCommands(cmds *[]cli.Command, name string, conf config.Configuration) {

	keys := conf.Keys()

	if len(keys) == 0 {
		return
	}

	objCount := 0
	for _, key := range keys {
		if conf.IsObject(key) || key == "usage" {
			objCount++
		}
	}

	// Command
	if objCount != len(keys) {
		*cmds = append(*cmds,
			cli.Command{
				Name:  name,
				Usage: conf.GetString("usage"),
				Flags: []cli.Flag{
					cli.StringSliceFlag{
						Name:  "skip, s",
						Usage: "skip steps by id, e.g.: -s 0 -s stepA",
					},
					cli.StringSliceFlag{
						Name:  "config, c",
						Usage: "mapping config to flow class, e.g.: --config default.conf --config classA:stepA.conf",
					},
					cli.StringSliceFlag{
						Name:  "env",
						Usage: "e.g.: --env USER:test --env PWD:asdf",
					},
					cli.StringSliceFlag{
						Name:  "ctx",
						Usage: "e.g.: --ctx code:gogap --env hello:world",
					},
					cli.StringSliceFlag{
						Name:  "env-file",
						Usage: "e.g.: --env-file a.json --env-file b.json",
					},
					cli.StringSliceFlag{
						Name:  "input, i",
						Usage: "input file from other's output for init this flow, e.g.: -i output1.json -i output2.json",
					},
					cli.StringFlag{
						Name:  "output, o",
						Usage: "filename of output",
					},
					cli.BoolFlag{
						Name:  "print-output",
						Usage: "print output to std",
					},
					cli.StringFlag{
						Name:  "dump-env",
						Usage: "dump delta env data to file",
					},
					cli.BoolFlag{
						Name:  "print-env",
						Usage: "print delta env data to std",
					},
					cli.StringFlag{
						Name:  "log-config",
						Usage: "logurs_mate logger's config",
					},
				},
				Action: newAction(name, conf),
			},
		)

		return
	}

	var subCommands []cli.Command

	for _, key := range conf.Keys() {

		if key == "usage" {
			continue
		}

		generateCommands(&subCommands, key, conf.GetConfig(key))

	}

	currentCommand := cli.Command{
		Name:        name,
		Usage:       conf.GetString("usage"),
		Subcommands: subCommands,
	}

	*cmds = append(*cmds, currentCommand)
}