// Exec
func Exec(params string) error {
// connect to the server; this will wait until a single read is returned from
// the server (blocking)
conn, data, err := connect(fmt.Sprintf("POST /exec?pid=%d&%v HTTP/1.1\r\n\r\n", os.Getpid(), params))
if err != nil {
return err
}
defer conn.Close()
// begin watching for changes to the project
go func() {
if err := notifyutil.Watch(config.CWDir, NotifyServer); err != nil {
fmt.Printf(err.Error())
}
}()
// get current term info
stdIn, stdOut, _ := term.StdStreams()
//
terminal.Connect(stdIn, stdOut)
// print the first read data from above
os.Stderr.WriteString(string(data))
//
return pipeToConnection(conn, stdIn, stdOut)
}
// Develop
func Develop(params string, mist mistClient.Client) error {
// connect to the server; this will wait until a single read is returned from
// the server (blocking)
conn, data, err := connect(fmt.Sprintf("POST /develop?pid=%d&%v HTTP/1.1\r\n\r\n", os.Getpid(), params))
if err != nil {
return err
}
defer conn.Close()
// disconnect mist
mist.Close()
// begin watching for changes to the project
go func() {
if err := notifyutil.Watch(config.CWDir, NotifyServer); err != nil {
fmt.Printf(err.Error())
}
}()
//
os.Stderr.WriteString(fmt.Sprintf(`+> Opening a nanobox console:
**
********
***************
*********************
*****************
:: ********* ::
:: *** ::
++ ::: ::: ++
++ ::: ++
++ ++
+
_ _ ____ _ _ ____ ___ ____ _ _
|\ | |__| |\ | | | |__) | | \/
| \| | | | \| |__| |__) |__| _/\_
--------------------------------------------------------------------------------
+ You are in a virtual machine (vm)
+ Your local source code has been mounted into the vm, and changes in either
the vm or local will be mirrored.
+ If you run a server, access it at >> %s
--------------------------------------------------------------------------------
`, config.Nanofile.Domain))
// get current term info
stdIn, stdOut, _ := term.StdStreams()
//
terminal.Connect(stdIn, stdOut)
// print the first read data from above
os.Stderr.WriteString(string(data))
//
return pipeToConnection(conn, stdIn, stdOut)
}
// watch
func watch(ccmd *cobra.Command, args []string) {
fmt.Printf(stylish.Bullet("Watching app files for changes"))
// begin watching for file changes at cwd
if err := notify.Watch(config.CWDir, server.NotifyRebuild); err != nil {
fmt.Printf(err.Error())
}
}
// Console
func Console(params string) error {
// connect to the server; this will wait until a single read is returned from
// the server (blocking)
conn, data, err := connect(fmt.Sprintf("POST /exec?pid=%d&%v HTTP/1.1\r\n\r\n", os.Getpid(), params))
if err != nil {
return err
}
defer conn.Close()
// begin watching for changes to the project
go func() {
if err := notifyutil.Watch(config.CWDir, NotifyServer); err != nil {
fmt.Printf(err.Error())
}
}()
//
os.Stderr.WriteString(`+> Opening a nanobox console:
**
********
***************
*********************
*****************
:: ********* ::
:: *** ::
++ ::: ::: ++
++ ::: ++
++ ++
+
_ _ ____ _ _ ____ ___ ____ _ _
|\ | |__| |\ | | | |__) | | \/
| \| | | | \| |__| |__) |__| _/\_
`)
// get current term info
stdIn, stdOut, _ := term.StdStreams()
// connect a raw terminal; if no error is returned defer resetting the terminal
state, err := terminal.Connect(stdIn, stdOut)
if err == nil {
defer terminal.Disconnect(stdIn, state)
}
// print the first read data from above
os.Stderr.Write(data)
//
return pipeToConnection(conn, stdIn, stdOut)
}
func execInternal(where, params string, in io.Reader, out io.Writer) error {
// if we can't connect to the server, lets bail out early
conn, err := net.Dial("tcp4", config.ServerURI)
if err != nil {
return err
}
defer conn.Close()
// get current term info
stdInFD, isTerminal := term.GetFdInfo(in)
stdOutFD, _ := term.GetFdInfo(out)
//
terminal.PrintNanoboxHeader(where)
// begin watching for changes to the project
go func() {
if err := notifyutil.Watch(config.CWDir, NotifyServer); err != nil {
fmt.Printf(err.Error())
}
}()
// if we are using a term, lets upgrade it to RawMode
if isTerminal {
// handle all incoming os signals and act accordingly; default behavior is to
// forward all signals to nanobox server
go monitorTerminal(stdOutFD)
oldState, err := term.SetRawTerminal(stdInFD)
// we only use raw mode if it is available.
if err == nil {
defer term.RestoreTerminal(stdInFD, oldState)
}
}
// make a http request
switch where {
case "develop":
if _, err := fmt.Fprintf(conn, "POST /develop?pid=%d&%v HTTP/1.1\r\n\r\n", os.Getpid(), params); err != nil {
return err
}
default:
if _, err := fmt.Fprintf(conn, "POST /exec?pid=%d&%v HTTP/1.1\r\n\r\n", os.Getpid(), params); err != nil {
return err
}
}
return pipeToConnection(conn, in, out)
}
// 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
}
