// bootstrap
func bootstrap(ccmd *cobra.Command, args []string) {
// PreRun: boot
fmt.Printf(stylish.Bullet("Bootstrapping codebase..."))
// stream bootstrap output
go Mist.Stream([]string{"log", "deploy"}, Mist.PrintLogStream)
// listen for status updates
errch := make(chan error)
go func() {
errch <- Mist.Listen([]string{"job", "bootstrap"}, Mist.BootstrapUpdates)
}()
// run a bootstrap
if err := server.Bootstrap(""); err != nil {
server.Fatal("[commands/bootstrap] server.Bootstrap() failed", err.Error())
}
// wait for a status update (blocking)
err := <-errch
//
if err != nil {
fmt.Printf(err.Error())
return
}
// PostRun: halt
}
// log
func log(ccmd *cobra.Command, args []string) {
// if stream is true, we connect to the live logs...
if stream {
fmt.Printf(stylish.Bullet("Opening log stream"))
// stream logs (blocking)
Mist.Stream([]string{"log", "app"}, Mist.ProcessLogStream)
// ...otherwise load historical logs
} else {
//
v := url.Values{}
v.Add("level", level)
v.Add("limit", fmt.Sprintf("%v", count))
v.Add("offset", fmt.Sprintf("%v", offset))
// show Mist history
if err := server.Logs(v.Encode()); err != nil {
server.Fatal("[commands/log] server.Logs() failed", err.Error())
}
}
}
// updateImages
func updateImages(ccmd *cobra.Command, args []string) {
// PreRun: boot
// stream update output
go Mist.Stream([]string{"log", "deploy"}, Mist.PrintLogStream)
// listen for status updates
errch := make(chan error)
go func() {
errch <- Mist.Listen([]string{"job", "imageupdate"}, Mist.ImageUpdates)
}()
fmt.Printf(stylish.Bullet("Updating nanobox docker images (this may take a while)..."))
// run an image update
if err := server.Update(""); err != nil {
server.Fatal("[commands/update-images] server.Update() failed", err.Error())
}
// wait for a status update (blocking)
err := <-errch
//
if err != nil {
fmt.Printf(err.Error())
return
}
// PostRun: halt
}
// dev
func dev(ccmd *cobra.Command, args []string) {
// PreRun: boot
// don't rebuild
if !nobuild {
// if the vm has no been created or deployed, the rebuild flag, or the VM has
// recently been reloaded do a deploy
if Vagrant.Status() == "not created" || !config.VMfile.HasDeployed() || rebuild || config.VMfile.HasReloaded() {
fmt.Printf(stylish.Bullet("Deploying codebase..."))
// remount the engine file at ~/.nanobox/apps/<app>/<engine> so any new scripts
// will be used during the deploy
if err := engineutil.RemountLocal(); err != nil {
config.Debug("No engine mounted (not found locally).")
}
// run a deploy
if err := server.Deploy(""); err != nil {
server.Fatal("[commands/dev] server.Deploy() failed", err.Error())
}
// stream log output
go Mist.Stream([]string{"log", "deploy"}, Mist.PrintLogStream)
// listen for status updates
errch := make(chan error)
go func() {
errch <- Mist.Listen([]string{"job", "deploy"}, Mist.DeployUpdates)
}()
// wait for a status update (blocking)
err := <-errch
//
if err != nil {
fmt.Printf(err.Error())
return
}
}
}
//
if err := server.Exec("develop", ""); err != nil {
server.Error("[commands/dev] Server.Exec failed", err.Error())
}
// PostRun: halt
}
// deploy
func deploy(ccmd *cobra.Command, args []string) {
// PreRun: boot
fmt.Printf(stylish.Bullet("Deploying codebase..."))
// stream deploy output
go mistutil.Stream([]string{"log", "deploy"}, mistutil.PrintLogStream)
// listen for status updates
errch := make(chan error)
go func() {
errch <- mistutil.Listen([]string{"job", "deploy"}, mistutil.DeployUpdates)
}()
v := url.Values{}
v.Add("reset", strconv.FormatBool(config.Force))
v.Add("run", strconv.FormatBool(install))
// remount the engine file at ~/.nanobox/apps/<app>/<engine> so any new scripts
// will be used during the deploy
if err := engineutil.RemountLocal(); err != nil {
config.Debug("No engine mounted (not found locally).")
}
// run a deploy
if err := server.Deploy(v.Encode()); err != nil {
server.Fatal("[commands/deploy] server.Deploy() failed", err.Error())
}
// wait for a status update (blocking)
err := <-errch
//
if err != nil {
fmt.Printf(err.Error())
return
}
// reset "reloaded" to false after a successful deploy so as NOT to deploy on
// subsequent runnings of "nanobox dev"
config.VMfile.ReloadedIs(false)
// PostRun: halt
}
// build
func build(ccmd *cobra.Command, args []string) {
// PreRun: boot
fmt.Printf(stylish.Bullet("Building codebase..."))
// stream build output
go mistutil.Stream([]string{"log", "deploy"}, mistutil.PrintLogStream)
// listen for status updates
errch := make(chan error)
go func() {
errch <- mistutil.Listen([]string{"job", "build"}, mistutil.BuildUpdates)
}()
// remount the engine file at ~/.nanobox/apps/<app>/<engine> so any new scripts
// are used during the build
if err := engineutil.RemountLocal(); err != nil {
config.Debug("No engine mounted (not found locally).")
}
// run a build
if err := server.Build(""); err != nil {
server.Fatal("[commands/build] server.Build() failed", err.Error())
}
// wait for a status update (blocking)
err := <-errch
//
if err != nil {
fmt.Printf(err.Error())
return
}
// PostRun: halt
}
// info runs 'vagrant status'
func info(ccmd *cobra.Command, args []string) {
// PreRun: runnable
// determine status
status := Vagrant.Status()
fmt.Printf(`
Local Domain : %s
App Name : %s
Nanobox state : %s
Nanobox Files : %s
`, config.Nanofile.Domain, config.Nanofile.Name, status, config.AppDir)
if status != "running" {
fmt.Println("NOTE: To view 'services' information start nanobox with 'nanobox dev' or 'nanobox run'")
return
}
//
var services []server.Service
if _, err := server.Get("/services", &services); err != nil {
server.Fatal("[commands/info] failed", err.Error())
}
//
if len(services) >= 1 {
fmt.Printf("////////// SERVICES //////////\n")
//
for _, service := range services {
fmt.Printf("\n%s :\n", service.UID)
if service.Name != "" {
fmt.Printf(" name : %s\n", service.Name)
}
fmt.Printf(" host : %s\n", config.Nanofile.Domain)
fmt.Printf(" ports : %v\n", service.Ports)
//
if service.Username != "" {
fmt.Printf(" username : %s\n", service.Username)
}
//
if service.Password != "" {
fmt.Printf(" password : %s\n", service.Password)
}
// show any environment variables
if len(service.EnvVars) >= 1 {
fmt.Printf(" evars :\n")
for k, v := range service.EnvVars {
fmt.Printf(" %s : %s\n", k, v)
}
}
}
}
}
// run
func run(ccmd *cobra.Command, args []string) {
// PreRun: boot
fmt.Printf(stylish.Bullet("Deploying codebase..."))
// stream deploy output
go mistutil.Stream([]string{"log", "deploy"}, mistutil.PrintLogStream)
// listen for status updates
errch := make(chan error)
go func() {
errch <- mistutil.Listen([]string{"job", "deploy"}, mistutil.DeployUpdates)
}()
// remount the engine file at ~/.nanobox/apps/<app>/<engine> so any new scripts
// will be used during the deploy
if err := engineutil.RemountLocal(); err != nil {
config.Debug("No engine mounted (not found locally).")
}
// run a deploy
if err := server.Deploy("run=true"); err != nil {
server.Fatal("[commands/run] server.Deploy() failed", err.Error())
}
// wait for a status update (blocking)
err := <-errch
//
if err != nil {
fmt.Printf(err.Error())
return
}
fmt.Printf(`
--------------------------------------------------------------------------------
[√] APP SUCCESSFULLY BUILT /// DEV URL : %v
--------------------------------------------------------------------------------
`, config.Nanofile.Domain)
// if in background mode just exist w/o streaming logs or watching files
if config.VMfile.IsBackground() {
fmt.Println(`
To stream logs and watch files while in 'background mode' you can use
'nanobox log' and 'nanobox watch'
`)
return
}
// if not in background mode begin streaming logs and watching files
fmt.Printf(`
++> STREAMING LOGS (ctrl-c to exit) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
`)
// stream app output
go mistutil.Stream([]string{"log", "app"}, mistutil.ProcessLogStream)
// begin watching for file changes (blocking)
if err := notify.Watch(config.CWDir, server.NotifyRebuild); err != nil {
fmt.Printf(err.Error())
}
// PostRun: halt
}
// dev
func dev(ccmd *cobra.Command, args []string) {
// PreRun: boot
// check to see if the devconfig option is one of our predetermined values. If
// not indicate as much and return
switch devconfig {
case "mount", "copy", "none":
break
default:
fmt.Printf("--dev-config option '%s' is not accepted. Please choose either 'mount', 'copy', or 'none'\n", devconfig)
os.Exit(1)
}
// stream log output; this is done here because there might be output from hooks
// that needs to be streamed to the client. This will also capture any output
// that would come from a deploy (if one is run).
mist, err := Mist.Connect([]string{"log", "deploy"}, Mist.PrintLogStream)
if err != nil {
config.Fatal("[commands/dev] mist.Connect() failed", err.Error())
}
// don't rebuild
if !nobuild {
// if the vm has no been created or deployed, the rebuild flag, or the VM has
// recently been reloaded do a deploy
if Vagrant.Status() == "not created" || !config.VMfile.HasDeployed() || rebuild || config.VMfile.HasReloaded() {
fmt.Printf(stylish.Bullet("Deploying codebase..."))
// remount the engine file at ~/.nanobox/apps/<app>/<engine> so any new scripts
// will be used during the deploy
if err := engineutil.RemountLocal(); err != nil {
config.Debug("No engine mounted (not found locally).")
}
// run a deploy
if err := server.Deploy(""); err != nil {
server.Fatal("[commands/dev] server.Deploy() failed", err.Error())
}
// listen for status updates
errch := make(chan error)
go func() {
errch <- Mist.Listen([]string{"job", "deploy"}, Mist.DeployUpdates)
}()
// wait for a status update (blocking)
err := <-errch
//
if err != nil {
fmt.Printf(err.Error())
return
}
}
}
//
v := url.Values{}
v.Add("dev_config", devconfig)
//
if err := server.Develop(v.Encode(), mist); err != nil {
server.Error("[commands/dev] Server.Develop failed", err.Error())
}
// PostRun: halt
}