ea52eb78d9
I have an improved design for remote execution as a resource. Since I need to get rid of some technical debt to clean up the resource API, and this main loop, a good first step is to remote it's invocation. It will be coming back as a resource as soon as possible!
424 lines
11 KiB
Go
424 lines
11 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 lib
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/signal"
|
|
"sort"
|
|
"syscall"
|
|
|
|
"github.com/purpleidea/mgmt/bindata"
|
|
"github.com/purpleidea/mgmt/gapi"
|
|
|
|
"github.com/spf13/afero"
|
|
"github.com/urfave/cli"
|
|
)
|
|
|
|
// Fs is a simple wrapper to a memory backed file system to be used for
|
|
// standalone deploys. This is basically a pass-through so that we fulfill the
|
|
// same interface that the deploy mechanism uses.
|
|
type Fs struct {
|
|
*afero.Afero
|
|
}
|
|
|
|
// URI returns the unique URI of this filesystem. It returns the root path.
|
|
func (obj *Fs) URI() string { return fmt.Sprintf("%s://"+"/", obj.Name()) }
|
|
|
|
// run is the main run target.
|
|
func run(c *cli.Context) error {
|
|
|
|
obj := &Main{}
|
|
|
|
obj.Program = c.App.Name
|
|
obj.Version = c.App.Version
|
|
if val, exists := c.App.Metadata["flags"]; exists {
|
|
if flags, ok := val.(Flags); ok {
|
|
obj.Flags = flags
|
|
}
|
|
}
|
|
|
|
if h := c.String("hostname"); c.IsSet("hostname") && h != "" {
|
|
obj.Hostname = &h
|
|
}
|
|
|
|
if s := c.String("prefix"); c.IsSet("prefix") && s != "" {
|
|
obj.Prefix = &s
|
|
}
|
|
obj.TmpPrefix = c.Bool("tmp-prefix")
|
|
obj.AllowTmpPrefix = c.Bool("allow-tmp-prefix")
|
|
|
|
// add the versions GAPIs
|
|
names := []string{}
|
|
for name := range gapi.RegisteredGAPIs {
|
|
names = append(names, name)
|
|
}
|
|
sort.Strings(names) // ensure deterministic order when parsing
|
|
|
|
// create a memory backed temporary filesystem for storing runtime data
|
|
mmFs := afero.NewMemMapFs()
|
|
afs := &afero.Afero{Fs: mmFs} // wrap so that we're implementing ioutil
|
|
standaloneFs := &Fs{afs}
|
|
obj.DeployFs = standaloneFs
|
|
|
|
for _, name := range names {
|
|
fn := gapi.RegisteredGAPIs[name]
|
|
deployObj, err := fn().Cli(c, standaloneFs)
|
|
if err != nil {
|
|
log.Printf("GAPI cli parse error: %v", err)
|
|
//return cli.NewExitError(err.Error(), 1) // TODO: ?
|
|
return cli.NewExitError("", 1)
|
|
}
|
|
if deployObj == nil { // not used
|
|
continue
|
|
}
|
|
if obj.Deploy != nil { // already set one
|
|
return fmt.Errorf("can't combine `%s` GAPI with existing GAPI", name)
|
|
}
|
|
obj.Deploy = deployObj
|
|
}
|
|
|
|
obj.NoWatch = c.Bool("no-watch")
|
|
obj.NoConfigWatch = c.Bool("no-config-watch")
|
|
obj.NoStreamWatch = c.Bool("no-stream-watch")
|
|
|
|
obj.Noop = c.Bool("noop")
|
|
obj.Sema = c.Int("sema")
|
|
obj.Graphviz = c.String("graphviz")
|
|
obj.GraphvizFilter = c.String("graphviz-filter")
|
|
obj.ConvergedTimeout = c.Int("converged-timeout")
|
|
obj.MaxRuntime = uint(c.Int("max-runtime"))
|
|
|
|
obj.Seeds = c.StringSlice("seeds")
|
|
obj.ClientURLs = c.StringSlice("client-urls")
|
|
obj.ServerURLs = c.StringSlice("server-urls")
|
|
obj.AdvertiseClientURLs = c.StringSlice("advertise-client-urls")
|
|
obj.AdvertiseServerURLs = c.StringSlice("advertise-server-urls")
|
|
obj.IdealClusterSize = c.Int("ideal-cluster-size")
|
|
obj.NoServer = c.Bool("no-server")
|
|
|
|
obj.NoPgp = c.Bool("no-pgp")
|
|
|
|
if kp := c.String("pgp-key-path"); c.IsSet("pgp-key-path") {
|
|
obj.PgpKeyPath = &kp
|
|
}
|
|
|
|
if us := c.String("pgp-identity"); c.IsSet("pgp-identity") {
|
|
obj.PgpIdentity = &us
|
|
}
|
|
|
|
if err := obj.Init(); err != nil {
|
|
return err
|
|
}
|
|
|
|
obj.Prometheus = c.Bool("prometheus")
|
|
obj.PrometheusListen = c.String("prometheus-listen")
|
|
|
|
// install the exit signal handler
|
|
exit := make(chan struct{})
|
|
defer close(exit)
|
|
go func() {
|
|
signals := make(chan os.Signal, 1)
|
|
signal.Notify(signals, os.Interrupt) // catch ^C
|
|
//signal.Notify(signals, os.Kill) // catch signals
|
|
signal.Notify(signals, syscall.SIGTERM)
|
|
|
|
select {
|
|
case sig := <-signals: // any signal will do
|
|
if sig == os.Interrupt {
|
|
log.Println("Interrupted by ^C")
|
|
obj.Exit(nil)
|
|
return
|
|
}
|
|
log.Println("Interrupted by signal")
|
|
obj.Exit(fmt.Errorf("killed by %v", sig))
|
|
return
|
|
case <-exit:
|
|
return
|
|
}
|
|
}()
|
|
|
|
if err := obj.Run(); err != nil {
|
|
// log the error message returned
|
|
log.Printf("Main: Error: %v", err)
|
|
//return cli.NewExitError(err.Error(), 1) // TODO: ?
|
|
return cli.NewExitError("", 1)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// CLI is the entry point for using mgmt normally from the CLI.
|
|
func CLI(program, version string, flags Flags) error {
|
|
|
|
// test for sanity
|
|
if program == "" || version == "" {
|
|
return fmt.Errorf("program was not compiled correctly, see Makefile")
|
|
}
|
|
|
|
runFlags := []cli.Flag{
|
|
// useful for testing multiple instances on same machine
|
|
cli.StringFlag{
|
|
Name: "hostname",
|
|
Value: "",
|
|
Usage: "hostname to use",
|
|
},
|
|
|
|
cli.StringFlag{
|
|
Name: "prefix",
|
|
Usage: "specify a path to the working prefix directory",
|
|
EnvVar: "MGMT_PREFIX",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "tmp-prefix",
|
|
Usage: "request a pseudo-random, temporary prefix to be used",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "allow-tmp-prefix",
|
|
Usage: "allow creation of a new temporary prefix if main prefix is unavailable",
|
|
},
|
|
|
|
cli.BoolFlag{
|
|
Name: "no-watch",
|
|
Usage: "do not update graph under any switch events",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "no-config-watch",
|
|
Usage: "do not update graph on config switch events",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "no-stream-watch",
|
|
Usage: "do not update graph on stream switch events",
|
|
},
|
|
|
|
cli.BoolFlag{
|
|
Name: "noop",
|
|
Usage: "globally force all resources into no-op mode",
|
|
},
|
|
cli.IntFlag{
|
|
Name: "sema",
|
|
Value: -1,
|
|
Usage: "globally add a semaphore to all resources with this lock count",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "graphviz, g",
|
|
Value: "",
|
|
Usage: "output file for graphviz data",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "graphviz-filter, gf",
|
|
Value: "",
|
|
Usage: "graphviz filter to use",
|
|
},
|
|
cli.IntFlag{
|
|
Name: "converged-timeout, t",
|
|
Value: -1,
|
|
Usage: "exit after approximately this many seconds in a converged state",
|
|
EnvVar: "MGMT_CONVERGED_TIMEOUT",
|
|
},
|
|
cli.IntFlag{
|
|
Name: "max-runtime",
|
|
Value: 0,
|
|
Usage: "exit after a maximum of approximately this many seconds",
|
|
EnvVar: "MGMT_MAX_RUNTIME",
|
|
},
|
|
|
|
// if empty, it will startup a new server
|
|
cli.StringSliceFlag{
|
|
Name: "seeds, s",
|
|
Value: &cli.StringSlice{}, // empty slice
|
|
Usage: "default etc client endpoint",
|
|
EnvVar: "MGMT_SEEDS",
|
|
},
|
|
// port 2379 and 4001 are common
|
|
cli.StringSliceFlag{
|
|
Name: "client-urls",
|
|
Value: &cli.StringSlice{},
|
|
Usage: "list of URLs to listen on for client traffic",
|
|
EnvVar: "MGMT_CLIENT_URLS",
|
|
},
|
|
// port 2380 and 7001 are common
|
|
cli.StringSliceFlag{
|
|
Name: "server-urls, peer-urls",
|
|
Value: &cli.StringSlice{},
|
|
Usage: "list of URLs to listen on for server (peer) traffic",
|
|
EnvVar: "MGMT_SERVER_URLS",
|
|
},
|
|
// port 2379 and 4001 are common
|
|
cli.StringSliceFlag{
|
|
Name: "advertise-client-urls",
|
|
Value: &cli.StringSlice{},
|
|
Usage: "list of URLs to listen on for client traffic",
|
|
EnvVar: "MGMT_ADVERTISE_CLIENT_URLS",
|
|
},
|
|
// port 2380 and 7001 are common
|
|
cli.StringSliceFlag{
|
|
Name: "advertise-server-urls, advertise-peer-urls",
|
|
Value: &cli.StringSlice{},
|
|
Usage: "list of URLs to listen on for server (peer) traffic",
|
|
EnvVar: "MGMT_ADVERTISE_SERVER_URLS",
|
|
},
|
|
cli.IntFlag{
|
|
Name: "ideal-cluster-size",
|
|
Value: -1,
|
|
Usage: "ideal number of server peers in cluster; only read by initial server",
|
|
EnvVar: "MGMT_IDEAL_CLUSTER_SIZE",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "no-server",
|
|
Usage: "do not start embedded etcd server (do not promote from client to peer)",
|
|
},
|
|
|
|
cli.BoolFlag{
|
|
Name: "no-pgp",
|
|
Usage: "don't create pgp keys",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "pgp-key-path",
|
|
Value: "",
|
|
Usage: "path for instance key pair",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "pgp-identity",
|
|
Value: "",
|
|
Usage: "default identity used for generation",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "prometheus",
|
|
Usage: "start a prometheus instance",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "prometheus-listen",
|
|
Value: "",
|
|
Usage: "specify prometheus instance binding",
|
|
},
|
|
}
|
|
|
|
subCommands := []cli.Command{} // build deploy sub commands
|
|
|
|
names := []string{}
|
|
for name := range gapi.RegisteredGAPIs {
|
|
names = append(names, name)
|
|
}
|
|
sort.Strings(names) // ensure deterministic order when parsing
|
|
for _, x := range names {
|
|
name := x // create a copy in this scope
|
|
fn := gapi.RegisteredGAPIs[name]
|
|
gapiObj := fn()
|
|
flags := gapiObj.CliFlags() // []cli.Flag
|
|
|
|
runFlags = append(runFlags, flags...)
|
|
|
|
command := cli.Command{
|
|
Name: name,
|
|
Usage: fmt.Sprintf("deploy using the `%s` frontend", name),
|
|
Action: func(c *cli.Context) error {
|
|
if err := deploy(c, name, gapiObj); err != nil {
|
|
log.Printf("Deploy: Error: %v", err)
|
|
//return cli.NewExitError(err.Error(), 1) // TODO: ?
|
|
return cli.NewExitError("", 1)
|
|
}
|
|
return nil
|
|
},
|
|
Flags: flags,
|
|
}
|
|
subCommands = append(subCommands, command)
|
|
}
|
|
|
|
app := cli.NewApp()
|
|
app.Name = program // App.name and App.version pass these values through
|
|
app.Version = version
|
|
app.Usage = "next generation config management"
|
|
app.Metadata = map[string]interface{}{ // additional flags
|
|
"flags": flags,
|
|
}
|
|
|
|
// if no app.Command is specified
|
|
app.Action = func(c *cli.Context) error {
|
|
// print the license
|
|
if c.Bool("license") {
|
|
license, err := bindata.Asset("../COPYING") // use go-bindata to get the bytes
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Printf("%s", license)
|
|
return nil
|
|
}
|
|
|
|
// print help if no flags are set
|
|
cli.ShowAppHelp(c)
|
|
return nil
|
|
}
|
|
|
|
// global flags
|
|
app.Flags = []cli.Flag{
|
|
cli.BoolFlag{
|
|
Name: "license",
|
|
Usage: "prints the software license",
|
|
},
|
|
}
|
|
|
|
app.Commands = []cli.Command{
|
|
{
|
|
Name: "run",
|
|
Aliases: []string{"r"},
|
|
Usage: "run",
|
|
Action: run,
|
|
Flags: runFlags,
|
|
},
|
|
{
|
|
Name: "deploy",
|
|
Aliases: []string{"d"},
|
|
Usage: "deploy",
|
|
Subcommands: subCommands,
|
|
Flags: []cli.Flag{
|
|
cli.StringSliceFlag{
|
|
Name: "seeds, s",
|
|
Value: &cli.StringSlice{}, // empty slice
|
|
Usage: "default etc client endpoint",
|
|
EnvVar: "MGMT_SEEDS",
|
|
},
|
|
|
|
// common flags which all can use
|
|
cli.BoolFlag{
|
|
Name: "noop",
|
|
Usage: "globally force all resources into no-op mode",
|
|
},
|
|
cli.IntFlag{
|
|
Name: "sema",
|
|
Value: -1,
|
|
Usage: "globally add a semaphore to all resources with this lock count",
|
|
},
|
|
|
|
cli.BoolFlag{
|
|
Name: "no-git",
|
|
Usage: "don't look at git commit id for safe deploys",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "force",
|
|
Usage: "force a new deploy, even if the safety chain would break",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
app.EnableBashCompletion = true
|
|
return app.Run(os.Args)
|
|
}
|