func (c ProjectCompiler) Compile(projectPath *string, dataFile *string, baseDir *string, workDir *string) {
log.Notice("▶ Loading environment data from file:\n %s", *projectPath)
environment, source, err := loadEnvironment(*projectPath)
if err != nil {
util.HandleFatalError(err)
}
for _, provider := range environment.Providers {
log.Notice("▶ Switching provider to: %s", provider.Name)
log.Debug(" Creating template context")
if context, err := createContext(&environment.Data, &provider, dataFile); err == nil {
log.Notice("▶ Context data:")
printContextData(context, false)
log.Notice("▶ Compiling artifacts")
if compiled, err := compileTemplateFromString(context, source); err == nil {
var project data.Project
if err := util.LoadYAMLFromString(*compiled, &project); err == nil {
// Compile each artifact
for _, artifact := range project.Artifacts {
//log.Info(" Compiling:\n artifact: %s\n provider: %s", artifact.Name, provider.Name)
if err := compileArtifact(context, &artifact, provider.Name, baseDir, workDir); err != nil {
util.HandleFatalError(err)
}
}
} else {
err := errors.New(fmt.Sprintf("Error parsing project artifacts\nerror:\n %s", err.Error()))
util.HandleFatalError(err)
}
} else {
util.HandleFatalError(err)
}
} else {
util.HandleFatalError(err)
}
}
log.Notice("▶ Completed successfully")
}
func main() {
var flagDebug bool
var flagVerbose bool
var flagQuiet bool
var flagProjectFile string
var flagDataFile string
// Root
var RootCommand = &cobra.Command{
Use: "magutt",
Short: "Magutt is a simple tool to assemble cloud-config files for CoreOS",
PersistentPreRun: func(cmd *cobra.Command, args []string) {
logLevel := log.LevelInfo
if flagQuiet && (flagDebug || flagVerbose) {
log.Warn("I'm confused... How can I be verbose and quiet at the same time?!?!?!?")
os.Exit(1)
} else {
if flagQuiet {
logLevel = log.LevelOff
} else {
if flagDebug {
logLevel = log.LevelDebug
}
// Verbose flag overrides debug level
if flagVerbose {
logLevel = log.LevelTrace
}
}
}
log.SetLogLevel(logLevel)
},
}
RootCommand.PersistentFlags().BoolVarP(&flagQuiet, "quiet", "q", false, "disable logging")
RootCommand.PersistentFlags().BoolVarP(&flagDebug, "debug", "d", false, "enable debug logging")
RootCommand.PersistentFlags().BoolVarP(&flagVerbose, "verbose", "v", false, "enable verbose logging")
// Build
var CmdBuild = &cobra.Command{
Use: "build",
Short: "Build a config file",
Run: func(cmd *cobra.Command, args []string) {
if err := validateAndRunBuildCommand(flagProjectFile, flagDataFile); err != nil {
cmd.Usage()
util.HandleFatalError(err)
}
},
}
CmdBuild.Flags().StringVarP(&flagProjectFile, "input", "i", "", "input project file")
CmdBuild.Flags().StringVarP(&flagDataFile, "extra", "e", "", "extra data file")
// Version
var CmdVersion = &cobra.Command{
Use: "version",
Short: "Print version number",
Run: func(cmd *cobra.Command, args []string) {
log.Notice("Magutt v%s\n", version)
},
}
// Common flags
RootCommand.AddCommand(CmdBuild)
RootCommand.AddCommand(CmdVersion)
// Process command line
RootCommand.Execute()
}
