// 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
}
// deploy
func deploy(ccmd *cobra.Command, args []string) {
// PreRun: boot
fmt.Printf(stylish.Bullet("Deploying codebase..."))
// stream deploy 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)
}()
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.Error("[util/vagrant/init] engineutil.RemountLocal() failed", err.Error())
}
// run a deploy
if err := Server.Deploy(v.Encode()); err != nil {
Config.Fatal("[commands/deploy] server.Deploy() failed - ", err.Error())
}
// wait for a status update (blocking)
err := <-errch
//
if err != nil {
fmt.Printf(err.Error())
return
}
// PostRun: halt
}
// build
func build(ccmd *cobra.Command, args []string) {
// PreRun: boot
fmt.Printf(stylish.Bullet("Building codebase..."))
// stream build output
go Mist.Stream([]string{"log", "deploy"}, Mist.PrintLogStream)
// listen for status updates
errch := make(chan error)
go func() {
errch <- Mist.Listen([]string{"job", "build"}, Mist.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.Error("[util/vagrant/init] engineutil.RemountLocal() failed", err.Error())
}
// run a build
if err := Server.Build(""); err != nil {
Config.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
}
// run
func run(ccmd *cobra.Command, args []string) {
// PreRun: boot
fmt.Printf(stylish.Bullet("Deploying codebase..."))
// stream deploy 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)
}()
// 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.Error("[util/vagrant/init] engineutil.RemountLocal() failed", err.Error())
}
// run a deploy
if err := Server.Deploy("run=true"); err != nil {
Config.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 Mist.Stream([]string{"log", "app"}, Mist.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
}