github.com/masahide/goansible@v0.0.0-20160116054156-01eac649e9f2/main.go (about)

     1  package goansible
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"log"
     7  	"os"
     8  	"path/filepath"
     9  
    10  	"github.com/jessevdk/go-flags"
    11  )
    12  
    13  type Options struct {
    14  	Vars        map[string]string `short:"s" long:"set" description:"Set a variable"`
    15  	ShowOutput  bool              `short:"o" long:"output" description:"Show command output"`
    16  	ShowVersion bool              `short:"v" long:"version" description:"Show version"`
    17  	Passphrase  string            `short:"p" long:"Passphrase" description:"passphrase of decode"`
    18  	Development bool              `long:"dev" description:"Use a dev version of goansible"`
    19  	Debug       bool              `short:"d" long:"debug" description:"Show all information about commands"`
    20  	JSON        bool              `long:"json" description:"Output the run details in chunked json"`
    21  	//CleanHost   bool              `long:"clean-host" description:"Clean the host cache before using"`
    22  	//Host        string            `short:"t" long:"host" description:"Run the playbook on another host"`
    23  	//Release     string            `long:"release" description:"The release to use when remotely invoking goansible"`
    24  	//Install     bool              `long:"install" description:"Install goansible a remote machine"`
    25  }
    26  
    27  var Release string = "dev"
    28  var Version string
    29  var Arg0 string
    30  
    31  //go:generate go-bindata -pkg=goansible data/...
    32  
    33  func Main(args []string) int {
    34  	var opts Options
    35  
    36  	abs, err := filepath.Abs(args[0])
    37  	if err != nil {
    38  		panic(err)
    39  	}
    40  
    41  	Arg0 = abs
    42  
    43  	parser := flags.NewParser(&opts, flags.Default)
    44  
    45  	for _, o := range parser.Command.Group.Groups()[0].Options() {
    46  		if o.LongName == "release" {
    47  			o.Default = []string{Release}
    48  		}
    49  	}
    50  	args, err = parser.ParseArgs(args)
    51  
    52  	if err != nil {
    53  		if serr, ok := err.(*flags.Error); ok {
    54  			if serr.Type == flags.ErrHelp {
    55  				return 2
    56  			}
    57  		}
    58  
    59  		fmt.Printf("Error parsing options: %s", err)
    60  		return 1
    61  	}
    62  
    63  	if opts.ShowVersion {
    64  		fmt.Println(filepath.Base(args[0]), "Version:", Version)
    65  		return 0
    66  	}
    67  	if /*!opts.Install &&*/ len(args) != 2 {
    68  		fmt.Printf("Usage: goansible [options] <playbook>\n")
    69  		return 1
    70  	}
    71  
    72  	/*
    73  		if opts.Host != "" {
    74  			return runOnHost(&opts, args)
    75  		}
    76  	*/
    77  
    78  	cfg := &Config{ShowCommandOutput: opts.ShowOutput, Passphrase: opts.Passphrase}
    79  
    80  	ns := NewNestedScope(nil)
    81  
    82  	for k, v := range opts.Vars {
    83  		ns.Set(k, v)
    84  	}
    85  
    86  	env := NewEnv(ns, cfg)
    87  	defer env.Cleanup()
    88  
    89  	if opts.JSON {
    90  		//env.ReportJSON()
    91  		env.ReportStruct()
    92  	}
    93  
    94  	playbookFile := args[1]
    95  	err = StartPlaybook(env, playbookFile)
    96  	if opts.JSON {
    97  		j, err := json.MarshalIndent(env.report, "", " ")
    98  		if err != nil {
    99  			log.Println(err)
   100  		}
   101  		fmt.Println(string(j))
   102  	}
   103  	if err != nil {
   104  		log.Println(err)
   105  		return 1
   106  	}
   107  	return 0
   108  }
   109  
   110  func StartPlaybook(env *Environment, file string) error {
   111  
   112  	playbook, err := NewPlaybook(env, file)
   113  	if err != nil {
   114  		return fmt.Errorf("Error loading plays: %s\n", err)
   115  	}
   116  
   117  	cur, err := os.Getwd()
   118  	if err != nil {
   119  		return fmt.Errorf("Unable to figure out the current directory: %s\n", err)
   120  	}
   121  
   122  	defer os.Chdir(cur)
   123  	os.Chdir(playbook.baseDir)
   124  
   125  	runner := NewRunner(env, playbook.Plays)
   126  	err = runner.Run(env)
   127  
   128  	if err != nil {
   129  		return fmt.Errorf("Error running playbook: %s\n", err)
   130  	}
   131  	return nil
   132  }
   133  
   134  /*
   135  func runOnHost(opts *Options, args []string) int {
   136  	if opts.Install {
   137  		fmt.Printf("=== Installing goansible on %s\n", opts.Host)
   138  	} else {
   139  		fmt.Printf("=== Executing playbook on %s\n", opts.Host)
   140  	}
   141  
   142  	var playbook string
   143  
   144  	if !opts.Install {
   145  		playbook = args[1]
   146  	}
   147  
   148  	t := &Tachyon{
   149  		Target:      opts.Host,
   150  		Debug:       opts.Debug,
   151  		Output:      opts.ShowOutput,
   152  		Clean:       opts.CleanHost,
   153  		Dev:         opts.Development,
   154  		Playbook:    playbook,
   155  		Release:     opts.Release,
   156  		InstallOnly: opts.Install,
   157  	}
   158  
   159  	_, err := RunAdhocCommand(t, t.Debug, t.Output, "")
   160  	if err != nil {
   161  		fmt.Printf("Error: %s\n", err)
   162  		return 1
   163  	}
   164  
   165  	return 0
   166  }
   167  */