vanagon 0.15.37 → 0.18.0

data/resources/osx/postinstall.erb

@@ -5,7 +5,7 @@
 <%- get_configfiles.each do |config|
 dest_file = config.path.gsub(/\.pristine$/, '') -%>
 
-if [ -f "<%= dest_file %>" ]; then
+if [ -f "<%= dest_file %>" ] && ! diff "<%= config.path %>" "<%= dest_file %>" > /dev/null; then
   echo "Detected file at '<%= dest_file %>'; updated file at '<%= config.path %>'."
 else
   mv '<%= config.path %>' '<%= dest_file %>'

data/resources/solaris/10/postinstall.erb

@@ -9,7 +9,7 @@
 <%- get_configfiles.each do |config|
 dest_file = config.path.gsub(/\.pristine$/, '') -%>
 
-if [ -f "<%= dest_file %>" ]; then
+if [ -f "<%= dest_file %>" ] && ! diff "<%= config.path %>" "<%= dest_file %>" > /dev/null; then
   echo "Detected file at '<%= dest_file %>'; updated file at '<%= config.path %>'."
 else
   cp -pr '<%= config.path %>' '<%= dest_file %>'

data/spec/lib/vanagon/cli_spec.rb

@@ -0,0 +1,226 @@
+require 'vanagon/cli'
+
+##
+## Ignore the CLI calling 'exit'
+##
+RSpec.configure do |rspec|
+  rspec.around(:example) do |ex|
+    begin
+      ex.run
+    rescue SystemExit => e
+      puts "Got SystemExit: #{e.inspect}. Ignoring"
+    end
+  end
+end
+
+describe Vanagon::CLI do
+  describe "options that don't take a value" do
+    [:skipcheck, :verbose].each do |flag|
+      it "can create an option parser that accepts the #{flag} flag" do
+        subject = described_class.new
+        expect(subject.parse(%W[build --#{flag} project platform])).to have_key(flag)
+      end
+    end
+
+    describe "short options" do
+      [["v", :verbose]].each do |short, long|
+        it "maps the short option #{short} to #{long}" do
+          subject = described_class.new
+          expect(subject.parse(%W[build -#{short} project platform])).to include(long => true)
+        end
+      end
+    end
+  end
+
+  describe "options that only allow limited values" do
+    [[:preserve, ["always", "never", "on-failure"]]].each do |option, values|
+      values.each do |value|
+        it "can create a parser that accepts \"--#{option} #{value}\"" do
+          subject = described_class.new
+          expect(subject.parse(%W[build --#{option} #{value} project platform]))
+            .to include(option => value.to_sym)
+        end
+      end
+    end
+    [[:preserve, ["bad-argument"]]].each do |option, values|
+      values.each do |value|
+        it "rejects the bad argument \"--#{option} #{value}\"" do
+          subject = described_class.new
+          expect{subject.parse(%W[build --#{option} #{value} project platform])}
+            .to raise_error(Vanagon::InvalidArgument)
+        end
+      end
+    end
+    it "preserve defaults to :on-failure" do
+      subject = described_class.new
+      expect(subject.parse([])).to include(:preserve => :'on-failure')
+    end
+  end
+
+
+  describe "options that take a value" do
+    [:workdir, :configdir, :engine].each do |option|
+      it "can create an option parser that accepts the #{option} option" do
+        subject = described_class.new
+        expect(subject.parse(%W[build --#{option} hello project platform]))
+          .to include(option => "hello")
+      end
+    end
+
+    describe "short options" do
+      [["w", :workdir], ["c", :configdir], ["e", :engine]].each do |short, long|
+        it "maps the short option #{short} to #{long}" do
+          subject = described_class.new
+          expect(subject.parse(%W[build -#{short} hello project platform]))
+            .to include(long => "hello")
+        end
+      end
+    end
+  end
+end
+
+describe Vanagon::CLI::List do 
+  let(:cli) { Vanagon::CLI::List.new }
+  
+  describe "#output" do 
+      let(:list) { ['a', 'b', 'c']}
+      it "returns an array if space is false" do 
+          expect(cli.output(list, false)).to eq(list)
+      end 
+      it "returns space separated if space is true" do 
+          expect(cli.output(list, true)).to eq('a b c')
+      end 
+  end
+
+  describe "#run" do 
+    let(:projects){ ['foo', 'bar', 'baz'] }
+    let(:platforms){ ['1', '2', '3'] }
+    let(:output_both){
+"- Projects
+foo
+bar
+baz
+
+- Platforms
+1
+2
+3
+"
+}
+    context "specs with standard config path" do
+      before(:each) do
+        expect(Dir).to receive(:exist?)
+          .with("#{File.join(Dir.pwd, 'configs', 'platforms')}")
+          .and_return(true)
+        expect(Dir).to receive(:exist?)
+          .with("#{File.join(Dir.pwd, 'configs', 'projects')}")
+          .and_return(true)
+        expect(Dir).to receive(:children)
+          .with("#{File.join(Dir.pwd, 'configs', 'projects')}")
+          .and_return(projects)
+        expect(Dir).to receive(:children)
+          .with("#{File.join(Dir.pwd, 'configs', 'platforms')}")
+          .and_return(platforms)
+      end
+      let(:options_empty) { {
+        nil=>false, 
+        :configdir=>"#{Dir.pwd}/configs", 
+        :platforms=>false, 
+        :projects=>false, 
+        :use_spaces=>false
+      } }
+      let(:options_platforms_only) { {
+        nil=>false, 
+        :configdir=>"#{Dir.pwd}/configs", 
+        :platforms=>true, 
+        :projects=>false, 
+        :use_spaces=>false
+      } }
+      let(:options_projects_only) { {
+        nil=>false, 
+        :configdir=>"#{Dir.pwd}/configs", 
+        :platforms=>false, 
+        :projects=>true, 
+        :use_spaces=>false
+      } }
+      let(:options_space_only) { {
+        nil=>false, 
+        :configdir=>"#{Dir.pwd}/configs", 
+        :platforms=>false, 
+        :projects=>false, 
+        :use_spaces=>true
+      } }
+
+      it "outputs projects and platforms with no options passed" do 
+        expect do
+          cli.run(options_empty)
+        end.to output(output_both).to_stdout
+      end
+      
+      let(:output_both_space){
+"- Projects
+foo bar baz
+
+- Platforms
+1 2 3
+"
+  }
+      it "outputs projects and platforms space separated" do 
+        expect do
+          cli.run(options_space_only)
+        end.to output(output_both_space).to_stdout
+      end
+
+      let(:output_platforms){
+"- Platforms
+1
+2
+3
+"
+}
+      it "outputs only platforms when platforms is passed" do 
+        expect do
+          cli.run(options_platforms_only)
+        end.to output(output_platforms).to_stdout
+      end
+
+      let(:output_projects){
+"- Projects
+foo
+bar
+baz
+"
+}
+      it "outputs only projects when projects is passed" do 
+        expect do
+          cli.run(options_projects_only)
+        end.to output(output_projects).to_stdout
+      end
+    end
+
+    context "spec with a configdir specified" do
+      let(:options_configdir) { {
+        nil=>false, 
+        :configdir=> '/configs', 
+        :platforms=>false, 
+        :projects=>false, 
+        :use_spaces=>false} }
+      it "it successfully takes the configs directory" do 
+        expect(Dir).to receive(:exist?).with('/configs' + '/platforms')
+          .and_return(true)
+        expect(Dir).to receive(:exist?).with('/configs' + '/projects')
+          .and_return(true)
+        expect(Dir).to receive(:children).with('/configs' + '/projects')
+          .and_return(projects)
+        expect(Dir).to receive(:children).with('/configs' + '/platforms')
+          .and_return(platforms)
+        expect do
+          cli.run(options_configdir)
+        end.to output(output_both).to_stdout
+      end
+    end
+  end
+end
+
+      
+

data/spec/lib/vanagon/driver_spec.rb

@@ -50,7 +50,7 @@ describe 'Vanagon::Driver' do
       info = create_driver(redhat).build_host_info
 
       expect(info).to match({ 'name'   => 'centos-7-x86_64',
-                              'engine' => 'pooler' })
+                              'engine' => 'always_be_scheduling' })
     end
 
     it 'returns the vmpooler template with an explicit engine' do

data/spec/lib/vanagon/engine/always_be_scheduling_spec.rb

@@ -2,6 +2,7 @@ require 'vanagon/engine/always_be_scheduling'
 require 'vanagon/driver'
 require 'vanagon/platform'
 require 'logger'
+require 'spec_helper'
 
 class Vanagon
   class Driver
@@ -45,6 +46,8 @@ describe 'Vanagon::Engine::AlwaysBeScheduling' do
                     end")
     plat._platform
   }
+  let(:pooler_token_file) { File.expand_path('~/.vanagon-token') }
+  let(:floaty_config) { File.expand_path('~/.vmfloaty.yml') }
 
   describe '#validate_platform' do
     it 'returns true if the platform has the required attributes' do
@@ -81,4 +84,113 @@ describe 'Vanagon::Engine::AlwaysBeScheduling' do
         .to eq('always_be_scheduling')
     end
   end
-end
+
+  describe '#read_vanagon_token' do
+    it 'takes the first line for abs token, second line is optional' do
+      token_value = 'decade'
+      allow(File).to receive(:exist?)
+                         .with(pooler_token_file)
+                         .and_return(true)
+
+      allow(File).to receive(:read)
+                         .with(pooler_token_file)
+                         .and_return(token_value)
+
+      abs_service = Vanagon::Engine::AlwaysBeScheduling.new(platform, nil)
+      expect(abs_service.token).to eq('decade')
+      expect(abs_service.token_vmpooler).to eq(nil)
+    end
+    it 'takes the second line as vmpooler token' do
+      token_value = "decade\nanddaycade"
+      allow(File).to receive(:exist?)
+                         .with(pooler_token_file)
+                         .and_return(true)
+
+      allow(File).to receive(:read)
+                         .with(pooler_token_file)
+                         .and_return(token_value)
+
+      abs_service = Vanagon::Engine::AlwaysBeScheduling.new(platform, nil)
+      expect(abs_service.token).to eq('decade')
+      expect(abs_service.token_vmpooler).to eq('anddaycade')
+    end
+  end
+
+  describe '#read_vmfloaty_token' do
+    before :each do
+      allow(File).to receive(:exist?)
+                         .with(pooler_token_file)
+                         .and_return(false)
+
+      allow(File).to receive(:exist?)
+                         .with(floaty_config)
+                         .and_return(true)
+    end
+    token_value = 'decade'
+    it %(reads a token from '~/.vmfloaty.yml at the top level') do
+      allow(YAML).to receive(:load_file)
+                         .with(floaty_config)
+                         .and_return({'token' => token_value})
+
+      abs_service = Vanagon::Engine::AlwaysBeScheduling.new(platform, nil)
+      expect(abs_service.token).to eq(token_value)
+      expect(abs_service.token_vmpooler).to eq(nil)
+    end
+    it %(reads a token from '~/.vmfloaty.yml in the abs service') do
+      allow(YAML).to receive(:load_file)
+                         .with(floaty_config)
+                         .and_return({'services' =>
+                                          {'MYabs' => {'type'=>'abs', 'token'=>token_value, 'url'=>'foo'}}
+                                     })
+
+      abs_service = Vanagon::Engine::AlwaysBeScheduling.new(platform, nil)
+      expect(abs_service.token).to eq(token_value)
+      expect(abs_service.token_vmpooler).to eq(nil)
+    end
+    it %(reads a token from '~/.vmfloaty.yml in the abs service and includes the vmpooler token') do
+      vmp_token_value = 'deecade'
+      allow(YAML).to receive(:load_file)
+                         .with(floaty_config)
+                         .and_return({'services' =>
+                                          {'MYabs' => {'type'=>'abs', 'token'=>token_value, 'url'=>'foo', 'vmpooler_fallback' => 'myvmp'},
+                                           'myvmp' => {'token'=>vmp_token_value, 'url'=>'bar'}}
+                                     })
+
+      abs_service = Vanagon::Engine::AlwaysBeScheduling.new(platform, nil)
+      expect(abs_service.token).to eq(token_value)
+      expect(abs_service.token_vmpooler).to eq(vmp_token_value)
+    end
+  end
+  describe '#select_target_from' do
+    it 'runs successfully' do
+      hostname = 'faint-whirlwind.puppet.com'
+      stub_request(:post, "https://foobar/request").
+          to_return({status: 202, body: "", headers: {}},{status: 200, body: '[{"hostname":"'+hostname+'","type":"aix-6.1-ppc","engine":"nspooler"}]', headers: {}})
+      abs_service = Vanagon::Engine::AlwaysBeScheduling.new(platform, nil)
+      abs_service.select_target_from("https://foobar")
+      expect(abs_service.target).to eq(hostname)
+    end
+    it 'returns a warning if the first request is not a 202' do
+      hostname = 'fainter-whirlwind.puppet.com'
+      stub_request(:post, "https://foobar/request").
+          to_return({status: 404, body: "", headers: {}},{status: 200, body: '[{"hostname":"'+hostname+'","type":"aix-6.1-ppc","engine":"nspooler"}]', headers: {}})
+      allow_any_instance_of(Object).to receive(:warn)
+      expect_any_instance_of(Object).to receive(:warn).with("failed to request ABS with code 404")
+      abs_service = Vanagon::Engine::AlwaysBeScheduling.new(platform, nil)
+      pooler = abs_service.select_target_from("https://foobar")
+      expect(pooler).to eq('')
+    end
+    it 'returns a warning and retries until request is a 200' do
+      hostname = 'faintest-whirlwind.puppet.com'
+      stub_request(:post, "https://foobar/request").
+          to_return({status: 202, body: "", headers: {}},
+                    {status: 503, body: "", headers: {}},
+                    {status: 200, body: '[{"hostname":"'+hostname+'","type":"aix-6.1-ppc","engine":"nspooler"}]', headers: {}})
+      allow_any_instance_of(Object).to receive(:warn)
+      expect_any_instance_of(Object).to receive(:warn).with(/Waiting 1 seconds to check if ABS request has been filled/)
+      abs_service = Vanagon::Engine::AlwaysBeScheduling.new(platform, nil)
+      abs_service.select_target_from("https://foobar")
+      expect(abs_service.target).to eq(hostname)
+    end
+  end
+end

data/spec/lib/vanagon/engine/docker_spec.rb

@@ -1,21 +1,36 @@
 require 'vanagon/engine/docker'
 require 'vanagon/platform'
 
-describe 'Vanagon::Engine::Docker' do
-  let (:platform_with_docker_image) {
-    plat = Vanagon::Platform::DSL.new('debian-6-i386')
-    plat.instance_eval("platform 'debian-6-i386' do |plat|
-                      plat.docker_image 'debian-6-i386'
-                    end")
+describe Vanagon::Engine::Docker do
+  let (:platform_with_docker_image) do
+    plat = Vanagon::Platform::DSL.new('debian-10-amd64')
+    plat.instance_eval(<<~EOF)
+      platform 'debian-10-amd64' do |plat|
+        plat.docker_image 'debian:10-slim'
+      end
+    EOF
     plat._platform
-  }
+  end
 
-  let (:platform_without_docker_image) {
-    plat = Vanagon::Platform::DSL.new('debian-6-i386')
-    plat.instance_eval("platform 'debian-6-i386' do |plat|
-                    end")
+  let (:platform_without_docker_image) do
+    plat = Vanagon::Platform::DSL.new('debian-10-amd64')
+    plat.instance_eval(<<~EOF)
+      platform 'debian-10-amd64' do |plat|
+      end
+    EOF
+    plat._platform
+  end
+
+  let(:platform_with_docker_exec) do
+    plat = Vanagon::Platform::DSL.new('debian-10-amd64')
+    plat.instance_eval(<<~EOF)
+      platform 'debian-10-amd64' do |plat|
+        plat.docker_image 'debian:10-slim'
+        plat.use_docker_exec true
+      end
+    EOF
     plat._platform
-  }
+  end
 
   describe '#initialize' do
     it 'fails without docker installed' do
@@ -23,24 +38,67 @@ describe 'Vanagon::Engine::Docker' do
         expect(FileTest).to receive(:executable?).with(File.join(path_elem, 'docker')).and_return(false)
       end
 
-      expect { Vanagon::Engine::Docker.new(platform_with_docker_image) }.to raise_error(RuntimeError)
+      expect { described_class.new(platform_with_docker_image) }.to raise_error(RuntimeError)
     end
   end
 
   describe "#validate_platform" do
     it 'raises an error if the platform is missing a required attribute' do
       expect(Vanagon::Utilities).to receive(:find_program_on_path).with('docker').and_return('/usr/bin/docker')
-      expect { Vanagon::Engine::Docker.new(platform_without_docker_image).validate_platform }.to raise_error(Vanagon::Error)
+      expect { described_class.new(platform_without_docker_image).validate_platform }.to raise_error(Vanagon::Error)
     end
 
     it 'returns true if the platform has the required attributes' do
       expect(Vanagon::Utilities).to receive(:find_program_on_path).with('docker').and_return('/usr/bin/docker')
-      expect(Vanagon::Engine::Docker.new(platform_with_docker_image).validate_platform).to be(true)
+      expect(described_class.new(platform_with_docker_image).validate_platform).to be(true)
     end
   end
 
   it 'returns "docker" name' do
     expect(Vanagon::Utilities).to receive(:find_program_on_path).with('docker').and_return('/usr/bin/docker')
-    expect(Vanagon::Engine::Docker.new(platform_with_docker_image).name).to eq('docker')
+    expect(described_class.new(platform_with_docker_image).name).to eq('docker')
+  end
+
+  describe '#dispatch' do
+    context 'when platform has use_docker_exec set' do
+      subject { described_class.new(platform_with_docker_exec) }
+
+      it 'uses docker exec' do
+        expect(Vanagon::Utilities).to receive(:remote_ssh_command).never
+        expect(subject).to receive(:docker_exec)
+
+        subject.dispatch('true', true)
+      end
+    end
+  end
+
+  describe '#ship_workdir' do
+    context 'when platform has use_docker_exec set' do
+      subject { described_class.new(platform_with_docker_exec) }
+
+      it 'uses docker cp' do
+        expect(Vanagon::Utilities).to receive(:rsync_to).never
+        expect(subject).to receive(:docker_cp_globs_to)
+
+        subject.ship_workdir('foo/')
+      end
+    end
+  end
+
+  describe '#retrieve_built_artifact' do
+    context 'when platform has use_docker_exec set' do
+      subject { described_class.new(platform_with_docker_exec) }
+
+      before(:each) do
+        allow(FileUtils).to receive(:mkdir_p)
+      end
+
+      it 'uses docker cp' do
+        expect(Vanagon::Utilities).to receive(:rsync_from).never
+        expect(subject).to receive(:docker_cp_globs_from)
+
+        subject.retrieve_built_artifact('output/*', false)
+      end
+    end
   end
 end