func saveBootData(boot *BootOpts, blog string, elapsed time.Duration) error {
log.Debugf("%s in (%s)\n%s",
cmd.Colorfy(boot.B.GetFullName(), "cyan", "", "bold"),
cmd.Colorfy(elapsed.String(), "green", "", "bold"),
cmd.Colorfy(blog, "yellow", "", ""))
return nil
}
//this is an array, a property provider helps to load the provider specific stuff
func (s *Service) setProvisioner(pt string) error {
var err error
var tempProv provision.Provisioner
if tempProv, err = provision.Get(pt); err != nil {
return err
}
log.Debugf(cmd.Colorfy(" > configuring ", "blue", "", "bold") + fmt.Sprintf("%s ", pt))
if initializableProvisioner, ok := tempProv.(provision.InitializableProvisioner); ok {
err = initializableProvisioner.Initialize(s.Dockerd.toMap(), s.Bridges.ConvertToMap())
if err != nil {
return fmt.Errorf("unable to initialize %s provisioner\n --> %s", pt, err)
} else {
log.Debugf(cmd.Colorfy(fmt.Sprintf(" > %s initialized", pt), "blue", "", "bold"))
}
}
if messageProvisioner, ok := tempProv.(provision.MessageProvisioner); ok {
startupMessage, err := messageProvisioner.StartupMessage()
if err == nil && startupMessage != "" {
log.Infof(startupMessage)
}
}
carton.ProvisionerMap[pt] = tempProv
return nil
}
func saveDeployData(opts *StateOpts, dlog string, duration time.Duration) error {
log.Debugf("%s in (%s)\n%s",
cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
cmd.Colorfy(duration.String(), "green", "", "bold"),
cmd.Colorfy(dlog, "yellow", "", ""))
return nil
}
func saveUpgradeData(opts *Upgradeable, ulog string, duration time.Duration) error {
log.Debugf("%s in (%s)\n%s",
cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
cmd.Colorfy(duration.String(), "green", "", "bold"),
cmd.Colorfy(ulog, "yellow", "", ""))
return nil
}
func saveStateData(opts *StateChangeOpts, slog string, duration time.Duration, changeError error) error {
log.Debugf("%s in (%s)\n%s",
cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
cmd.Colorfy(duration.String(), "green", "", "bold"),
cmd.Colorfy(slog, "yellow", "", ""))
if opts.B.Level == provision.BoxSome && opts.B.Repo.IsEnabled() {
hookId, err := repository.Manager(opts.B.Repo.GetSource()).CreateHook(opts.B.Repo)
if err != nil {
return nil
}
comp, err := NewComponent(opts.B.Id)
if err != nil {
return err
}
if err = comp.setDeployData(DeployData{
Timestamp: time.Now(),
Duration: duration,
HookId: hookId,
}); err != nil {
return err
}
}
return nil
}
//initialize the provisioner and setup the requirements for provisioner
func (p *chefsoloProvisioner) Initialize(m map[string]string) error {
var outBuffer bytes.Buffer
start := time.Now()
p.Cookbook = m[CHEFREPO_COOKBOOK]
logWriter := carton.NewLogWriter(&provision.Box{CartonName: m[NAME]})
writer := io.MultiWriter(&outBuffer, &logWriter)
defer logWriter.Close()
cr := NewChefRepo(m, writer)
if err := cr.Download(true); err != nil {
err = provision.EventNotify(constants.StatusCookbookFailure)
return err
}
if err := cr.Torr(); err != nil {
err = provision.EventNotify(constants.StatusCookbookFailure)
return err
}
elapsed := time.Since(start)
log.Debugf("%s in (%s)\n%s",
cmd.Colorfy(m[NAME], "cyan", "", "bold"),
cmd.Colorfy(elapsed.String(), "green", "", "bold"),
cmd.Colorfy(outBuffer.String(), "yellow", "", ""))
_ = provision.EventNotify(constants.StatusCookbookSuccess)
return nil
}
func saveDeployData(opts *DeployOpts, imageId, dlog string, duration time.Duration, deployError error) error {
log.Debugf("%s in (%s)\n%s",
cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
cmd.Colorfy(duration.String(), "green", "", "bold"),
cmd.Colorfy(dlog, "yellow", "", ""))
//if there are deployments to track as follows in outputs: {} then do it here.
//Riak: code to save the status of a deploy (created.)
// deploy :
// name:
// status:
/*deploy := DeployData {
App: opts.App.Name,
Timestamp: time.Now(),
Duration: duration,
Commit: opts.Commit,
Image: imageId,
Log: log,
}
if opts.Commit != "" {
deploy.Origin = "git"
} else if opts.Image != "" {
deploy.Origin = "rollback"
} else {
deploy.Origin = "app-deploy"
}
if deployError != nil {
deploy.Error = deployError.Error()
}
return db.Store(compid or assmid, &struct)
*/
return nil
}
func saveLifecycleData(li *LifecycleOpts, llog string, elapsed time.Duration) error {
log.Debugf("%s in (%s)\n%s",
cmd.Colorfy(li.B.GetFullName(), "cyan", "", "bold"),
cmd.Colorfy(elapsed.String(), "green", "", "bold"),
cmd.Colorfy(llog, "yellow", "", ""))
return nil
}
func (p *dockerProvisioner) StartupMessage() (string, error) {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy(" > docker ", "white", "", "bold") + "\t" +
cmd.Colorfy(p.String(), "cyan", "", "")))
fmt.Fprintln(w)
w.Flush()
return strings.TrimSpace(b.String()), nil
}
func saveDestroyedData(opts *DestroyOpts, slog string, duration time.Duration, destroyError error) error {
log.Debugf("%s in (%s)\n%s",
cmd.Colorfy(opts.B.GetFullName(), "cyan", "", "bold"),
cmd.Colorfy(duration.String(), "green", "", "bold"),
cmd.Colorfy(slog, "yellow", "", ""))
if destroyError == nil {
markDeploysAsRemoved(opts)
}
return nil
}
func (c *Rpc) Call(command string, args []interface{}) ([]interface{}, error) {
log.Debugf(cmd.Colorfy(" > [one-go] ", "blue", "", "bold")+"%s", command)
log.Debugf(cmd.Colorfy("\n> args ", "cyan", "", "bold")+" %v\n", args)
result := []interface{}{}
if err := c.Client.Call(command, args, &result); err != nil {
return nil, err
}
//log.Debugf(cmd.Colorfy("\n> response ", "cyan", "", "bold")+" %v", result)
log.Debugf(cmd.Colorfy(" > [one-go] ( ´ ▽ ` ) SUCCESS", "blue", "", "bold"))
return result, nil
}
func (c Config) String() string {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Config:", "white", "", "bold") + "\t" +
cmd.Colorfy("httpd", "green", "", "") + "\n"))
b.Write([]byte("Enabled" + "\t" + strconv.FormatBool(c.Enabled) + "\n"))
b.Write([]byte("BindAddress" + "\t" + c.BindAddress + "\n"))
fmt.Fprintln(w)
w.Flush()
return b.String()
}
func (d DockerBridge) String() string {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 1, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Bridge", "white", "", "") + "\t" +
cmd.Colorfy(d.Name, "blue", "", "") + "\n"))
b.Write([]byte("network" + "\t" + d.Network + "\n"))
b.Write([]byte("gateway" + "\t" + d.Gateway + "\n"))
b.Write([]byte("---\n"))
fmt.Fprintln(w)
w.Flush()
return strings.TrimSpace(b.String())
}
func (c Config) String() string {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Config:", "white", "", "bold") + "\t" +
cmd.Colorfy("Metricsd", "cyan", "", "") + "\n"))
b.Write([]byte("enabled" + "\t" + strconv.FormatBool(c.Enabled) + "\n"))
b.Write([]byte("collect_interval" + "\t" + c.CollectInterval.String() + "\n"))
b.Write([]byte("---\n"))
fmt.Fprintln(w)
w.Flush()
return strings.TrimSpace(b.String())
}
func (c Config) String() string {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("\nConfig:", "white", "", "bold") + "\t" +
cmd.Colorfy("httpd", "cyan", "", "") + "\n"))
b.Write([]byte("enabled " + "\t" + strconv.FormatBool(c.Enabled) + "\n"))
b.Write([]byte("bind_address" + "\t" + c.BindAddress + "\n"))
b.Write([]byte("usetls " + "\t" + strconv.FormatBool(c.UseTls) + "\n"))
b.Write([]byte("---\n"))
fmt.Fprintln(w)
w.Flush()
return strings.TrimSpace(b.String())
}
func (c Config) String() string {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Config:", "white", "", "bold") + "\t" +
cmd.Colorfy("Gulpd", "green", "", "") + "\n"))
b.Write([]byte("Enabled" + "\t" + strconv.FormatBool(c.Enabled) + "\n"))
b.Write([]byte("Provider" + "\t" + c.Provider + "\n"))
b.Write([]byte("Cookbook" + "\t" + c.Cookbook + "\n"))
b.Write([]byte("ChefRepoGit" + "\t" + c.ChefRepoGit + "\n"))
b.Write([]byte("ChefRepoTarball" + "\t" + c.ChefRepoTarball + "\n"))
fmt.Fprintln(w)
w.Flush()
return b.String()
}
/**
*
* Creates an RPCClient with endpoint and returns it
*
**/
func NewRPCClient(endpoint string, username string, password string) (*Rpc, error) {
log.Debugf(cmd.Colorfy(" > [one-go] connecting", "blue", "", "bold"))
RPCclient, err := xmlrpc.NewClient(endpoint, nil)
if err != nil {
//TO-DO: trap and send connRefused error.
return nil, err
}
log.Debugf(cmd.Colorfy(" > [one-go] connected", "blue", "", "bold")+" %s", endpoint)
return &Rpc{
RPCClient: *RPCclient,
Key: username + ":" + password}, nil
}
func logs(w http.ResponseWriter, r *http.Request) error {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Errorf("Error in socket connection")
return err
}
messageType, p, err := conn.ReadMessage()
if err != nil {
return err
}
var entry provision.Box
_ = json.Unmarshal(p, &entry)
l, _ := provision.NewLogListener(&entry)
go func() {
if _, _, err := conn.NextReader(); err != nil {
conn.Close()
l.Close()
log.Debugf(cmd.Colorfy(" > [nsqd] unsub ", "blue", "", "bold") + fmt.Sprintf("Unsubscribing from the Queue"))
}
}()
for log := range l.B {
logData, _ := json.Marshal(log)
go conn.WriteMessage(messageType, logData)
}
return nil
}
func (c Config) String() string {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Config:", "white", "", "bold") + "\t" +
cmd.Colorfy("Eventsd", "cyan", "", "") + "\n"))
b.Write([]byte("enabled " + "\t" + strconv.FormatBool(c.Enabled) + "\n"))
b.Write([]byte(c.Mailgun.String()))
b.Write([]byte(c.Infobip.String()))
b.Write([]byte(c.Slack.String() + "\n"))
b.Write([]byte(c.BillMgr.String() + "\n"))
b.Write([]byte("---\n"))
fmt.Fprintln(w)
w.Flush()
return strings.TrimSpace(b.String())
}
func (c Config) String() string {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Config:", "white", "", "bold") + "\t" +
cmd.Colorfy("Meta", "cyan", "", "") + "\n"))
b.Write([]byte("Home " + "\t" + c.Home + "\n"))
b.Write([]byte("Dir " + "\t" + c.Dir + "\n"))
b.Write([]byte("Riak " + "\t" + strings.Join(c.Riak, ",") + "\n"))
b.Write([]byte("Api " + "\t" + c.Api + "\n"))
b.Write([]byte("NSQd " + "\t" + strings.Join(c.NSQd, ",") + "\n"))
b.Write([]byte("---\n"))
fmt.Fprintln(w)
w.Flush()
return strings.TrimSpace(b.String())
}
func (w *WrappedParms) String() string {
wt := new(tabwriter.Writer)
var b bytes.Buffer
wt.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Packages", "cyan", "", "") + "\n"))
for _, v := range w.Packages {
b.Write([]byte(v + "\n"))
}
b.Write([]byte(cmd.Colorfy("Options", "blue", "", "") + "\n"))
for k, v := range w.Options {
b.Write([]byte(k + "\t" + v + "\n"))
}
b.Write([]byte("---\n"))
fmt.Fprintln(wt)
wt.Flush()
return strings.TrimSpace(b.String())
}
func (c Bridges) String() string {
bs := make([]string, len(c))
for _, v := range c {
bs = append(bs, v.String(), "\n")
}
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Config:", "white", "", "bold") + "\t" +
cmd.Colorfy("bridges", "green", "", "") + "\n"))
b.Write([]byte(strings.Join(bs, "\n")))
fmt.Fprintln(w)
w.Flush()
return strings.TrimSpace(b.String())
}
// Connect to a certain keyspace directly. Same as using Connect().KeySpace(keySpaceName)
func connectToKeySpace(keySpace string, nodeIps []string, username, password string) (gocassa.KeySpace, error) {
c, err := gocassa.Connect(nodeIps, username, password)
if err != nil {
return nil, err
}
log.Debugf(cmd.Colorfy(" > [scylla] keyspace "+keySpace, "blue", "", "bold"))
return c.KeySpace(keySpace), nil
}
func (c Config) String() string {
w := new(tabwriter.Writer)
var b bytes.Buffer
w.Init(&b, 0, 8, 0, '\t', 0)
b.Write([]byte(cmd.Colorfy("Config:", "white", "", "bold") + "\t" +
cmd.Colorfy("docker", "cyan", "", "") + "\n"))
b.Write([]byte("enabled " + "\t" + strconv.FormatBool(c.Enabled) + "\n"))
b.Write([]byte(docker.DOCKER_REGISTRY + "\t" + c.Registry + "\n"))
b.Write([]byte(docker.DOCKER_SWARM + " \t" + c.Swarm + "\n"))
b.Write([]byte(docker.DOCKER_MEMSIZE + " \t" + strconv.Itoa(c.MemSize) + "\n"))
b.Write([]byte(docker.DOCKER_SWAPSIZE + " \t" + strconv.Itoa(c.SwapSize) + "\n"))
b.Write([]byte(docker.DOCKER_CPUPERIOD + " \t" + c.CPUPeriod.String() + "\n"))
b.Write([]byte(docker.DOCKER_CPUQUOTA + " \t" + c.CPUQuota.String() + "\n"))
b.Write([]byte("---\n"))
fmt.Fprintln(w)
w.Flush()
return strings.TrimSpace(b.String())
}
func (p *ReqOperator) Accept(r *MegdProcessor) error {
c, err := p.Get(p.Id)
if err != nil {
return err
}
md := *r
log.Debugf(cmd.Colorfy(md.String(), "cyan", "", "bold"))
return md.Process(c)
}
func NewClient(config map[string]string) (*Rpc, error) {
log.Debugf(cmd.Colorfy(" > [one-go] connecting", "blue", "", "bold"))
if !satisfied(config) {
return nil, ErrArgsNotSatisfied
}
client, err := xmlrpc.NewClient(config[ENDPOINT], nil)
if err != nil {
return nil, err
}
//log.Debugf(cmd.Colorfy(" > [one-go] connection response", "blue", "", "bold")+"%#v",client)
log.Debugf(cmd.Colorfy(" > [one-go] connected", "blue", "", "bold")+" %s", config[ENDPOINT])
return &Rpc{
Client: *client,
Key: config[USERID] + ":" + config[PASSWORD]}, nil
}
//Show a spinner until our services start.
func (cmd *Command) funSpin(vers string, logo string) {
fmt.Printf("%s %s", vers, logo)
s := spin.New()
for i := 0; i < 10; i++ {
fmt.Printf("\r%s", fmt.Sprintf("%s %s", pp.Colorfy("starting", "green", "", "bold"), s.Next()))
time.Sleep(3 * time.Millisecond)
}
fmt.Printf("\n")
}
func (p *Pipeline) rollback(index int, params []interface{}) {
bwCtx := BWContext{Params: params}
for i := index; i >= 0; i-- {
log.Debugf(cmd.Colorfy(fmt.Sprintf(" => step %d: %s action", i, p.actions[i].Name), "red", "", "bold"))
if p.actions[i].Backward != nil {
bwCtx.FWResult = p.actions[i].result
p.actions[i].Backward(bwCtx)
}
}
}
func (c *AttachOneHost) Run(context *cmd.Context) error {
handler.FunSpin(cmd.Colorfy(handler.Logo, "green", "", "bold"), "", "installing")
w := handler.NewWrap(c)
w.IfNoneAddPackages(INSTALL_PACKAGES)
if h, err := handler.NewHandler(w); err != nil {
return err
} else if err := h.Run(); err != nil {
return err
}
return nil
}
func (c *Cephdatastore) Run(context *cmd.Context) error {
handler.FunSpin(cmd.Colorfy(handler.Logo, "green", "", "bold"), "", "install")
w := handler.NewWrap(c)
w.IfNoneAddPackages(CEPH_DATATSTORE)
if h, err := handler.NewHandler(w); err != nil {
return err
} else if err := h.Run(); err != nil {
return err
}
return nil
}