// 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 }
// 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 }
// Init func Init() { // create Vagrantfile vagrantfile, err := os.Create(config.AppDir + "/Vagrantfile") if err != nil { config.Fatal("[util/vagrant/init] ioutil.WriteFile() failed", err.Error()) } defer vagrantfile.Close() // // create synced folders // mount code directory (mounted as nfs by default) synced_folders := fmt.Sprintf(`nanobox.vm.synced_folder "%s", "/vagrant/code/%s"`, config.CWDir, config.Nanofile.Name) // mount code directory as NFS unless configured otherwise; if not mounted in // this way Vagrant will just decide what it thinks is best if config.Nanofile.MountNFS { synced_folders += `, type: "nfs", mount_options: ["nfsvers=3", "proto=tcp"]` } // "mount" the engine file locally at ~/.nanobox/apps/<app>/<engine> name, path, err := engineutil.MountLocal() if err != nil { config.Debug("No engine mounted (not found locally).") } // "mount" the engine into the VM (if there is one) if name != "" && path != "" { synced_folders += fmt.Sprintf(` nanobox.vm.synced_folder "%s", "/vagrant/engines/%s"`, path, name) // mount engine directory as NFS unless configured otherwise; if not mounted in // this way Vagrant will just decide what it thinks is best if config.Nanofile.MountNFS { synced_folders += `, type: "nfs", mount_options: ["nfsvers=3", "proto=tcp"]` } } // // nanofile config // create nanobox private network and unique forward port network := fmt.Sprintf("nanobox.vm.network \"private_network\", ip: \"%s\"", config.Nanofile.IP) sshport := fmt.Sprintf("nanobox.vm.network :forwarded_port, guest: 22, host: %v, id: 'ssh'", util.StringToPort(config.Nanofile.Name)) // provider := fmt.Sprintf(`# VirtualBox nanobox.vm.provider "virtualbox" do |p| p.name = "%v" p.customize ["modifyvm", :id, "--natdnshostresolver1", "%+v"] p.customize ["modifyvm", :id, "--cpuexecutioncap", "%v"] p.cpus = %v p.memory = %v end`, config.Nanofile.Name, config.Nanofile.HostDNS, config.Nanofile.CPUCap, config.Nanofile.CPUs, config.Nanofile.RAM) // // insert a provision script that will indicate to nanobox-server to boot into // 'devmode' var devmode string if config.Devmode { fmt.Printf(stylish.Bullet("Configuring vm to run in 'devmode'")) devmode = `# added because --dev was detected; boots the server into 'devmode' config.vm.provision "shell", inline: <<-DEVMODE echo "Starting VM in dev mode..." mkdir -p /mnt/sda/var/nanobox touch /mnt/sda/var/nanobox/DEV DEVMODE` } // // write to Vagrantfile vagrantfile.Write([]byte(fmt.Sprintf(` ################################################################################ ## ## ## *** ## ## ********* ## ## ******************* ## ## *************************** ## ## ******************* ## ## ... ********* ... ## ## ... *** ... ## ## +++ ... ... +++ ## ## +++ ... +++ ## ## \\\ +++ +++ /// ## ## \\\ +++ /// ## ## \\ // ## ## \// ## ## ## ## _ _ ____ _ _ ____ ___ ____ _ _ ## ## |\ | |__| |\ | | | |__) | | \/ ## ## | \| | | | \| |__| |__) |__| _/\_ ## ## ## ## This file was generated by nanobox. Any modifications to it may cause your ## ## nanobox VM to fail! To regenerate this file, delete it and run ## ## 'nanobox init' ## ## ## ################################################################################ # -*- mode: ruby -*- # vi: set ft=ruby : # Vagrant.configure(2) do |config| # add the boot2docker user credentials to allow nanobox to freely ssh into the vm # w/o requiring a password config.ssh.shell = "bash" config.ssh.username = "******" config.ssh.password = "******" config.vm.define :'%s' do |nanobox| ## Set the hostname of the vm to the app domain nanobox.vm.provision "shell", inline: <<-SCRIPT sudo hostname %s SCRIPT ## Wait for nanobox-server to be ready before vagrant exits nanobox.vm.provision "shell", inline: <<-WAIT echo "Waiting for nanobox server..." while ! nc -z 127.0.0.1 1757; do sleep 1; done; WAIT ## box nanobox.vm.box = "nanobox/boot2docker" ## network # add custom private network and ip and custom ssh port forward %s %s ## shared folders # disable default /vagrant share (overridden below) nanobox.vm.synced_folder ".", "/vagrant", disabled: true # add nanobox shared folders nanobox.vm.synced_folder "~/.ssh", "/mnt/ssh" %s ## provider configs %s ## wait for the dhcp service to come online nanobox.vm.provision "shell", inline: <<-WAIT attempts=0 while [[ ! -f /var/run/udhcpc.eth1.pid && $attempts -lt 30 ]]; do let attempts++ sleep 1 done WAIT # kill the eth1 dhcp server so that it doesn't override the assigned ip when # the lease is up nanobox.vm.provision "shell", inline: <<-KILL if [ -f /var/run/udhcpc.eth1.pid ]; then echo "Killing eth1 dhcp..." kill -9 $(cat /var/run/udhcpc.eth1.pid) fi KILL %s end end`, config.Nanofile.Name, config.Nanofile.Domain, network, sshport, synced_folders, provider, devmode))) }
// 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 }
// Init func Init() { // create Vagrantfile vagrantfile, err := os.Create(config.AppDir + "/Vagrantfile") if err != nil { config.Fatal("[util/vagrant/init] ioutil.WriteFile() failed", err.Error()) } defer vagrantfile.Close() // // create synced folders var sshMount, engineMount, codeMount string // // default path to ssh dir (assumes Unix) sshPath := filepath.Join(config.Home, ".ssh") // default path to ssh (windows) if config.OS == "windows" { sshPath = os.Getenv("HOMEDRIVE") + os.Getenv("HOMEPATH") + `\.ssh` } // if an sshPath is provided in the nanofile override the default if config.Nanofile.SshPath != "" { sshPath = config.Nanofile.SshPath } // ensure the ssh location is a valid place; if the ssh dir is found, mount it sshDir, err := os.Stat(sshPath) if err == nil && sshDir.IsDir() { sshMount = fmt.Sprintf(`nanobox.vm.synced_folder '%s', "/mnt/ssh"`, sshPath) // if not found print this friendly warning } else { fmt.Printf(` WARNING: Nanobox was unable to mount your .ssh folder into the VM because it was unable to detect the location of an .ssh directory at: %s While nanobox is still usable for local development, this may result in failures to fetch dependancies that require the use of those credentials`, sshPath) } // // mount code directory (mounted as nfs by default) codeMount = fmt.Sprintf(`nanobox.vm.synced_folder '%s', '/vagrant/code/%s'`, config.CWDir, config.Nanofile.Name) // mount code directory as NFS unless configured otherwise; if not mounted in // this way Vagrant will just decide what it thinks is best if config.Nanofile.MountNFS { codeMount += `, type: "nfs", mount_options: ["nfsvers=3", "proto=tcp"]` } // // "mount" the engine file locally at ~/.nanobox/apps/<app>/<engine>; this is // done when a local engine is detected so that the engine can be developed // and changed are reflected in the VM name, path, err := engineutil.MountLocal() if err != nil { config.Debug("No engine mounted (not found locally).") } // "mount" the engine into the VM (if there is one) if name != "" && path != "" { engineMount = fmt.Sprintf(`nanobox.vm.synced_folder '%s', "/vagrant/engines/%s"`, path, name) // mount engine directory as NFS unless configured otherwise; if not mounted // in this way Vagrant will just decide what it thinks is best if config.Nanofile.MountNFS { engineMount += `, type: "nfs", mount_options: ["nfsvers=3", "proto=tcp"]` } } // // nanofile config // create nanobox private network and unique forward port network := fmt.Sprintf("nanobox.vm.network \"private_network\", ip: \"%s\"", config.Nanofile.IP) sshport := fmt.Sprintf("nanobox.vm.network :forwarded_port, guest: 22, host: %v, id: 'ssh'", appNameToPort(config.Nanofile.Name)) // provider := fmt.Sprintf(`# VirtualBox nanobox.vm.provider "virtualbox" do |p| p.name = "%v" p.customize ["modifyvm", :id, "--natdnshostresolver1", "%+v"] p.customize ["modifyvm", :id, "--cpuexecutioncap", "%v"] p.cpus = %v p.memory = %v end`, config.Nanofile.Name, config.Nanofile.HostDNS, config.Nanofile.CPUCap, config.Nanofile.CPUs, config.Nanofile.RAM) // // insert a provision script that will indicate to nanobox-server to boot into // 'devmode' var devmode string if config.Devmode { fmt.Printf(stylish.Bullet("Configuring vm to run in 'devmode'")) devmode = `# added because --dev was detected; boots the server into 'devmode' nanobox.vm.provision "shell", inline: <<-DEVMODE echo "Starting VM in dev mode..." mkdir -p /mnt/sda/var/nanobox touch /mnt/sda/var/nanobox/DEV DEVMODE` } // // insert a provision script that will allow utilization of system proxy vars var proxy string if config.Nanofile.UseProxy { fmt.Printf(stylish.Bullet("Configuring vm to use 'proxy' vars")) proxy = `# added because env 'use_proxy' was set; configures vm to use proxy nanobox.vm.provision "shell" do |s| s.inline = <<-PROXY echo "Configuring VM for proxy..." cat > /var/lib/boot2docker/profile <<-EOF export http_proxy="$1" export https_proxy="$2" export https_user="******" export https_pass="******" EOF sudo /usr/local/etc/init.d/docker restart sudo /etc/init.d/services/nanoboxd stop && sudo /etc/init.d/services/nanoboxd start PROXY s.args = "'#{ENV['http_proxy']}' '#{ENV['https_proxy']}' '#{ENV['https_user']}' '#{ENV['https_pass']}'" end` } // // write to Vagrantfile vagrantfile.Write([]byte(fmt.Sprintf(` ################################################################################ ## ## ## *** ## ## ********* ## ## ******************* ## ## *************************** ## ## ******************* ## ## ... ********* ... ## ## ... *** ... ## ## +++ ... ... +++ ## ## +++ ... +++ ## ## \\\ +++ +++ /// ## ## \\\ +++ /// ## ## \\ // ## ## \// ## ## ## ## _ _ ____ _ _ ____ ___ ____ _ _ ## ## |\ | |__| |\ | | | |__) | | \/ ## ## | \| | | | \| |__| |__) |__| _/\_ ## ## ## ## This file was generated by nanobox. Any modifications to it may cause your ## ## nanobox VM to fail! To regenerate this file, delete it and run ## ## 'nanobox init' ## ## ## ################################################################################ # -*- mode: ruby -*- # vi: set ft=ruby : # Vagrant.configure(2) do |config| # add the boot2docker user credentials to allow nanobox to freely ssh into the vm # w/o requiring a password config.ssh.shell = "bash" config.ssh.username = "******" config.ssh.password = "******" config.vm.define :'%s' do |nanobox| ## Set the hostname of the vm to the app domain nanobox.vm.provision "shell", inline: <<-SCRIPT sudo hostname %s SCRIPT ## Wait for nanobox-server to be ready before vagrant exits nanobox.vm.provision "shell", inline: <<-WAIT echo "Waiting for nanobox server..." while ! nc -z 127.0.0.1 1757; do sleep 1; done; WAIT ## box nanobox.vm.box = "nanobox/boot2docker" ## network # add custom private network and ip and custom ssh port forward `+network+` `+sshport+` ## shared folders # disable default /vagrant share (overridden below) nanobox.vm.synced_folder ".", "/vagrant", disabled: true # add nanobox shared folders `+sshMount+` `+codeMount+` `+engineMount+` ## provider configs `+provider+` ## wait for the dhcp service to come online nanobox.vm.provision "shell", inline: <<-WAIT attempts=0 while [[ ! -f /var/run/udhcpc.eth1.pid && $attempts -lt 30 ]]; do let attempts++ sleep 1 done WAIT # kill the eth1 dhcp server so that it doesn't override the assigned ip when # the lease is up nanobox.vm.provision "shell", inline: <<-KILL if [ -f /var/run/udhcpc.eth1.pid ]; then echo "Killing eth1 dhcp..." kill -9 $(cat /var/run/udhcpc.eth1.pid) fi KILL %s %s end end`, config.Nanofile.Name, config.Nanofile.Domain, devmode, proxy))) }