apex/up

package up

import (
    "io"
    "os"
    "os/exec"
    "time"

    "github.com/apex/log"
    "github.com/pkg/errors"

    "github.com/apex/up/config"
    "github.com/apex/up/internal/util"
    "github.com/apex/up/platform/event"
)

// Config for a project.
type Config = config.Config

// ReadConfig reads the configuration from `path`.
var ReadConfig = config.ReadConfig

// ParseConfigString returns config from JSON string.
var ParseConfigString = config.ParseConfigString

// MustParseConfigString returns config from JSON string.
var MustParseConfigString = config.MustParseConfigString

// Project manager.
type Project struct {
    Platform
    config *Config
    events event.Events
}

// New project.
func New(c *Config, events event.Events) *Project {
    return &Project{
        config: c,
        events: events,
    }
}

// WithPlatform to `platform`.
func (p *Project) WithPlatform(platform Platform) *Project {
    p.Platform = platform
    return p
}

// RunHook runs a hook by name.
func (p *Project) RunHook(name string) error {
    hook := p.config.Hooks.Get(name)

    if hook.IsEmpty() {
        log.Debugf("hook %s is not defined", name)
        return nil
    }

    defer p.events.Time("hook", event.Fields{
        "name": name,
        "hook": hook,
    })()

    for _, command := range hook {
        log.Debugf("hook %q command %q", name, command)

        cmd := exec.Command("sh", "-c", command)
        cmd.Env = os.Environ()
        cmd.Env = append(cmd.Env, util.Env(p.config.Environment)...)
        cmd.Env = append(cmd.Env, "PATH=node_modules/.bin:"+os.Getenv("PATH"))

        b, err := cmd.CombinedOutput()
        if err != nil {
            return errors.Errorf("%q: %s", command, b)
        }
    }

    return nil
}

// RunHooks runs hooks by name.
func (p *Project) RunHooks(names ...string) error {
    for _, n := range names {
        if err := p.RunHook(n); err != nil {
            return errors.Wrapf(err, "%q hook", n)
        }
    }
    return nil
}

// Build the project.
func (p *Project) Build(hooks bool) error {
    defer p.events.Time("platform.build", nil)()

    if hooks {
        if err := p.RunHooks("prebuild", "build"); err != nil {
            return err
        }
    }

    if err := p.Platform.Build(); err != nil {
        return errors.Wrap(err, "building")
    }

    if hooks {
        return p.RunHooks("postbuild")
    }

    return nil
}

// Deploy the project.
func (p *Project) Deploy(d Deploy) error {
    defer p.events.Time("deploy", event.Fields{
        "commit": d.Commit,
        "stage":  d.Stage,
    })()

    if err := p.Build(d.Build); err != nil {
        return errors.Wrap(err, "building")
    }

    if err := p.deploy(d); err != nil {
        return errors.Wrap(err, "deploying")
    }

    if d.Build {
        if err := p.RunHook("clean"); err != nil {
            return errors.Wrap(err, "clean hook")
        }
    }

    return nil
}

// deploy stage.
func (p *Project) deploy(d Deploy) error {
    if err := p.RunHooks("predeploy", "deploy"); err != nil {
        return err
    }

    if err := p.Platform.Deploy(d); err != nil {
        return err
    }

    return p.RunHooks("postdeploy")
}

// Zip returns the zip if supported by the platform.
func (p *Project) Zip() (io.Reader, error) {
    z, ok := p.Platform.(Zipper)
    if !ok {
        return nil, errors.Errorf("platform does not support zips")
    }

    return z.Zip(), nil
}

// Init initializes the runtime such as remote environment variables.
func (p *Project) Init(stage string) error {
    r, ok := p.Platform.(Runtime)
    if !ok {
        return nil
    }

    return r.Init(stage)
}

// CreateStack implementation.
func (p *Project) CreateStack(region, version string) error {
    defer p.events.Time("stack.create", event.Fields{
        "region":  region,
        "version": version,
    })()

    return p.Platform.CreateStack(region, version)
}

// DeleteStack implementation.
func (p *Project) DeleteStack(region string, wait bool) error {
    defer p.events.Time("stack.delete", event.Fields{
        "region": region,
    })()

    return p.Platform.DeleteStack(region, wait)
}

// ShowStack implementation.
func (p *Project) ShowStack(region string) error {
    defer p.events.Time("stack.show", event.Fields{
        "region": region,
    })()

    return p.Platform.ShowStack(region)
}

// ShowMetrics implementation.
func (p *Project) ShowMetrics(region, stage string, start time.Time) error {
    defer p.events.Time("metrics", event.Fields{
        "region": region,
        "stage":  stage,
        "start":  start,
    })()

    return p.Platform.ShowMetrics(region, stage, start)
}

// PlanStack implementation.
func (p *Project) PlanStack(region string) error {
    defer p.events.Time("stack.plan", event.Fields{
        "region": region,
    })()

    return p.Platform.PlanStack(region)
}

// ApplyStack implementation.
func (p *Project) ApplyStack(region string) error {
    defer p.events.Time("stack.apply", event.Fields{
        "region": region,
    })()

    return p.Platform.ApplyStack(region)
}

// Prune implementation.
func (p *Project) Prune(region, stage string, versions int) error {
    pruner, ok := p.Platform.(Pruner)
    if !ok {
        return errors.Errorf("platform does not support pruning")
    }

    return pruner.Prune(region, stage, versions)
}