vagabond 0.1.0 → 0.1.2

data/CHANGELOG.md

@@ -1,2 +1,13 @@
+## v0.1.2
+* Added support for centos guests
+* Added new base templates for centos and debian
+* Debugging output support
+* Pretty CLI output
+* Actual help output
+* Improved status output
+* SSH functionality to nodes
+* Improved server functionality
+* Other stuff I probably forgot
+
 ## v0.1.0
 * Initial release!

data/README.md

@@ -1,8 +1,8 @@
 # Vagabond
 
-* Issue: VMs are slow. Especially when creating over and over.
-* Discovery: Linux provides LXC tools similar to BSD jails
-* Helpful: LXCs can provide different distributions
+* Issue: VMs are slow.
+* Discovery: Linux has LXC, which is pretty cool.
+* Helpful: LXCs can run different distributions.
 * Implementation: Vagabond
 
 Awesome
@@ -42,53 +42,116 @@ Hash you return. Heres a simple example:
 
 Pretty simple, right?
 
-## Commands
-
-```
-# create and provision
-$ vagabond up precise
+### Templates available
 
-# provision existing
-$ vagabond provision precise
+Currently builtin templates:
 
-# freeze (pause) node
-$ vagabond freeze precise
+* ubuntu_1204
+* ubuntu_1210
+* debian_6
+* debian_7
+* centos_58
+* centos_63
+* centos_64
 
-# thaw (unpause) node
-$ vagabond thaw node
-
-# destroy node
-$ vagabond destroy precise
+## Commands
 
-# status of defined nodes
-$ vagabond status [node]
+Lots of commands. What to see them all? Just ask:
 
-# ssh to node
-$ vagabond ssh precise
+```
+$ vagabond --help
+Nodes:
+        vagabond create NODE [options]
+        vagabond destroy NODE [options]
+        vagabond freeze NODE [options]
+        vagabond provision NODE [options]
+        vagabond rebuild NODE [options]
+        vagabond ssh NODE [options]
+        vagabond start NODE [options]
+        vagabond status NODE [options]
+        vagabond thaw NODE [options]
+        vagabond up NODE [options]
+Server:
+        vagabond server auto_upload [options]
+        vagabond server create [options]
+        vagabond server destroy [options]
+        vagabond server freeze [options]
+        vagabond server provision [options]
+        vagabond server rebuild [options]
+        vagabond server ssh [options]
+        vagabond server start [options]
+        vagabond server status [options]
+        vagabond server stop [options]
+        vagabond server thaw [options]
+        vagabond server up [options]
+        vagabond server upload_cookbooks [options]
+        vagabond server upload_databags [options]
+        vagabond server upload_environments [options]
+        vagabond server upload_roles [options]
+Options:
+        --debug
+        --disable-auto-provision
+        --disable-local-server
+        --disable-configure
+        --force-configure
+    -f, --vagabond-file FILE
+```
 
 ## Local chef server?
 
 Yep, that's right. You can let vagabond set you up with a local chef
 server hanging out in a container, which all your vagabond nodes can
-then run against. Isolated building and test? You betcha!
+then run against. Isolated building and testing? You betcha!
+
+Server containers are isolated by project. This means you will have an
+erchef instance running in an isolated container for every project the
+local server option is enabled. It's just an important bit of information
+to remember so you can make a mental note to stop or freeze it when not
+in use. Or just let them run. What ever floats your boat.
+
+### Vagabond knife
 
-Server provides a superset of the commands available for regular
-vagabond nodes. They are accessed using:
+Since you can have a local chef server running, it can also be helpful
+to be able to actually interact with that server. Vagabond has commands
+for doing bulk uploads of assets, but you can access it too with knife
+to do isolated uploads, or to just do knifey things:
+
+```
+vagabond knife SOME COOL KNIFE COMMAND
+```
 
-`$ vagabond server COMMAND`
+This will just push the command into the local chef server. 
 
 ## Important note
 
 Until namespaces hit Linux proper, vagabond `sudo`s its way around. You
 _can_ get around this using the setcap stuff, but it's pretty meh. If you
-do go that road, just turn off `sudo` in your Vagabond file by setting
-`:sudo => false`.
+do go that road, just turn off `sudo` in your Vagabond file by setting:
+
+```
+:sudo => false
+```
+
+Oh, and if you use `rvm` and would rather be using `rvmsudo` instead of
+boring old `sudo`, you can do that to:
+
+```
+:sudo => 'rvmsudo'
+```
 
 ## Extra note
 
 This is still very much in alpha testing phase. So if you find bugs, please
 report them!
 
+## Contributing
+
+No hard and fast rules for contributing just preferences. I'm always happy to 
+get help making things better!
+
+* Base updates and pull requests on the `develop` branch
+* Please don't update core files like `version.rb` or `vagabond.gemspec`
+
 ## Infos
 
 * Repository: https://github.com/chrisroberts/vagabond

data/lib/vagabond/actions/create.rb

@@ -2,26 +2,27 @@ module Vagabond
   module Actions
     module Create
       def create
-        create
+        if(lxc.exists?)
+          ui.warn "Node already exists: #{name}" unless name == 'server'
+          start
+        else
+          ui.info "#{ui.color('Vagabond:', :bold)} Creating #{ui.color(name, :green)}"
+          do_create
+          ui.info ui.color('  -> CREATED!', :green)
+        end
       end
 
       private
 
-      # Lets get this out proper!
       def do_create
-        unless(check_existing!)
-          @ui.info "LXC: Creating #{name}..."
-          com = "#{sudo}lxc-start-ephemeral -d -o #{config[:template]}"
-          c = Mixlib::ShellOut.new("#{com} && sleep 3")
-          c.run_command
-          e_name = c.stdout.split("\n").last.split(' ').last.strip
-          @internal_config[:mappings][name] = e_name
-          @internal_config.save
-          @lxc = Lxc.new(e_name)
-          @ui.info "LXC: #{name} has been created!"
-        else
-          lxc.start unless lxc.running?
-        end
+        com = "#{sudo}lxc-start-ephemeral -d -o #{config[:template]}"
+        debug(com)
+        c = Mixlib::ShellOut.new("#{com} && sleep 3", :live_stream => Config[:debug])
+        c.run_command
+        e_name = c.stdout.split("\n").last.split(' ').last.strip
+        @internal_config[:mappings][name] = e_name
+        @internal_config.save
+        @lxc = Lxc.new(e_name)
       end
 
     end

data/lib/vagabond/actions/destroy.rb

@@ -2,9 +2,13 @@ module Vagabond
   module Actions
     module Destroy
       def destroy
-        ui.info "Destroying instance: #{name}..."
-        do_destroy
-        ui.info 'Complete!'
+        if(lxc.exists?)
+          ui.info "#{ui.color('Vagabond:', :bold)} Destroying node: #{ui.color(name, :red)}"
+          do_destroy
+          ui.info ui.color('  -> DESTROYED', :red)
+        else
+          ui.error "Node not created: #{name}"
+        end
       end
 
       private
@@ -12,18 +16,25 @@ module Vagabond
       def do_destroy
         lxc.stop if lxc.running?
         com = "#{Config[:sudo]}lxc-destroy -n #{lxc.name}"
-        cmd = Mixlib::ShellOut.new(com)
+        debug(com)
+        cmd = Mixlib::ShellOut.new(com, :live_stream => Config[:debug])
         cmd.run_command
         cmd.error!
         if(cmd.stderr.include?('skipping'))
-          ui.warn 'Failed to unmount some resource. Doing so manually'
+          ui.info ui.color('  -> Failed to unmount some resources. Forcing manually.', :yellow)
           %w(rootfs ephemeralbind).each do |mnt|
-            cmd = Mixlib::ShellOut.new("#{Config[:sudo]}umount /var/lib/lxc/#{lxc.name}/#{mnt}")
+            com = "#{Config[:sudo]}umount /var/lib/lxc/#{lxc.name}/#{mnt}"
+            debug(com)
+            cmd = Mixlib::ShellOut.new(com, :live_stream => Config[:debug])
             cmd.run_command
-            cmd = Mixlib::ShellOut.new("#{Config[:sudo]}lxc-destroy -n #{lxc.name}")
+            com = "#{Config[:sudo]}lxc-destroy -n #{lxc.name}"
+            debug(com)
+            cmd = Mixlib::ShellOut.new(com, :live_stream => Config[:debug])
             cmd.run_command
             cmd.error!
+            internal_config[:mappings].delete(name)
           end
+          internal_config.save
         end
       end
     end

data/lib/vagabond/actions/freeze.rb

@@ -2,11 +2,16 @@ module Vagabond
   module Actions
     module Freeze
       def freeze
-        if(lxc.running?)
-          lxc.freeze
-          ui.info "Container has been frozen: #{name}"
+        if(lxc.exists?)
+          ui.info "#{ui.color('Vagabond:', :bold)} Freezing node: #{ui.color(name, :blue)}"
+          if(lxc.running?)
+            lxc.freeze
+            ui.info ui.color('  -> FROZEN', :blue)
+          else
+            ui.error "Node is not currently running: #{name}"
+          end
         else
-          ui.error "Container #{name} is not currently running"
+          ui.error "Node not created: #{name}"
         end
       end
     end

data/lib/vagabond/actions/provision.rb

@@ -2,28 +2,40 @@ module Vagabond
   module Actions
     module Provision
       def provision
-        if(lxc.exists? && lxc.running?)
-          do_provision
+        if(lxc.exists?)
+          if(lxc.running?)
+            do_provision
+          else
+            ui.error "Node is not currently running: #{name}"
+          end
         else
-          ui.fatal "LXC: Requested container: #{name} has not been created!"
+          ui.error "Node not created: #{name}"
         end
       end
-
+      
       private
 
       def do_provision
-        @ui.info "LXC: Provisioning #{name}..."
-        com = "#{sudo}knife bootstrap #{lxc.container_ip(10, true)} -d chef-full -N #{name} -i /opt/hw-lxc-config/id_rsa "
+        ui.info "#{ui.color('Vagabond:', :bold)} Provisioning node: #{ui.color(name, :magenta)}"
+        com = "sudo knife bootstrap #{lxc.container_ip(10, true)} -d chef-full -N #{name} -i /opt/hw-lxc-config/id_rsa "
         com << "--no-host-key-verify --run-list \"#{config[:run_list].join(',')}\" "
         if(config[:environment])
           com << "-E #{config[:environment]}"
         end
         if(Config[:knife_opts])
-          com << Conifg[:knife_opts]
+          com << Config[:knife_opts]
         end
+        debug(com)
+        # Send the live stream out since people will generally want to
+        # know what's happening
         cmd = Mixlib::ShellOut.new(com, :live_stream => STDOUT)
         cmd.run_command
-        @ui.info "LXC: Provisioning of #{name} complete!"
+        # NOTE: cmd.status.success? won't be valid, so check for FATAL
+        unless(cmd.stdout.split("\n").last.to_s.include?('FATAL'))
+          ui.info ui.color('  -> PROVISIONED', :magenta)
+        else
+          ui.info ui.color('  -> PROVISION FAILED', :red)
+        end
       end
 
     end

data/lib/vagabond/actions/rebuild.rb

@@ -0,0 +1,18 @@
+module Vagabond
+  module Actions
+    module Rebuild
+      def rebuild
+        ui.info "#{ui.color('Vagabond:', :bold)} Rebuilding #{ui.color(name, :blue)}"
+        destroy
+        @lxc = Lxc.new(name)
+        destroy
+        Config[:force_solo] = true
+        ui.info ui.color('  -> DESTROYED!', :red)
+        internal_config.run_solo
+        internal_config[:mappings].delete(name)
+        internal_config.save
+        ui.info ui.color('  -> REBUILT!', :green)
+      end
+    end
+  end
+end

data/lib/vagabond/actions/ssh.rb

@@ -2,10 +2,15 @@ module Vagabond
   module Actions
     module SSH
       def ssh
-        if(lxc.running?)
-          exec("#{Config[:sudo]}ssh root@#{lxc.container_ip(10, true)} -i /opt/hw-lxc-config/id_rsa -oStrictHostKeyChecking=no")
+        if(lxc.exists?)
+          if(lxc.running?)
+            ui.info "#{ui.color('Vagabond:', :bold)} SSH connect to: #{ui.color(name, :cyan)}"
+            exec("#{Config[:sudo]}ssh root@#{lxc.container_ip(10, true)} -i /opt/hw-lxc-config/id_rsa -oStrictHostKeyChecking=no")
+          else
+            ui.error "Node not running: #{name}"
+          end
         else
-          ui.error "Container #{name} is not currently running"
+          ui.error "Node not created: #{name}"
         end
       end
     end

data/lib/vagabond/actions/start.rb

@@ -0,0 +1,18 @@
+module Vagabond
+  module Actions
+    module Start
+
+      def start
+        ui.info "#{ui.color('Vagabond:', :bold)} Starting node: #{ui.color(name, :green)}"
+        do_start
+        ui.info ui.color('  -> STARTED', :green)
+      end
+
+      protected
+      
+      def do_start
+        lxc.start
+      end
+    end
+  end
+end

data/lib/vagabond/actions/status.rb

@@ -2,6 +2,7 @@ module Vagabond
   module Actions
     module Status
       def status
+        ui.info ui.color("Vagabond node status:\n", :bold)
         if(name)
           status_for(name)
         else
@@ -11,18 +12,34 @@ module Vagabond
         end
       end
 
+      private
+
       def status_for(c_name)
         m_name = internal_config[:mappings][c_name]
+        state = nil
+        status = []
         if(Lxc.exists?(m_name))
+          @lxc = Lxc.new(m_name) unless lxc.name == m_name
           info = Lxc.info(m_name)
-          status = info[:state].to_s
-          if(info[:pid])
-            status << " - PID: #{info[:pid]}"
-          end
+          state = info[:state]
+          status << "PID: #{info[:pid] == -1 ? 'N/A' : info[:pid]}"
+          status << "Address: #{lxc.container_ip || 'unknown'}"
+          status << "\n"
+        end
+        case state
+        when :running
+          color = :green
+        when :frozen
+          color = :blue
+        when :stopped
+          color = :yellow
         else
-          status = 'does not exist'
+          color = :red
+        end
+        ui.info ui.color("  #{c_name}: #{state || "Not currently created\n"}", color)
+        unless(status.empty?)
+          ui.info(status.map{|s| "    #{s}"}.join("\n").chomp)
         end
-        ui.info "Status of #{c_name}: #{status}"
       end
     end
   end

data/lib/vagabond/actions/thaw.rb

@@ -2,11 +2,16 @@ module Vagabond
   module Actions
     module Thaw
       def thaw
-        if(lxc.frozen?)
-          lxc.unfreeze
-          ui.info "Container has been thawed: #{name}"
+        if(lxc.exists?)
+          if(lxc.frozen?)
+            ui.info "#{ui.color('Vagabond:', :bold)} Thawing node: #{ui.color(name, :yellow)}"
+            lxc.unfreeze
+            ui.info ui.color('  -> THAWED!', :yellow)
+          else
+            ui.error "Node is not currently frozen: #{name}"
+          end
         else
-          ui.error "Container #{name} is not currently frozen"
+          ui.error "Node does not exist: #{name}"
         end
       end
     end