pennyworth-tool 0.0.1

data/spec/import_base_command_spec.rb

@@ -0,0 +1,189 @@
+# Copyright (c) 2013-2014 SUSE LLC
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of version 3 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE about this file by physical or electronic mail,
+# you may find current contact information at www.suse.com
+
+require "spec_helper.rb"
+
+describe Pennyworth::ImportBaseCommand do
+
+  before(:all) do
+    Pennyworth::Cli.settings = Pennyworth::Settings.new
+    Pennyworth::Cli.settings.definitions_dir = test_data_dir
+  end
+
+  before(:each) do
+    stub_request(:get, /example.com.*import_state.yaml/).
+      with(headers: {'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
+      to_return(status: 200, body: File.read(File.join(test_data_dir,
+        "/kiwi5/import_state.yaml")), headers: {})
+  end
+
+  context "without box state file" do
+    before(:each) do
+      @kiwi_dir = File.join(test_data_dir, "kiwi")
+      @cmd = Pennyworth::ImportBaseCommand.new(@kiwi_dir, "http://example.com/pennyworth/")
+      allow(Pennyworth::Libvirt).to receive(:ensure_libvirt_env_started)
+      allow(@cmd).to receive(:log)
+      allow(@cmd).to receive(:write_import_state_file) # Don't write state
+    end
+
+    it "imports a local box" do
+      expect(@cmd).to receive(:base_image_clean).with("base_opensuse12.3_kvm")
+      expect_any_instance_of(Pennyworth::Vagrant).to receive(:run).with("box", "add",
+        "base_opensuse12.3_kvm", "#{@kiwi_dir}/base_opensuse12.3_kvm.box",
+        "--force")
+
+      @cmd.execute("base_opensuse12.3_kvm", :local => true)
+    end
+
+    it "imports a remote box" do
+      allow(@cmd).to receive(:fetch_remote_box_state_file)
+
+      expect(@cmd).to receive(:base_image_clean).with("base_opensuse13.1_kvm")
+      expect_any_instance_of(Pennyworth::Vagrant).to receive(:run).with("box", "add",
+        "base_opensuse13.1_kvm",
+        "http://example.com/pennyworth/base_opensuse13.1_kvm.box", "--force")
+
+      @cmd.execute("base_opensuse13.1_kvm")
+    end
+
+    context "url checks" do
+      before(:each) do
+        @box_state_get = stub_request(:get, /example.com\/pennyworth\/box_state.yaml/)
+      end
+
+      it "fetches the box state file from an url with a trailing slash" do
+        cmd = Pennyworth::ImportBaseCommand.new(@kiwi_dir, "http://example.com/pennyworth/")
+        cmd.read_remote_box_state_file()
+
+        assert_requested(@box_state_get)
+      end
+
+      it "fetches the box state file from an url without a trailing slash" do
+        cmd = Pennyworth::ImportBaseCommand.new(@kiwi_dir, "http://example.com/pennyworth")
+        cmd.read_remote_box_state_file()
+
+        assert_requested(@box_state_get)
+      end
+    end
+  end
+
+  context "with box state file" do
+    before(:each) do
+      @kiwi_dir = File.join(test_data_dir, "kiwi2")
+      @cmd = Pennyworth::ImportBaseCommand.new(@kiwi_dir)
+      allow(Pennyworth::Libvirt).to receive(:ensure_libvirt_env_started)
+      allow(@cmd).to receive(:log)
+      allow(@cmd).to receive(:fetch_remote_box_state_file).and_return(
+        File.read(File.join(@kiwi_dir, "box_state.yaml")))
+    end
+
+    it "writes import state file" do
+      allow(@cmd).to receive(:base_image_clean)
+      allow(@cmd).to receive(:vagrant)
+      allow_any_instance_of(Pennyworth::Vagrant).to receive(:run)
+
+      import_state_file = File.join(@kiwi_dir, "import_state.yaml")
+
+      FileUtils.rm(import_state_file) if File.exist?(import_state_file)
+
+      @cmd.execute("base_opensuse13.1_kvm", :local => true)
+      @cmd.execute("base_opensuse12.3_kvm", :local => true)
+
+      expected_content = <<-EOT
+---
+base_opensuse13.1_kvm: 115469c104dcc69455f321eb086ffb11
+base_opensuse12.3_kvm: e4e743b5340686d8488dbce54b5644d8
+      EOT
+
+      expect(File.read(import_state_file)).to eq expected_content
+
+      FileUtils.rm(import_state_file) if File.exist?(import_state_file)
+    end
+
+    it "reads remote box state file" do
+      box_state = @cmd.read_remote_box_state_file
+
+      expect(box_state["base_opensuse12.3_kvm"]["sources"]["config.sh"]).to eq(
+        "c6640ba00ab345b7491b836d517a637b")
+      expect(box_state["base_opensuse13.1_kvm"]["target"]).to eq(
+        "115469c104dcc69455f321eb086ffb11")
+    end
+  end
+
+  context "with box and import state files" do
+    before(:each) do
+      @kiwi_dir = File.join(test_data_dir, "kiwi3")
+      @cmd = Pennyworth::ImportBaseCommand.new(@kiwi_dir, "http://example.com/pennyworth/")
+      allow(Pennyworth::Libvirt).to receive(:ensure_libvirt_env_started)
+      allow(@cmd).to receive(:log)
+      allow(@cmd).to receive(:write_import_state_file) # Don't write state
+      allow(@cmd).to receive(:fetch_remote_box_state_file).and_return(
+        File.read(File.join(@kiwi_dir, "box_state.yaml")))
+    end
+
+    it "imports changed local box" do
+      expect(@cmd).to receive(:base_image_clean)
+      expect_any_instance_of(Pennyworth::Vagrant).to receive(:run)
+
+      @cmd.execute("base_opensuse12.3_kvm", :local => true)
+    end
+
+    it "doesn't import unchanged local box" do
+      expect(@cmd).to_not receive(:base_image_clean)
+      expect_any_instance_of(Pennyworth::Vagrant).to_not receive(:run)
+
+      @cmd.execute("base_opensuse13.1_kvm", :local => true)
+    end
+
+    it "imports changed remote box" do
+      expect(@cmd).to receive(:base_image_clean)
+      expect_any_instance_of(Pennyworth::Vagrant).to receive(:run)
+
+      @cmd.execute("base_opensuse13.2_kvm")
+    end
+
+    it "doesn't import unchanged remote box" do
+      expect(@cmd).to_not receive(:base_image_clean)
+      expect_any_instance_of(Pennyworth::Vagrant).to_not receive(:run)
+
+      @cmd.execute("base_opensuse13.1_kvm")
+    end
+  end
+
+  context "without box state, but with import state files" do
+    before(:each) do
+      @kiwi_dir = File.join(test_data_dir, "kiwi4")
+      @cmd = Pennyworth::ImportBaseCommand.new(@kiwi_dir)
+      allow(Pennyworth::Libvirt).to receive(:ensure_libvirt_env_started)
+      allow(@cmd).to receive(:log)
+    end
+
+    it "removes imported state after import" do
+      expect(@cmd).to receive(:base_image_clean)
+      expect_any_instance_of(Pennyworth::Vagrant).to receive(:run)
+
+      import_state = @cmd.read_import_state_file
+      expect(import_state["base_opensuse13.1_kvm"]).to eq "115469c104dcc69455f321eb086ffb11"
+
+      expect(@cmd).to receive(:write_import_state_file).with(
+        {"base_opensuse13.1_kvm"=>nil, "base_opensuse12.3_kvm"=>"old_hash"}
+      )
+
+      @cmd.execute("base_opensuse13.1_kvm", :local => true)
+    end
+  end
+end

data/spec/local_command_runner_spec.rb

@@ -0,0 +1,117 @@
+# Copyright (c) 2013-2014 SUSE LLC
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of version 3 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE about this file by physical or electronic mail,
+# you may find current contact information at www.suse.com
+
+require "spec_helper"
+
+include GivenFilesystemSpecHelpers
+
+describe Pennyworth::LocalCommandRunner do
+  use_given_filesystem
+  let(:command_runner) { Pennyworth::LocalCommandRunner.new }
+
+  it_behaves_like "a command runner"
+
+  describe "#run" do
+    it "executes commands via Cheetah" do
+      expect(Cheetah).to receive(:run).with("bash", "-c", "foo bar", stdout: :capture)
+
+      command_runner.run("foo bar", stdout: :capture)
+    end
+
+    it "prepends the env variable to the command" do
+      runner = Pennyworth::LocalCommandRunner.new(
+        env: {
+          "MACHINERY_DIR" => "/tmp"
+        }
+      )
+      expect(runner).to receive(:with_env).with("MACHINERY_DIR" => "/tmp").and_call_original
+      expect(Cheetah).to receive(:run).with("bash", "-c", "foo bar", stdout: :capture)
+
+      runner.run("foo bar", stdout: :capture)
+    end
+  end
+
+  describe "#extract_file" do
+    before(:each) do
+      @source_file = given_dummy_file "example.file"
+      @target = given_directory
+      @expected_file = File.join(@target, "example.file")
+    end
+
+    it "extracts the file" do
+      command_runner.extract_file(@source_file, @target)
+
+      expect(File.exists?(File.join(@target, "example.file"))).to be(true)
+    end
+  end
+
+  describe "#inject_file" do
+    before(:each) do
+      @source_file = given_dummy_file "example.file"
+      @target = given_directory
+      @expected_file = File.join(@target, "example.file")
+    end
+
+    it "injects the file" do
+      command_runner.inject_file(@source_file, @target)
+      expect(File.exists?(File.join(@target, "example.file"))).to be(true)
+    end
+
+    it "copies the file and sets the owner" do
+      expect(FileUtils).to receive(:chown).with("tux", nil, @expected_file)
+
+      command_runner.inject_file(@source_file, @target, owner: "tux")
+    end
+
+    it "copies the file and sets the group" do
+      expect(FileUtils).to receive(:chown).with(nil, "tux", @expected_file)
+
+      command_runner.inject_file(@source_file, @target, group: "tux")
+    end
+
+    it "copies the file and sets the mode" do
+      expect(FileUtils).to receive(:chmod).with("600", @expected_file)
+
+      command_runner.inject_file(@source_file, @target, mode: "600")
+    end
+  end
+
+  describe "#inject_directory" do
+    before(:each) do
+      @source_dir = given_directory do
+        @source_file = given_dummy_file "example.file"
+      end
+
+      @target = given_directory
+      @expected_dir = File.join(@target, File.basename(@source_dir))
+      @expected_file = File.join(@target, File.basename(@source_dir), "example.file")
+    end
+
+    it "injects the directory" do
+      command_runner.inject_directory(@source_dir, @target)
+
+      expect(Dir.exists?(@expected_dir)).to be(true)
+      expect(File.exists?(@expected_file)).to be(true)
+    end
+
+    it "copies the directory and sets the user and group" do
+      expect(FileUtils).to receive(:chown_R).with("user", "group", @target)
+
+      command_runner.inject_directory(@source_dir, @target, owner: "user", group: "group")
+    end
+  end
+end

data/spec/local_runner_spec.rb

@@ -0,0 +1,42 @@
+# Copyright (c) 2013-2014 SUSE LLC
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of version 3 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE about this file by physical or electronic mail,
+# you may find current contact information at www.suse.com
+
+require "spec_helper"
+
+describe Pennyworth::LocalRunner do
+  let(:runner) {
+    Pennyworth::LocalRunner.new
+  }
+
+  it_behaves_like "a runner"
+
+  describe "#command_runner" do
+    it "returns a LocalCommandRunner" do
+      expect(runner.command_runner).to be_a(Pennyworth::LocalCommandRunner)
+    end
+
+    it "forwards the :env and :command_map options to the LocalCommandRunner" do
+      opts = {
+        env: { "FOO" => "BAR" },
+        command_map: { "foo" => "/bar" }
+      }
+      expect(Pennyworth::LocalCommandRunner).to receive(:new).with(opts)
+
+      Pennyworth::LocalRunner.new(opts).command_runner
+    end
+  end
+end

data/spec/lock_service_spec.rb

@@ -0,0 +1,95 @@
+# Copyright (c) 2015 SUSE LLC
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of version 3 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE about this file by physical or electronic mail,
+# you may find current contact information at www.suse.com
+
+require "spec_helper"
+
+describe Pennyworth::LockService do
+  let(:lock_service) { Pennyworth::LockService.new("lock.example.com:9999") }
+
+  it "creates lock object" do
+    expect(lock_service.lock_server_host).to eq("lock.example.com")
+    expect(lock_service.lock_server_port).to eq("9999")
+  end
+
+  it "acquires lock" do
+    socket = double
+    expect(TCPSocket).to receive(:new).and_return(socket)
+    expect(socket).to receive(:puts).with("g my_test")
+    expect(socket).to receive(:gets).
+      and_return("1 Lock Get Success: my_test")
+
+    expect(lock_service.request_lock("my_test")).to be(true)
+  end
+
+  it "fails to acquire lock" do
+    socket = double
+    expect(TCPSocket).to receive(:new).and_return(socket)
+    expect(socket).to receive(:puts).with("g my_test")
+    expect(socket).to receive(:gets).
+      and_return("0 Lock Get Failure: my_test")
+
+    expect(lock_service.request_lock("my_test")).to be(false)
+  end
+
+  it "fails to release non-existing lock" do
+    expect {
+      lock_service.release_lock("inexisting lock")
+    }.to raise_error(Pennyworth::LockError)
+  end
+
+  it "releases lock" do
+    socket = double
+    expect(TCPSocket).to receive(:new).and_return(socket)
+    expect(socket).to receive(:puts).with("g my_test")
+    expect(socket).to receive(:gets).
+      and_return("1 Lock Get Success: my_test")
+
+    expect(lock_service.request_lock("my_test")).to be(true)
+
+    expect(socket).to receive(:close)
+
+    lock_service.release_lock("my_test")
+  end
+
+  it "returns locked status" do
+    socket = double
+    expect(TCPSocket).to receive(:new).and_return(socket)
+
+    expect(socket).to receive(:puts).with("i my_test")
+    expect(socket).to receive(:gets).
+      and_return("1 Lock Is Locked: my_test")
+
+    expect(socket).to receive(:puts).with("d my_test")
+    expect(socket).to receive(:gets).
+      and_return("my_test: 172.16.254.1:49716")
+
+    expect(lock_service.info("my_test")).
+      to eq "'my_test' is locked by 172.16.254.1"
+  end
+
+  it "returns unlocked status" do
+    socket = double
+    expect(TCPSocket).to receive(:new).and_return(socket)
+
+    expect(socket).to receive(:puts).with("i my_test")
+    expect(socket).to receive(:gets).
+      and_return("0 Lock Not Locked: my_test")
+
+    expect(lock_service.info("my_test")).
+      to eq "'my_test' is not locked"
+  end
+end

data/spec/remote_command_runner_spec.rb

@@ -0,0 +1,115 @@
+# Copyright (c) 2013-2014 SUSE LLC
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of version 3 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE about this file by physical or electronic mail,
+# you may find current contact information at www.suse.com
+
+require "spec_helper"
+
+describe Pennyworth::RemoteCommandRunner do
+  let(:ssh_output) { "-rw-r--r-- 1 root root 642 Sep 27 22:06 /etc/hosts" }
+  let(:command_runner) { Pennyworth::RemoteCommandRunner.new("1.2.3.4", "root") }
+
+  it_behaves_like "a command runner"
+
+  describe "#run" do
+    it "calls ssh and returns the command's standard output" do
+      expect(Cheetah).to receive(:run).
+        and_return(ssh_output)
+
+      output = command_runner.run("ls", "-l", "/etc/hosts", stdout: :capture)
+
+      expect(output).to eq (ssh_output)
+    end
+
+    it "executes commands as given user" do
+      expect(Cheetah).to receive(:run).
+        with(
+        "ssh", "-o", "UserKnownHostsFile=/dev/null", "-o", "StrictHostKeyChecking=no",
+        "root@1.2.3.4", "LC_ALL=C", "su", "-l", "vagrant", "-c", "ls", "-l", "/etc/hosts",
+        stdout: :capture).
+        and_return(ssh_output)
+
+      output = command_runner.run("ls", "-l", "/etc/hosts", as: "vagrant", stdout: :capture)
+
+      expect(output).to eq (ssh_output)
+    end
+
+    it "raises ExecutionFailed in case of errors" do
+      expect(Cheetah).to receive(:run).and_raise(Cheetah::ExecutionFailed.new(nil, nil, nil, nil))
+
+      expect {
+        command_runner.run("foo")
+      }.to raise_error(Pennyworth::ExecutionFailed)
+    end
+  end
+
+  describe "#extract_file" do
+    it "calls scp with source and destination as arguments" do
+      expect(Cheetah).to receive(:run)
+
+      command_runner.extract_file("/etc/hosts", "/tmp")
+    end
+  end
+
+  describe "#inject_file" do
+    it "calls scp with source and destination as arguments" do
+      expect(Cheetah).to receive(:run)
+
+      command_runner.inject_file("/tmp/hosts", "/etc")
+    end
+
+    it "copies the file and sets the owner" do
+      expect(Cheetah).to receive(:run) { |*args| expect(args).to include(/scp/) }
+      expect(Cheetah).to receive(:run) { |*args| expect(args.join(" ")).to match(/chown.*tux/) }
+
+      command_runner.inject_file("/tmp/hosts", "/etc", owner: "tux")
+    end
+
+    it "copies the file and sets the group" do
+      expect(Cheetah).to receive(:run) { |*args| expect(args).to include(/scp/) }
+      expect(Cheetah).to receive(:run) { |*args| expect(args.join(" ")).to match(/chown.*:tux/) }
+
+      command_runner.inject_file("/tmp/hosts", "/etc", group: "tux")
+    end
+
+    it "copies the file and sets the mode" do
+      expect(Cheetah).to receive(:run) { |*args| expect(args).to include(/scp/) }
+      expect(command_runner).to receive(:run) do |*args|
+        expect(args.join(" ")).to include("chmod 600")
+      end
+
+      command_runner.inject_file("/tmp/hosts", "/etc", mode: "600")
+    end
+  end
+
+  describe "#inject_directory" do
+    it "calls scp with source and destination as arguments" do
+      expect(Cheetah).to receive(:run) { |*args| expect(args).to include(/mkdir -p/) }
+      expect(Cheetah).to receive(:run) { |*args| expect(args).to include(/scp/) }
+
+      command_runner.inject_directory("/tmp/hosts", "/etc")
+    end
+
+    it "copies the directory and sets the user and group" do
+      expect(Cheetah).to receive(:run) { |*args| expect(args).to include(/mkdir -p/) }
+      expect(Cheetah).to receive(:run) { |*args| expect(args).to include(/scp/) }
+      expect(Cheetah).to receive(:run) do |*args|
+        expect(args.join(" ")).to include("chown -R user:group")
+      end
+
+      command_runner.inject_directory("/tmp/hosts", "/etc", owner: "user", group: "group")
+    end
+  end
+end