vagabond 0.2.8 → 0.2.10

data/lib/vagabond/settings.rb

@@ -0,0 +1,17 @@
+require 'chef/mash'
+
+module Vagabond
+  class Settings
+    class << self
+      def [](k)
+        @v ||= Mash.new
+        @v[k]
+      end
+      def []=(k,v)
+        @v ||= Mash.new
+        @v[k] = v
+        v
+      end
+    end
+  end
+end

data/lib/vagabond/spec.rb

@@ -1,7 +1,8 @@
+#encoding: utf-8
 require 'thor'
-require File.join(File.dirname(__FILE__), 'cookbooks/lxc/libraries/lxc.rb')
+require 'elecksee/lxc'
 
-%w(layout vagabond server helpers vagabondfile internal_configuration actions/status).each do |dep|
+%w(vagabond server helpers vagabondfile internal_configuration actions/status).each do |dep|
   require "vagabond/#{dep}"
 end
 
@@ -12,8 +13,6 @@ module Vagabond
     include Helpers
     include Actions::Status
 
-    attr_accessor :layout
-
     self.class_exec(&Vagabond::CLI_OPTIONS)
 
     def self.basename
@@ -23,6 +22,7 @@ module Vagabond
     def initialize(*args)
       @name = nil
       super
+      base_setup(:no_configure, :no_validate)
     end
 
     method_option(:irl,
@@ -30,6 +30,11 @@ module Vagabond
       :default => false,
       :desc => 'Test In Real Life'
     )
+    method_option(:irl_connect,
+      :type => :string,
+      :default => 'ipaddress',
+      :desc => 'Attribute to use for ssh connection'
+    )
     method_option(:environment,
       :type => :string,
       :desc => 'Specify environment to restrict node detection'
@@ -41,18 +46,19 @@ module Vagabond
     )
     desc 'start [CLUSTER]', 'Run specs for cluster'
     def start(cluster=nil)
-      @options = options.dup
-      setup_ui(nil, :no_class_set)
       error = nil
       begin
         if(options[:irl])
           irl_spec(cluster)
         else
           cluster_spec(cluster)
+          cluster_destroy(cluster) if options[:auto_destroy]
         end
       rescue => error
+        ui.error "Unexpected error encountered: #{error}"
+        debug("#{error.class}: #{error}\n#{error.backtrace.join("\n")}")
+        raise
       ensure
-        cluster_destroy(cluster) if options[:auto_destroy] && !options[:irl]
         result = error ? ui.color('FAILED', :red, :bold) : ui.color('PASSED', :green, :bold)
         ui.info "--> Specs for cluster #{cluster}: #{result}"
         raise VagabondError::SpecFailed.new(error) if error
@@ -65,23 +71,19 @@ module Vagabond
     )
     desc 'destroy NAME', 'Destroy the given cluster/node'
     def destroy(cluster)
-      base_setup
       options[:node] ? node_destroy(cluster, options[:node]) : cluster_destroy(cluster)
     end
 
     desc 'status [NAME]', 'Show status of existing nodes'
     def status(name=nil)
-      base_setup
       _status
     end
 
     desc 'init', 'Initalize spec configuration'
     def init
-      setup_ui(nil, :no_class_set)
       ui.info "Initializing spec configuration..."
       make_spec_directory
       populate_spec_directory
-      # - dump empty layout
       ui.info "  -> #{ui.color('COMPLETE!', :green)}"
     end
     
@@ -112,7 +114,6 @@ module Vagabond
     end
 
     def populate_spec_directory
-      write_default_file('Layout')
       write_default_file('spec_helper.rb')
     end
 
@@ -140,26 +141,25 @@ module Vagabond
     end
     
     def irl_spec(cluster)
-      if(cluster && load_layout[cluster])
-        valid_runlists = layout[:clusters][cluster][:nodes]
-        # Runlists composed of role AND/OR recipe
-        valid_runlists.each do |r_l|
-          runlist = r_l.map{|r| Chef::RunList::RunListItem.new(r)}
-          roles = runlist.find_all do |i|
-            i.role?
-          end
-          recipes = runlist.find_all do |i|
-            i.recipe?
-          end
-          terms = roles.map{|r| "role:#{r.name}"} + recipes.map{|r| "recipes:#{r.name}"}
-          query = terms.join(' AND ')
-          if(options[:environment])
-            query = "chef_environment:#{options[:environment]} AND (#{query})"
+      # TODO: Clean up this inject and spit error when nil returned
+      address = options[:irl_connect].split('.').inject(node){|k,m| m[k] || {}}
+      if(cluster && vagabondfile[:clusters][cluster])
+        nodes = vagabondfile[:clusters][cluster].map do |item_name|
+          vagabondfile.for_node(item_name, :allow_missing_node)
+        end
+        valid_runlists = nodes.map do |node|
+          node[:run_list].map do |runlist_item|
+            i = Chef::RunList::RunListItem.new(runlist_item)
+            [i, "#{i.role? ? 'roles' : 'recipes'}:#{i.name}"]
           end
-          search(:node, query).each do |node|
-            n_r = node.run_list.map(&:to_s)
-            next unless n_r.size == r_l.size && (n_r - r_l).empty?
-            test_node!(node.name, node.ipaddress, node.run_list)
+        end
+        valid_runlists.each do |rl|
+          query = rl.map(&:last)
+          query.push("chef_environment:#{options[:environment]}") if options[:environment]
+          search(:node, query.join(' AND ')).each do |node|
+            node_runlist = node.run_list.map(&:to_s)
+            next unless node_runlist.size == rl.size && (node_runlist - rl.map(&:first)).empty?
+            test_node!(node.name, address, node.run_list)
           end
         end
       else
@@ -169,74 +169,118 @@ module Vagabond
         end
         Chef::Search::Query.new(:node, query.join(' AND ')) do |nodes|
           nodes.each do |node|
-            test_node!(node.name, node.ipaddress, node.run_list)
+            test_node!(node.name, address, node.run_list)
           end
         end
       end
     end
 
-    def vagabondfile
-      unless(@vagabondfile)
-        @vagabondfile = Vagabondfile.new(options[:vagabond_file])
-      end
-      @vagabondfile
+    def get_cluster(name)
+      clusters = vagabondfile[:specs][:clusters] || Mash.new
+      cluster = clusters[name] || Mash.new
+      cluster[:nodes] = (vagabondfile[:clusters][name] || []) + (cluster[:nodes] || [])
+      cluster
     end
     
     def cluster_spec(cluster)
-      @options[:auto_provision] = true
-      options[:sudo] = sudo
-      Lxc.use_sudo = vagabondfile[:sudo].nil? ? true : vagabondfile[:sudo]
-      @internal_config = InternalConfiguration.new(vagabondfile, nil, options)
-      # First, setup server
-      if(vagabondfile[:local_chef_server][:enabled])
-        require 'vagabond/server'
-        srv = ::Vagabond::Server.new
-        srv.send(:setup, 'up')
-        srv.send(:execute)
-      end
+      cluster = get_cluster(cluster)
+      
+      setup_server_if_needed
 
-      load_layout
-      default_config = Chef::Mixin::DeepMerge.merge(
-        Mash.new(:platform => 'ubuntu_1204'), layout[:defaults]
-      )
-      test_nodes = []
-      layout[:clusters][cluster][:nodes].each_with_index do |node, index|
-        config = Chef::Mixin::DeepMerge.merge(default_config, layout[:definitions][node])
-        config = Chef::Mixin::DeepMerge.merge(config, layout[:clusters][cluster][:overrides] || {})
-        v_n = vagabond_instance(:up,
+      index = 0
+      test_nodes = cluster[:nodes].map do |node_name|
+        config = vagabondfile.for_node(node_name, :allow_missing)
+        config = vagabondfile.for_definition(node_name) unless config
+        if(cluster[:overrides])
+          config = Chef::Mixin::DeepMerge.merge(config, cluster[:overrides])
+        end
+        v_n = vagabond_instance(:create,
           :platform => config[:platform],
           :cluster => cluster,
-          :base_name => "s-#{node}-#{index}"
+          :base_name => "s-#{node_name}-#{index}"
         )
         v_n.config = Chef::Mixin::DeepMerge.merge(v_n.config, config)
         v_n.send(:execute)
-        test_nodes << [v_n.name, v_n.lxc.name, config]
+        index += 1
+        [v_n, v_n.lxc.name, config]
       end
-      test_nodes.each do |node|
-        name, lxc_name, config = node
-        lxc = Lxc.new(lxc_name)
-        test_node!(name, lxc.container_ip, config[:run_list])
+      run_specs = [cluster[:provision] || :every].flatten.compact.map(&:to_sym)
+      after = cluster[:after] || Mash.new
+      (cluster[:provision] || 1).to_i.times do |i|
+        count = i + 1
+        test_nodes.each do |node|
+          node_inst, lxc_name, config = node
+          node_inst._provision
+          ## specs
+          if(run_specs.include?(:every) || run_specs.include?("after_#{count}".to_sym))
+            test_node!(node_inst.name, node_inst.lxc.container_ip, config)
+          end
+        end
+        if(after[:every])
+          process_after(after[:every], test_nodes.map(&:first), cluster)
+        end
+        if(after[count.to_s])
+          process_after(after[count.to_s], test_nodes.map(&:first), cluster)
+        end
+      end
+
+      destroy_server_if_needed
+    end
+
+    def process_after(after, nodes, cluster_config)
+      if(after[:pause])
+        ui.info ui.color("  Pause run... (#{after[:pause]} seconds)")
+        sleep(after[:pause].to_f)
+      end
+      if(after[:run])
+        run_coms = []
+        if(after[:run].is_a?(String))
+          run_coms << [after[:run], nodes]
+        else
+          if(after[:run][:on])
+            after[:run][:on].each do |dest, com|
+              on_nodes = dest.map do |n|
+                nodes[cluster_config[:nodes].index(n)]
+              end.compact
+              run_coms << [com, on_nodes]
+            end
+            after[:run].delete(:on)
+          end
+          # NOTE: This is just for where `:on` key is missed or people
+          # just want to be lazy
+          after[:run].each_pair do |dest, com|
+            on_nodes = dest.map do |n|
+              nodes[cluster_config[:nodes].index(n)]
+            end.compact
+            run_coms << [com, on_nodes]
+          end
+        end
+        run_coms.each do |com_pair|
+          com_pair.last.each do |node_inst|
+            node_inst.direct_container_command(com_pair.first, :live_stream => STDOUT)
+          end
+        end
       end
     end
     
-    def test_node!(name, ip_address, run_list)
-      run_list.each do |item|
+    def test_node!(name, ip_address, node_config)
+      test_files = []
+      Array(node_config[:run_list]).each do |item|
         r_item = item.is_a?(Chef::RunList::RunListItem) ? item : Chef::RunList::RunListItem.new(item)
         dir = File.join(File.dirname(vagabondfile.path), "spec/#{r_item.type}/#{r_item.name.sub('::', '/')}")
         dir << '/default' if r_item.type.to_sym == :recipe && !r_item.name.include?('::')
-        Dir.glob(File.join(dir, '*.rb')).each do |path|
-          com = "#{sudo}VAGABOND_TEST_HOST='#{ip_address}' rspec #{path}"
-          debug(com)
-          cmd = Mixlib::ShellOut.new(com, :live_stream => STDOUT, :env => {'VAGABOND_TEST_HOST' => ip_address})
-          cmd.run_command
-          cmd.error!
-        end
+        test_files += Dir.glob(File.join(dir, '*.rb')).map(&:to_s)
+      end
+      Array(node_config[:custom_specs]).each do |custom|
+        dir = File.join(vagabondfile.directory, 'spec/custom', File.join(*custom.split('::')))
+        test_files += Dir.glob(File.join(dir, '*.rb')).map(&:to_s)
+      end
+      test_files.flatten.compact.each do |path|
+        ui.info "\n#{ui.color('**', :green, :bold)}  Running spec: #{path.sub("#{vagabondfile.directory}/", '')}"
+        cmd = build_command("rspec #{path}", :live_stream => STDOUT, :shellout => {:env => {'VAGABOND_TEST_HOST' => ip_address}})
+        cmd.run_command
+        cmd.error!
       end
-    end
-
-    def load_layout
-      # Load up layouts and set defaults
-      @layout = Layout.new(File.dirname(vagabondfile.path))
     end
     
     def vagabond_instance(action, args={})
@@ -270,8 +314,10 @@ module Vagabond
       if(name)
         clusters = [name]
       else
-        load_layout
-        clusters = layout[:clusters].keys.sort
+        clusters = Mash.new
+        clusters.merge!(vagabondfile[:clusters] || Mash.new)
+        clusters.merge!(vagabondfile[:specs][:clusters] || Mash.new)
+        clusters = clusters.keys.sort
       end
       clusters.each do |cluster|
         ui.info "#{ui.color('Status of spec cluster:', :bold)} #{ui.color(cluster, :yellow)}"
@@ -301,24 +347,6 @@ module Vagabond
       internal_config.save
     end
     
-    CONTENT_DEFAULT_LAYOUT = <<-EOF
-{
-  :defaults => {
-    :platform => 'ubuntu_1204',
-    :environment => nil
-  },
-  :definitions => {
-    :example_node => {
-      :run_list => %w(role[example])
-    }
-  },
-  :clusters => {
-    :example_cluster => {
-      :nodes => ['example_node']
-    }
-  }
-}
-EOF
     CONTENT_DEFAULT_SPEC_HELPER = <<-EOF
 require 'serverspec'
 require 'pathname'
@@ -341,5 +369,3 @@ EOF
     
   end
 end
-
-  

data/lib/vagabond/uploader.rb

@@ -1,3 +1,4 @@
+#encoding: utf-8
 Dir.new(File.join(File.dirname(__FILE__), 'uploader')).each do |file|
   next if file.start_with?('.') || !file.end_with?('.rb')
   require "vagabond/uploader/#{file}"
@@ -11,13 +12,15 @@ module Vagabond
     attr_reader :store
     attr_reader :options
     attr_reader :ui
+    attr_reader :vagabondfile
 
     include Helpers
     
-    def initialize(base_directory, options={})
+    def initialize(vagabondfile, base_directory, options={})
       @store = base_directory
       @options = Mash.new(options)
       @ui = options[:ui]
+      @vagabondfile = vagabondfile
     end
 
     def prepare

data/lib/vagabond/uploader/berkshelf.rb

@@ -1,3 +1,4 @@
+#encoding: utf-8
 require 'vagabond/uploader/knife'
 
 module Vagabond
@@ -34,7 +35,7 @@ module Vagabond
 
       def vendor(*args)
         FileUtils.mkdir_p(ckbk_store = File.join(store, 'cookbooks'))
-        com = "berks install -b #{options[:berksfile]} -p #{ckbk_store}"
+        com = "berks install -b #{options[:berksfile]} -p #{ckbk_store} #{Array(options[:berks_opts]).compact.flatten.join(' ')}"
         debug(com)
         cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
         cmd.run_command

data/lib/vagabond/uploader/knife.rb

@@ -1,3 +1,4 @@
+#encoding: utf-8
 require 'vagabond/uploader'
 
 module Vagabond
@@ -6,18 +7,11 @@ module Vagabond
 
       def upload(*args)
         prepare unless args.include?(:no_prepare)
-        com = "knife cookbook upload#{options[:knife_opts]} --all"
+        com = "cookbook upload#{options[:knife_opts]} --all"
         if(options[:cookbook_paths])
           com << " --cookbook-path #{Array(options[:cookbook_paths]).join(':')}"
         end
-        if(File.exists?(knife_config = File.join(store, '.chef/knife.rb')))
-          com << " --config #{knife_config}"
-        end
-        debug(com)
-        cmd = Mixlib::ShellOut.new(com,
-          :live_stream => options[:debug],
-          :cwd => store
-        )
+        cmd = knife_command(com, :cwd => store)
         cmd.run_command
         cmd.error!
       end

data/lib/vagabond/uploader/librarian.rb

@@ -1,3 +1,4 @@
+#encoding: utf-8
 require 'vagabond/uploader/knife'
 
 module Vagabond
@@ -20,11 +21,7 @@ module Vagabond
         else
           com = "librarian-chef install --path=#{File.join(store, 'cookbooks')}"
         end
-        debug(com)
-        cmd = Mixlib::ShellOut.new(com,
-          :live_stream => options[:debug],
-          :cwd => File.dirname(options[:cheffile])
-        )
+        cmd = build_command(com, :shellout => {:cwd => File.dirname(options[:cheffile])})
         cmd.run_command
         cmd.error!
         options[:cookbook_paths] = [File.join(store, 'cookbooks')]

data/lib/vagabond/vagabond.rb

@@ -1,7 +1,8 @@
+#encoding: utf-8
 require 'thor'
 require 'chef/knife/core/ui'
 require 'vagabond/uploader'
-require File.join(File.dirname(__FILE__), 'cookbooks/lxc/libraries/lxc.rb')
+require 'elecksee/lxc'
 
 %w(constants errors vagabondfile internal_configuration helpers).each do |dep|
   require "vagabond/#{dep}"
@@ -17,6 +18,8 @@ end
 
 module Vagabond
   class Vagabond < Thor
+
+    DISABLE_HOST_SOLO_ON = %w(status init)
     
     include Thor::Actions
     include Helpers
@@ -26,52 +29,51 @@ module Vagabond
       include klass if klass.is_a?(Module)
     end
     
-    attr_reader :name
-    attr_reader :vagabondfile
-    attr_reader :internal_config
-    attr_reader :ui
-    attr_reader :options
-
     attr_accessor :mappings_key
     attr_accessor :lxc
     attr_accessor :config
     attr_accessor :action
 
     CLI_OPTIONS = lambda do
-    class_option(:debug,
-      :type => :boolean,
-      :default => false
-    )
-
-    class_option(:force_solo,
-      :aliases => '--force-configure',
-      :type => :boolean,
-      :default => false,
-      :desc => 'Force configuration of system'
-    )
-
-    class_option(:color,
-      :type => :boolean,
-      :default => true,
-      :desc => 'Enable/disable colorized output'
-    )
-
-    class_option(:vagabond_file,
-      :aliases => '-f',
-      :type => :string,
-      :desc => 'Provide path to Vagabondfile'
-    )
-    
-    class_option(:local_server,
-      :type => :boolean,
-      :default => true,
-      :desc => 'Enable/disable local Chef server usage if available'
-    )
+      class_option(:debug,
+        :type => :boolean,
+        :default => false
+      )
+
+      class_option(:force_solo,
+        :aliases => '--force-configure',
+        :type => :boolean,
+        :default => false,
+        :desc => 'Force configuration of system'
+      )
+
+      class_option(:color,
+        :type => :boolean,
+        :default => true,
+        :desc => 'Enable/disable colorized output'
+      )
+
+      class_option(:vagabond_file,
+        :aliases => '-f',
+        :type => :string,
+        :desc => 'Provide path to Vagabondfile'
+      )
+      
+      class_option(:local_server,
+        :type => :boolean,
+        :default => true,
+        :desc => 'Enable/disable local Chef server usage if available'
+      )
+
+      class_option(:callbacks,
+        :type => :boolean,
+        :default => true,
+        :desc => 'Enable/disable action callbacks'
+      )
     end
 
     CLI_OPTIONS.call
 
-    
     # action:: Action to perform
     # name:: Name of vagabond
     # config:: Hash configuration
@@ -101,8 +103,14 @@ module Vagabond
           end
         end
         define_method meth do |*args|
-          setup(meth, *args)
-          execute
+          @original_args = args.dup
+          unless(args.include?(:no_setup))
+            setup(meth, *args)
+          end
+          result = execute
+          callbacks(meth)
+          chain!
+          result
         end
       end
     end
@@ -111,6 +119,16 @@ module Vagabond
 
     protected
 
+    def attributes
+      if(config[:attributes])
+        if(config[:attributes].is_a?(Hash))
+          JSON.dump(config[:attributes])
+        else
+          config[:attributes].to_s
+        end
+      end
+    end
+    
     def version
       setup_ui
       ui.info "#{ui.color('Vagabond:', :yellow, :bold)} - Advocating idleness and work-shyness"
@@ -119,25 +137,22 @@ module Vagabond
     end
     
     def execute
-      self.send("_#{@action}")
+      self.send("_#{action}")
     end
     
     def setup(action, name=nil, *args)
       @action = action
       @name = name
-      @options = options.dup
-      if(args.last.is_a?(Hash))
-        _ui = args.last.delete(:ui)
-        @options.merge!(args.last)
-      end
-      @leftover_args = args
-      setup_ui(_ui)
-      load_configurations
-      if(respond_to?(check = "#{action}_validate?".to_sym))
-        validate! if send(check)
+      hash_args = args.detect{|x|x.is_a?(Hash)}
+      if(hash_args)
+        args.delete(hash_args)
+        _ui = hash_args.delete(:ui)
+        base_setup(_ui)
+        config.merge!(hash_args)
       else
-        validate!
+        base_setup
       end
+      @leftover_args = args
     end
 
     def name_required!
@@ -150,45 +165,17 @@ module Vagabond
     def provision_solo(dir)
       ui.info "#{ui.color('Vagabond:', :bold)} Provisioning node: #{ui.color(name, :magenta)}"
       lxc.container_ip(20) # force wait for container to appear and do so quietly
-      direct_container_command(
+      cmd = direct_container_command(
         "chef-solo -c #{File.join(dir, 'solo.rb')} -j #{File.join(dir, 'dna.json')}",
         :live_stream => STDOUT
       )
+      raise VagabondError::NodeProvisionFailed.new("Failed to provision: #{name}") unless cmd
     end
     
-    def load_configurations
-      @vagabondfile = Vagabondfile.new(options[:vagabond_file], :allow_missing)
-      options[:sudo] = sudo
-      # TODO: provide action call back for full or partial solo disable
-      if((@action.to_s == 'status' && lxc_installed?) || @action.to_s == 'init')
-        options[:disable_solo] = true
-      end
-      Chef::Log.init('/dev/null') unless options[:debug]
-      Lxc.use_sudo = @vagabondfile[:sudo].nil? ? true : @vagabondfile[:sudo]
-      @internal_config = InternalConfiguration.new(@vagabondfile, ui, options)
-      options[:disable_solo] = false if @action.to_s == 'init'
-      @config = @vagabondfile[:boxes][name]
-      @lxc = Lxc.new(@internal_config[mappings_key][name] || '____nonreal____')
-      if(options[:local_server] && lxc_installed?)
-        if(@vagabondfile[:local_chef_server] && @vagabondfile[:local_chef_server][:enabled])
-          srv_name = @internal_config[:mappings][:server]
-          srv = Lxc.new(srv_name) if srv_name
-          if(srv_name && srv.running?)
-            proto = @vagabondfile[:local_chef_server][:zero] ? 'http' : 'https'
-            options[:knife_opts] = " --server-url #{proto}://#{srv.container_ip(10, true)}"
-          else
-            unless(@action.to_sym == :status || name.to_s =='server')
-              ui.warn 'Local chef server is not currently running!' unless @action.to_sym == :status
-            end
-          end
-        end
-      end
-    end
-
     def validate!
       if(name.to_s == 'server')
         ui.fatal "RESERVED node name supplied: #{ui.color(name, :red)}"
-        ui.info ui.color("  -> Try: vagabond server #{@action}", :cyan)
+        ui.info ui.color("  -> Try: vagabond server #{action}", :cyan)
         raise VagabondError::ReservedName.new(name)
       end
       if(name && config.nil? && !options[:disable_name_validate])
@@ -199,7 +186,7 @@ module Vagabond
     end
     
     def check_existing!
-      if(@lxc.exists?)
+      if(lxc.exists?)
         ui.error "LXC: #{name} already exists!"
         true
       end
@@ -213,20 +200,17 @@ module Vagabond
       File.join(base_dir, '.vagabond')
     end
 
-    def lxc_installed?
-      system('which lxc-info > /dev/null')
-    end
-
     def wait_for_completion(type=nil)
+      @threads ||= []
       if(type)
-        Array(@threads[:type]).map(&:join)
+        Array(@threads[type]).collect{|hsh| hsh[:thread]}.map(&:join)
       else
-        @threads.values.map do |threads|
-          threads.each do |thread_set|
-            Array(thread_set).map(&:join)
-          end
-        end
+        @threads.values.flatten.collect{|hsh| hsh[:thread]}.map(&:join)
       end
     end
+
+    def tasks(type=nil)
+      type ? @threads[type] : @threads
+    end
   end
 end