vagabond 0.2.0 → 0.2.2

data/lib/vagabond/kitchen.rb

@@ -1,16 +1,20 @@
 require 'thor'
 require 'chef'
+require 'kitchen'
 require 'kitchen/busser'
+require 'kitchen/loader/yaml'
+require 'vagabond/monkey/kitchen_config'
 
-%w(helpers vagabondfile vagabond server helpers/cheffile_loader).each do |dep|
+%w(constants errors helpers vagabondfile vagabond server helpers/cheffile_loader actions/status).each do |dep|
   require "vagabond/#{dep}"
 end
 
 module Vagabond
   class Kitchen < Thor
-    
+
     include Thor::Actions
     include Helpers
+    include Actions::Status
 
     class << self
       def basename
@@ -19,13 +23,14 @@ module Vagabond
     end
 
     self.class_exec(&Vagabond::CLI_OPTIONS)
-    
+
     attr_reader :kitchen
     attr_reader :platform_map
     attr_reader :vagabondfile
     attr_reader :ui
     attr_reader :name
     attr_reader :action
+    attr_reader :internal_config
 
     def initialize(*args)
       super
@@ -51,7 +56,7 @@ module Vagabond
       end
     end
 
-    desc 'test COOKBOOK', 'Run test kitchen on COOKBOOK'
+    desc 'test [COOKBOOK]', 'Run test kitchen on COOKBOOK'
     method_option(:platform,
       :type => :string,
       :desc => 'Specify platform to test'
@@ -68,27 +73,33 @@ module Vagabond
     method_option(:parallel,
       :type => :boolean,
       :default => false,
-      :desc => 'Build test nodes in parallel'
+      :desc => 'Build test nodes in parallel [not enabled yet]'
     )
     method_option(:suites,
       :type => :string,
       :desc => 'Specify suites to test [suite1,suite2,...]'
     )
-    def test(cookbook)
+    def test(*args)
+      cookbook = args.first
       setup(cookbook, :test)
+
       ui.info "#{ui.color('Vagabond:', :bold)} - Kitchen testing for cookbook #{ui.color(name, :cyan)}"
       results = Mash.new
       platforms = [options[:platform] || platform_map.keys].flatten
-      if(options[:cluster])
-        ui.info ui.color("  -> Cluster Testing #{options[:cluster]}!", :yellow)
-        if(kitchen[:clusters].nil? || kitchen[:clusters][options[:cluster]].nil?)
+      if(cluster_name = options[:cluster])
+        ui.info ui.color("  -> Cluster Testing #{cluster_name}!", :yellow)
+        if(kitchen.clusters.empty? || kitchen.clusters[cluster_name].nil?)
           ui.fatal "Requested cluster is not defined: #{options[:cluster]}"
-          exit EXIT_CODES[:cluster_invalid]
+          raise VagabondError::ClusterInvalid.new(cluster_name)
         end
         serv = Server.new
+        if(@solo && serv.vagabondfile[:local_chef_server].empty?)
+          serv.vagabondfile[:local_chef_server].update(:enabled => true, :zero => true)
+        end
         serv.options = options
+        serv.send(:do_create)
         serv.auto_upload # upload everything : make optional?
-        suites = kitchen[:clusters][options[:cluster]]
+        suites = kitchen.clusters[options[:cluster]]
         platforms.each do |platform|
           %w(local_server_provision test destroy).each do |action|
             suites.each do |suite_name|
@@ -103,6 +114,7 @@ module Vagabond
             end
           end
         end
+        serv.destroy
       else
         suites = options[:suites] ? options[:suites].split(',') : ['default']
         platforms.each do |platform|
@@ -124,17 +136,28 @@ module Vagabond
           ui.info "    Suite: #{res[:suite_name]} -> #{res[:result] ? ui.color('SUCCESS!', :green) : ui.color('FAILED!', :red)}"
         end
       end
+      raise KitchenTestFailed.new(infos.map{|res| res[:suite_name] unless res[:result]}.compact)
     end
-    
+
+    desc 'status [NAME]', 'Show test node status'
+    def status(name=nil)
+      setup(name, :status)
+      _status
+    end
+
     protected
 
+    def mappings_key
+      :test_mappings
+    end
+
     def local_server_provision_node(platform, suite_name)
       run_list = generate_runlist(platform, suite_name)
       v_inst = vagabond_instance(:up, platform, :suite_name => suite_name, :run_list => run_list)
       raise "ERROR! No local chef!" unless v_inst.options[:knife_opts]
       v_inst.send(:execute)
     end
-    
+
     # TODO: Handle failed provision!
     def provision_node(platform, suite_name)
       run_list = generate_runlist(platform, suite_name)
@@ -161,18 +184,35 @@ module Vagabond
         v_inst.send(:execute)
       end
     end
-    
+
     def setup(name, action)
+      @solo = name.to_s.strip.empty?
       @options = options.dup
-      @vagabondfile = Vagabondfile.new(options[:vagabond_file])
+      @vagabondfile = Vagabondfile.new(options[:vagabond_file], :allow_missing)
       setup_ui
-      @name = name
+      @internal_config = InternalConfiguration.new(@vagabondfile, ui, options)
+      @name = name || action == :status ? name : discover_name
+      load_kitchen_yml(@name) unless action == :status
       @action = action
-      load_kitchen_yml
+    end
+
+    # TODO: Make this traverse up if in cookbook subdir
+    def discover_name
+      name = nil
+      if(File.exists?('metadata.rb'))
+        m = Chef::Cookbook::Metadata.new
+        m.from_file('metadata.rb')
+        name = m.name
+        unless(name)
+          name = File.basename(File.dirname(File.expand_path(Dir.pwd)))
+        end
+      end
+      raise "Failed to detect name of cookbook. Are we in the top directory?" unless name
+      name
     end
 
     def configure_for(l_name, platform, suite_name, runlist, *args)
-      dir = File.join(File.dirname(vagabondfile.path), ".vagabond/node_configs/#{l_name}")
+      dir = File.join(File.dirname(vagabondfile.store_path), ".vagabond/node_configs/#{l_name}")
       FileUtils.mkdir_p(dir)
       _args = [args.include?(:integration) ? :integration : nil].compact
       write_dna(l_name, suite_name, dir, platform, runlist, *_args) if args.include?(:dna)
@@ -186,14 +226,14 @@ module Vagabond
         file.write("cookbook_path '#{File.join(dir, 'cookbooks')}'\n")
       end
     end
-    
+
     def write_dna(l_name, suite_name, dir, platform, runlist, *args)
       key = args.include?(:integration) ? :integration_suites : :suites
       dna = Mash.new
-      dna.merge!(platform_map[platform][:attributes] || {})
-      s_args = kitchen[:suites].detect{|s|s[:name] == suite_name}
-      if(s_args)
-        dna.merge!(s_args)
+      dna.merge!(platform_map[platform][:attributes] || Mash.new)
+      suite = kitchen.suites.detect{|s|s.name == suite_name}
+      if(suite)
+        dna.merge!(suite.attributes)
       end
       dna[:run_list] = runlist
       File.open(File.join(dir, 'dna.json'), 'w') do |file|
@@ -202,30 +242,70 @@ module Vagabond
     end
 
     def cookbook_path
-      Chef::CookbookLoader.new(
-        File.join(File.dirname(vagabondfile.path), 'cookbooks')
-      ).load_cookbooks[name].root_dir
+      if(@solo)
+        vagabondfile.directory
+      else
+        require 'chef/knife'
+        begin
+          Chef::Knife.new.configure_chef
+        rescue
+          # ignore
+        end
+        Chef::CookbookLoader.new(
+          Chef::Config[:cookbook_path]
+        ).load_cookbooks[name].root_dir
+      end
     end
-    
-    def load_cookbooks(l_name, suite_name, dir, platform, runlist, *_args)
+
+    def custom_cheffile
+      ui.warn "Installing Cooks with Librarian"
       contents = ['site "http://community.opscode.com/api/v1"']
       contents << "cookbook '#{name}', :path => '#{cookbook_path}'"
       contents << "cookbook 'minitest-handler'"
-      # TODO - Customs from kitchen. Customs from root. Customs from cookbook
-      File.open(File.join(dir, 'Cheffile'), 'w') do |file|
-        file.write(contents.join("\n"))
+      contents.join("\n")
+    end
+
+    def load_cookbooks(l_name, suite_name, dir, platform, runlist, *_args)
+      if(File.exists?(File.join(vagabondfile.directory, 'Berksfile')))
+        berks_vendor
+      else
+        librarian_vendor
+      end
+    end
+          
+    def berks_vendor
+      ui.info 'Cookbooks being vendored via berks'
+      berk_uploader = Uploader::Berkshelf.new(
+        vagabondfile.generate_store_path, options.merge(
+          :ui => ui,
+          :berksfile => File.join(vagabondfile.directory, 'Berksfile'),
+          :chef_server_url => options[:knife_opts].to_s.split(' ').last
+        )
+      )
+      berk_uploader.upload
+    end
+
+    def librarian_vendor
+      ui.info 'Cookbooks being vendored with librarian'
+      unless(File.exists?(cheffile = File.join(vagabondfile.directory, 'Cheffile')))
+        File.open(cheffile = vagabond.generate_store_path, 'w') do |file|
+          file.write custom_cheffile
+        end
       end
-      com = "librarian-chef update"
-      debug(com)
-      c = Mixlib::ShellOut.new(com, :live_stream => options[:debug], :cwd => dir)
-      c.run_command
-      c.error!
+      librarian_uploader = Uploader::Librarian.new(
+        vagabondfile.generate_store_path, options.merge(
+          :ui => ui,
+          :cheffile => cheffile
+        )
+      )
+      librarian_uploader.prepare
     end
 
     def bus_node(v_inst, suite_name)
-      unless(::Kitchen::Busser::DEFAULT_TEST_ROOT == c_path = File.join(cookbook_path, 'test/integration'))
+      test_path = options[:cluster] ? 'test/cluster' : 'test/integration'
+      unless(::Kitchen::Busser::DEFAULT_TEST_ROOT == c_path = File.join(cookbook_path, test_path))
         ::Kitchen::Busser.send(:remove_const, :DEFAULT_TEST_ROOT)
-        ::Kitchen::Busser.const_set(:DEFAULT_TEST_ROOT, File.join(cookbook_path, 'test/integration'))
+        ::Kitchen::Busser.const_set(:DEFAULT_TEST_ROOT, c_path)
       end
       busser = ::Kitchen::Busser.new(suite_name)
       ui.info "#{ui.color('Kitchen:', :bold)} Setting up..."
@@ -236,7 +316,7 @@ module Vagabond
       end
       busser
     end
-    
+
     def vagabond_instance(action, platform, args={})
       options[:disable_name_validate] = true
       v = Vagabond.new
@@ -260,42 +340,42 @@ module Vagabond
       v
     end
 
-    def load_kitchen_yml
-      y_path = File.join(
-        File.dirname(vagabondfile.path), 'cookbooks', name, '.kitchen.yml'
+    def load_kitchen_yml(name)
+      @kitchen = ::Kitchen::Config.new(
+        :kitchen_root => cookbook_path,
+        :test_base_path => File.join(cookbook_path, 'test/integration'),
+        :loader => ::Kitchen::Loader::YAML.new(
+          File.join(cookbook_path, '.kitchen.yml')
+        )
       )
-      if(File.exists?(y_path))
-        @kitchen = Mash.new(YAML.load(File.read(y_path)))
-      else
-        ui.fatal "Cookbook #{name} does not have a .kitchen.yml file defined!"
-        ui.info ui.color("  -> Path: #{y_path}", :red)
-        exit EXIT_CODES[:kitchen_missing_yml]
-      end
     end
 
     def platform_map
-      @platform_map ||= Mash.new(Hash[*(
-          kitchen[:platforms].map do |plat|
+      @platform_map ||= Mash[
+        *(
+          kitchen.platforms.map do |plat|
             [
-              plat[:name], Mash.new(
-                  :template => plat[:driver_config][:box].scan(
-                    %r{([^-]+-[^-]+)$}
-                  ).flatten.first.to_s.gsub('.', '').gsub('-', '_'),
-                  :run_list => plat[:run_list],
-                  :attributes => plat[:attributes]
+              plat.name, Mash.new(
+                :template => plat.name.gsub('.', '').gsub('-', '_'),
+                :run_list => plat.run_list,
+                :attributes => plat.attributes
               )
             ]
           end.flatten
-      )])
+        )
+      ]
     end
 
     def generate_runlist(platform, suite)
+      unless(platform_map[platform])
+        raise "Invalid platform #{platform}. Valid: #{platform_map.keys.sort.join(', ')}"
+      end
       r = platform_map[platform][:run_list]
-      kitchen_suite = kitchen[:suites].detect do |k_s|
-        k_s[:name] == suite
+      kitchen_suite = kitchen.suites.detect do |k_s|
+        k_s.name == suite
       end
-      if(kitchen_suite && kitchen_suite[:run_list])
-        r |= kitchen_suite[:run_list]
+      if(kitchen_suite && kitchen_suite.run_list)
+        r |= kitchen_suite.run_list
       end
       r.uniq
     end
@@ -304,7 +384,7 @@ module Vagabond
       unless(platform_map[plat])
         ui.fatal "Requested platform does not exist: #{ui.color(plat, :red)}"
         ui.info "  -> Available platforms: #{platform_map.keys.sort.join(', ')}"
-        exit EXIT_CODES[:kitchen_invalid_platform]
+        raise VagabondError::KitchenInvalidPlatform.new(plat)
       end
     end
   end

data/lib/vagabond/knife.rb

@@ -14,7 +14,7 @@ module Vagabond
     def initialize(*args)
       super
     end
-    
+
     desc 'knife COMMAND', 'Run knife commands against local Chef server'
     def knife(command, *args)
       @options = options.dup
@@ -27,15 +27,18 @@ module Vagabond
         if(@vagabondfile[:local_chef_server] && @vagabondfile[:local_chef_server][:enabled])
           srv = Lxc.new(@internal_config[:mappings][:server])
           if(srv.running?)
-            options[:knife_opts] = " -s https://#{srv.container_ip(10, true)}"
+            proto = @vagabondfile[:local_chef_server][:zero] ? 'http' : 'https'
+            options[:knife_opts] = " --server-url #{proto}://#{srv.container_ip(10, true)}"
           else
             options[:knife_opts] = ' -s https://no-local-server'
           end
         end
       end
-      exec("knife #{[command, args].flatten.compact.join(' ')} #{options[:knife_opts]}")
+      command_string = [command, args.map{|s| "'#{s}'"}].flatten.compact.join(' ')
+      if(ENV['VAGABOND_KNIFE_DEBUG'])
+        puts "knife #{command_string} #{options[:knife_opts]}"
+      end
+      exec("knife #{command_string} #{options[:knife_opts]}")
     end
-
-    
   end
 end

data/lib/vagabond/layout.rb

@@ -0,0 +1,16 @@
+module Vagabond
+  class Layout
+
+    def initialize(base_dir)
+      unless(File.exists?(path = File.join(base_dir, 'spec/Layout')))
+        raise 'Spec layout file does not exist'
+      end
+      @l = Mash.new(self.instance_eval(IO.read(path), path, 1))
+    end
+
+    def [](k)
+      @l[k]
+    end
+
+  end
+end

data/lib/vagabond/monkey/kitchen_config.rb

@@ -0,0 +1,23 @@
+require 'kitchen/config'
+
+module Vagabond
+  module MonkeyPatch
+    module KitchenConfig
+      def clusters
+        unless(@clusters)
+          @clusters = Hash[
+            *(
+              Array(data[:clusters]).map{ |name, suite_names|
+                [name, suite_names]
+              }.flatten(1)
+            )
+          ]
+          @clusters = Mash.new(@clusters)
+        end
+        @clusters
+      end
+    end
+  end
+end
+
+Kitchen::Config.send(:include, Vagabond::MonkeyPatch::KitchenConfig)

data/lib/vagabond/server.rb

@@ -18,7 +18,7 @@ module Vagabond
       super
       @name = 'server'
       @base_template = 'ubuntu_1204' # TODO: Make this dynamic
-      setup(nil, name)
+      setup('status')
     end
 
     desc 'server stop', 'Stops the local Chef server'
@@ -49,27 +49,31 @@ module Vagabond
     desc 'upload_roles', 'Upload all roles'
     def upload_roles
       am_uploading('roles') do
-        com = "knife role from file #{File.join(base_dir, 'roles/*')} #{options[:knife_opts]}"
-        debug(com)
-        cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
-        cmd.run_command
-        cmd.error!
+        if(File.directory?(File.join(base_dir, 'roles')))
+          com = "knife role from file #{File.join(base_dir, 'roles/*')} #{options[:knife_opts]}"
+          debug(com)
+          cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
+          cmd.run_command
+          cmd.error!
+        end
       end
     end
 
     desc 'upload_databags', 'Upload all data bags'
     def upload_databags
       am_uploading('data bags') do
-        Dir.glob(File.join(base_dir, "data_bags/*")).each do |b|
-          next if %w(. ..).include?(b)
-          coms = [
-            "knife data bag create #{File.basename(b)} #{options[:knife_opts]}",
-            "knife data bag from file #{File.basename(b)} #{options[:knife_opts]} --all"
-          ].each do |com|
-            debug(com)
-            cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
-            cmd.run_command
-            cmd.error!
+        if(File.directory?(File.join(base_dir, 'data_bags')))
+          Dir.glob(File.join(base_dir, "data_bags/*")).each do |b|
+            next if %w(. ..).include?(b)
+            coms = [
+              "knife data bag create #{File.basename(b)} #{options[:knife_opts]}",
+              "knife data bag from file #{File.basename(b)} #{options[:knife_opts]} --all"
+            ].each do |com|
+              debug(com)
+              cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
+              cmd.run_command
+              cmd.error!
+            end
           end
         end
       end
@@ -78,18 +82,22 @@ module Vagabond
     desc 'upload_environments', 'Upload all environments'
     def upload_environments
       am_uploading('environments') do
-        com = "knife environment from file #{File.join(base_dir, 'environments/*')} #{options[:knife_opts]}"
-        debug(com)
-        cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
-        cmd.run_command
-        cmd.error!
+        if(File.directory?(File.join(base_dir, 'environments')))
+          com = "knife environment from file #{File.join(base_dir, 'environments/*')} #{options[:knife_opts]}"
+          debug(com)
+          cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
+          cmd.run_command
+          cmd.error!
+        end
       end
     end
 
     desc 'upload_cookbooks', 'Upload all cookbooks'
     def upload_cookbooks
       am_uploading('cookbooks') do
-        if(vagabondfile[:local_chef_server][:berkshelf])
+        if(vagabondfile[:local_chef_server][:librarian])
+          librarian_upload
+        elsif(vagabondfile[:local_chef_server][:berkshelf])
           berks_upload
         else
           raw_upload
@@ -111,64 +119,72 @@ module Vagabond
       yield
       ui.info ui.color("  -> UPLOADED #{thing.upcase}", :green)
     end
-
-    def write_berks_config
-      path = File.join(vagabond_dir, 'berks.json')
-      if(File.exists?(path))
-        cur = Mash.new(JSON.load(File.read(path)))
-      else
-        cur = Mash.new
-      end
-      url = "https://#{lxc.container_ip(10, true)}"
-      if(cur[:chef].nil? || cur[:chef][:chef_server_url] != url)
-        cur[:chef] = Mash.new(:chef_server_url => url)
-        cur[:ssl] = Mash.new(:verify => false)
-        File.open(path, 'w') do |file|
-          file.write(JSON.dump(cur))
-        end
-      end
-    end
     
     def do_create
-      com = "#{options[:sudo]}lxc-clone -n #{generated_name} -o #{@base_template}"
-      debug(com)
-      cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
-      cmd.run_command
-      cmd.error!
       @lxc = Lxc.new(generated_name)
+      unless(@lxc.exists?)
+        com = "#{options[:sudo]}lxc-clone -n #{generated_name} -o #{@base_template}"
+        debug(com)
+        cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
+        cmd.run_command
+        cmd.error!
+      else
+        ui.warn 'Found server instance not if configuration. Adding and moving on.'
+      end
       @internal_config[:mappings][name] = generated_name
       @internal_config.save
       ui.info ui.color('  -> Chef Server container created!', :cyan)
       lxc.start
-      ui.info ui.color('  -> Bootstrapping erchef...', :cyan)
-      tem_file = File.expand_path(File.join(File.dirname(__FILE__), 'bootstraps/server.erb'))
-      com = "#{options[:sudo]}knife bootstrap #{lxc.container_ip(10, true)} --template-file #{tem_file} -i /opt/hw-lxc-config/id_rsa"
-      debug(com)
-      cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug], :timeout => 1200)
-      cmd.run_command
-      cmd.error!
       ui.info ui.color('  -> Chef Server CREATED!', :green)
-      options[:knife_opts] = " --server-url https://#{lxc.container_ip(20, true)}"
+      do_provision
       auto_upload if vagabondfile[:local_chef_server][:auto_upload]
     end
 
-    def berks_upload
-      write_berks_config
-      com = "berks upload -c #{File.join(vagabond_dir, 'berks.json')}"
+    def do_provision
+      if(vagabondfile[:local_chef_server][:zero])
+        ui.info ui.color('  -> Bootstrapping chef-zero...', :cyan)
+        tem_file = File.expand_path(File.join(File.dirname(__FILE__), 'bootstraps/server-zero.erb'))
+        options[:knife_opts] = " --server-url http://#{lxc.container_ip(20, true)}"
+      else
+        ui.info ui.color('  -> Bootstrapping erchef...', :cyan)
+        tem_file = File.expand_path(File.join(File.dirname(__FILE__), 'bootstraps/server.erb'))
+        options[:knife_opts] = " --server-url https://#{lxc.container_ip(20, true)}"
+      end
+      com = "#{options[:sudo]}knife bootstrap #{lxc.container_ip(10, true)} --template-file #{tem_file} -i /opt/hw-lxc-config/id_rsa"
+      cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug], :timeout => 1200)
       debug(com)
-      cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
       cmd.run_command
       cmd.error!
-      ui.info "Berks cookbook upload complete!"
+    end
+    
+    def berks_upload
+      ui.info 'Cookbooks being uploaded via berks'
+      berk_uploader = Uploader::Berkshelf.new(
+        vagabondfile.directory, options.merge(
+          :ui => ui,
+          :berksfile => File.join(vagabondfile.directory, vagabondfile[:local_chef_server][:berkshelf][:path] || 'Berksfile'),
+          :chef_server_url => options[:knife_opts].to_s.split(' ').last,
+          :berks_opts => vagabondfile[:local_chef_server][:berkshelf][:options]
+        )
+      )
+      berk_uploader.upload
     end
 
+    def librarian_upload
+      ui.info 'Cookbooks being uploaded with librarian'
+      librarian_uploader = Uploader::Librarian.new(
+        vagabondfile.generate_store_path, options.merge(
+          :ui => ui,
+          :cheffile => File.join(vagabondfile.directory, 'Cheffile')
+        )
+      )
+      librarian_uploader.upload
+    end
+    
     def raw_upload
-      com = "knife cookbook upload#{options[:knife_opts]} --all"
-      debug(com)
-      cmd = Mixlib::ShellOut.new(com, :live_stream => options[:debug])
-      cmd.run_command
-      cmd.error!
-      ui.info "Cookbook upload complete!"
+      ui.info 'Cookbooks being uploaded via knife'
+      knife_uploader = Uploader::Knife.new(vagabondfile.directory, options.merge(:ui => ui))
+      knife_uploader.upload
     end
 
   end