knife-lpar 0.0.3

data/lib/chef/knife/lpar_list.rb

@@ -0,0 +1,90 @@
+#
+# Author:: Julian C. Dunn (<jdunn@chef.io>)
+# Copyright:: Copyright (c) 2014-2016 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "chef/knife"
+require "chef/knife/lpar_base"
+
+class Chef
+  class Knife
+    class LparList < Knife
+      include Chef::Knife::LparBase
+
+      banner "knife lpar list HMC [options]"
+
+      option :virtual_server,
+        :short => "-v SERVER",
+        :long => "--virtual-server",
+        :description => "Virtual Server Name"
+
+      option :help,
+        :long => "--help",
+        :description => "Prints this menu"
+
+      #
+      # Run the plugin
+      #
+      def run
+        read_and_validate_params
+        @password = get_password
+        list_lpars
+      end
+
+      private
+
+      #
+      # Reads the input parameters and validates them.
+      # Will exit if it encounters an error
+      #
+      def read_and_validate_params
+        if @name_args.length < 1
+          show_usage
+          exit 1
+        end
+
+        if config[:virtual_server].nil?
+          show_usage
+          exit 1
+        end
+      end
+
+      def list_lpars
+        lpar_list = [
+            ui.color("LPAR ID", :bold),
+            ui.color("Type", :bold),
+            ui.color("Name", :bold),
+            ui.color("OS Version", :bold),
+        ].flatten.compact
+
+        output_column_count = lpar_list.length
+
+        Net::SSH.start(@name_args[0], "hscroot", :password => @password) do |ssh|
+
+          command = "lssyscfg -m #{config[:virtual_server]} -F lpar_id,lpar_env,name,os_version -r lpar"
+          output = run_remote_command(ssh, command)
+          output.each_line do |lpar|
+            lpar.split(",").each do |field|
+              lpar_list << field.chomp
+            end
+          end
+          puts "\n"
+          puts ui.list(lpar_list, :uneven_columns_across, output_column_count)
+        end
+      end
+    end
+  end
+end

data/lib/knife-lpar/version.rb

@@ -0,0 +1,5 @@
+module Knife
+  module Lpar
+    VERSION = "0.0.3"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+#
+# Copyright:: Copyright (c) 2014-2016 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+RSpec.configure do |c|
+
+  c.expect_with :rspec do |config|
+    config.syntax = [:should, :expect]
+  end
+  c.filter_run :focus => true
+  c.run_all_when_everything_filtered = true
+end

data/spec/unit/lpar_base_spec.rb

@@ -0,0 +1,58 @@
+#
+# Copyright:: Copyright (c) 2014-2016 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "chef/knife/lpar_base.rb"
+
+describe Chef::Knife::LparBase do
+  class Chef
+    class Knife
+      class DummyClass < Knife
+        include Knife::LparBase
+      end
+    end
+  end
+
+  subject(:dummy) do
+    Chef::Knife::DummyClass.new
+  end
+
+  describe "#print_with_output" do
+    it "should print the message when there is no extra output" do
+      expect(dummy.ui).to receive(:info).with("Message")
+      return_val = dummy.print_with_output("Message", nil)
+    end
+
+    it "should concatenate output to the message" do
+      expect(dummy.ui).to receive(:info).with("Message - with some output and whatnot")
+      return_val = dummy.print_with_output("Message", "with some output and whatnot")
+    end
+  end
+
+  describe "#run_remote_command" do
+    before(:each) do
+      @session = double(Net::SSH)
+    end
+
+    # Not sure how to do the stdout part
+    it "should return a value in :stdout" do
+      expect(dummy).to receive(:run_remote_command).and_call_original
+      expect(@session).to receive(:exec!).with("TestCommand")
+      dummy.run_remote_command(@session, "TestCommand")
+    end
+  end
+end

data/spec/unit/lpar_create_spec.rb

@@ -0,0 +1,197 @@
+#
+# Copyright:: Copyright (c) 2014-2016 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "chef/knife/lpar_create.rb"
+
+describe Chef::Knife::LparCreate do
+
+  subject(:knife) do
+    Chef::Knife::LparCreate.new(argv).tap do |c|
+      allow(c).to receive(:output).and_return(true)
+      c.parse_options(argv)
+      c.merge_configs
+    end
+  end
+
+  describe "#run" do
+
+    context "by default" do
+      let(:argv) { %w{ create serverurl -n fakename --vios fakevios --virtual-server fakevirt --disk fakedisk -p fakeprof } }
+
+      it "parses argv, gets password, and creates lpar" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password)
+        expect(knife).to receive(:create_lpar)
+        knife.run
+      end
+    end
+
+  end
+
+  describe "#read_and_validate_params" do
+
+    context "when argv is empty" do
+      let(:argv) { [] }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when the name parameter is missing" do
+      let(:argv) { %w{ create serverurl --vios fakevios --virtual-server fakevirt --disk fakedisk } }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when the vios parameter is missing" do
+      let(:argv) { %w{ create serverurl -n fakename --virtual-server fakevirt --disk fakedisk } }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when the virtual-server parameter is missing" do
+      let(:argv) { %w{ create serverurl -n fakename --vios fakevios --disk fakedisk } }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when the disk parameter is missing" do
+      let(:argv) { %w{ create serverurl -n fakename --vios fakevios --virtual-server fakevirt } }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "by default" do
+      let(:argv) { %w{ create serverurl -n fakename --vios fakevios --virtual-server fakevirt --disk fakedisk -p fakeprof } }
+
+      it "sets defaults" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password)
+        expect(knife).to receive(:create_lpar)
+        knife.run
+        expect(knife.config[:profile]).to eq("fakeprof")
+        expect(knife.config[:min_mem]).to eq(1024)
+        expect(knife.config[:desired_mem]).to eq(4096)
+        expect(knife.config[:max_mem]).to eq(16384)
+        expect(knife.config[:min_procs]).to eq(1)
+        expect(knife.config[:desired_procs]).to eq(2)
+        expect(knife.config[:max_procs]).to eq(4)
+        expect(knife.config[:min_proc_units]).to eq(1)
+        expect(knife.config[:desired_proc_units]).to eq(2)
+        expect(knife.config[:max_proc_units]).to eq(4)
+      end
+    end
+
+    context "without profile" do
+      let(:argv) { %w{ create serverurl -n fakename --vios fakevios --virtual-server fakevirt --disk fakedisk } }
+
+      it "defaults profile to name" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password)
+        expect(knife).to receive(:create_lpar)
+        knife.run
+        expect(knife.config[:profile]).to eq("fakename")
+      end
+    end
+  end
+
+  context "#create_lpar" do
+    before(:each) do
+      Chef::Knife::LparCreate.load_deps
+      @session = double(Net::SSH)
+      allow(Net::SSH).to receive(:start).with("serverurl", "hscroot", :password => "testpass").and_yield(@session)
+    end
+
+    context "with an existing lpar name" do
+      let(:argv) { %w{ create serverurl -n fakename --vios fakevios --virtual-server fakevirt --disk fakedisk -p fakeprof} }
+
+      it "returns with an error since the lpar already exists" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password).and_return("testpass")
+        expect(knife).to receive(:create_lpar).and_call_original
+
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt -F name -r lpar | grep fakename").and_return("fakename")
+        expect(knife.ui).to receive(:fatal)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "with defaults" do
+      let(:argv) { %w{ create serverurl -n fakename --vios fakevios --virtual-server fakevirt --disk fakedisk -p fakeprof} }
+
+      it "does things" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password).and_return("testpass")
+        expect(knife).to receive(:create_lpar).and_call_original
+
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt -F name -r lpar | grep fakename").and_return(nil)
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"lsdev -type disk -virtual -field name\" | tail -1").and_return("fakevscsi1")
+        # this is real type of data it returns, deal with it :)
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"lsdev -dev fakevscsi1 -field physloc -fmt \\\":\\\"\"").and_return("U8231.E1D.06A398T-V2-C108-L1")
+        expect(knife).to receive(:run_remote_command).with(@session, "mksyscfg -m fakevirt -r lpar \
+-i \"name=fakename, \
+profile_name=fakeprof, \
+lpar_env=aixlinux, \
+min_mem=1024, \
+desired_mem=4096, \
+max_mem=16384, \
+proc_mode=shared, \
+min_procs=1, \
+desired_procs=2, \
+max_procs=4, \
+min_proc_units=1, \
+desired_proc_units=2, \
+max_proc_units=4, \
+sharing_mode=uncap, uncap_weight=128, \
+boot_mode=norm, max_virtual_slots=10, \
+\\\"virtual_eth_adapters=3/0/1//0/0\\\", \
+\\\"virtual_scsi_adapters=2/client//fakevios/109/1\\\"\"")
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt --filter \"lpar_names=fakename\" -F lpar_id -r lpar").and_return("5")
+        expect(knife).to receive(:run_remote_command).with(@session, "chhwres -r virtualio -m fakevirt -o a -p fakevios --rsubtype scsi -s 109 -a \"adapter_type=server, remote_lpar_name=fakename, remote_slot_num=2\"")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"mkvdev -fbo -vadapter vhost4\"").and_return("vadapter3")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"loadopt -vtd vadapter3 -disk fakedisk\"")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"mklv -lv fakename rootvg 50G\"")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"mkvdev -vdev fakename -vadapter vhost4\"").and_return("fakevtopt3 Virtual Optical Device")
+        expect(knife).to receive(:run_remote_command).with(@session, "mksyscfg -r prof -m fakevirt -o save -p fakevios -n `lssyscfg -r lpar -m fakevirt --filter \"lpar_names=fakevios\" -F curr_profile` --force")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"cfgdev\"")
+        expect(knife).to receive(:run_remote_command).with(@session, "chsysstate -r lpar -m fakevirt -o on -f fakeprof -b sms -n fakename")
+
+        knife.run
+      end
+    end
+  end
+end

data/spec/unit/lpar_delete_spec.rb

@@ -0,0 +1,140 @@
+#
+# Copyright:: Copyright (c) 2014-2016 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "chef/knife/lpar_delete.rb"
+
+describe Chef::Knife::LparDelete do
+
+  subject(:knife) do
+    Chef::Knife::LparDelete.new(argv).tap do |c|
+      allow(c).to receive(:output).and_return(true)
+      c.parse_options(argv)
+      c.merge_configs
+    end
+  end
+
+  describe "#run" do
+    context "by default" do
+      let(:argv) { %w{ delete serverurl -n fakename --vios fakevios --virtual-server fakevirt } }
+
+      it "parses argv, gets password, and deletes lpar" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password)
+        expect(knife).to receive(:delete_lpar)
+        knife.run
+      end
+    end
+  end
+
+  describe "#read_and_validate_params" do
+    context "when argv is empty" do
+      let(:argv) { [] }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when the name parameter is missing" do
+      let(:argv) { %w{ delete serverurl --vios fakevios --virtual-server fakevirt } }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when the vios parameter is missing" do
+      let(:argv) { %w{ delete serverurl -n fakename --virtual-server fakevirt } }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "when the virtual-server parameter is missing" do
+      let(:argv) { %w{ delete serverurl -n fakename --vios fakevios } }
+
+      it "prints usage and exits" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:show_usage)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+  end
+
+  describe "#delete_lpar" do
+    before(:each) do
+      Chef::Knife::LparDelete.load_deps
+      @session = double(Net::SSH)
+      allow(Net::SSH).to receive(:start).with("serverurl", "hscroot", :password => "testpass").and_yield(@session)
+    end
+
+    context "when lpar does not exist" do
+      let(:argv) { %w{ delete serverurl -n fakename --vios fakevios --virtual-server fakevirt } }
+
+      it "returns with an error since the lpar does not exist" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password).and_return("testpass")
+        expect(knife).to receive(:delete_lpar).and_call_original
+
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt -F name -r lpar --filter \"lpar_names=fakename\"").and_return(nil)
+        expect(knife.ui).to receive(:fatal)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+
+      it "returns with an error since the lpar exists but is not activated/running" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password).and_return("testpass")
+        expect(knife).to receive(:delete_lpar).and_call_original
+
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt -F name -r lpar --filter \"lpar_names=fakename\"").and_return("fakename")
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt -F state -r lpar --filter \"lpar_names=fakename\"").and_return("Running")
+        expect(knife.ui).to receive(:fatal)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+
+      it "does things" do
+        expect(knife).to receive(:read_and_validate_params).and_call_original
+        expect(knife).to receive(:get_password).and_return("testpass")
+        expect(knife).to receive(:delete_lpar).and_call_original
+
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt -F name -r lpar --filter \"lpar_names=fakename\"").and_return("fakename")
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt -F state -r lpar --filter \"lpar_names=fakename\"").and_return("Not Activated")
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt --filter \"lpar_names=fakename\" -F lpar_id -r lpar").and_return(8)
+        expect(knife).to receive(:run_remote_command).with(@session, "lssyscfg -m fakevirt -r prof --filter \"lpar_names=fakename\" -F virtual_scsi_adapters").and_return("2/client/2/fakevirt/106/1")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"lsmap -vadapter vhost7 -type file_opt -field vtd -fmt \\\":\\\"\"").and_return("vtopt4")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"lsmap -vadapter vhost7 -type lv -field vtd -fmt \\\":\\\"\"").and_return("vtscsi3")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"lsmap -vadapter vhost7 -type lv -field backing -fmt \\\":\\\"\"").and_return("backingdevice")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"rmvdev -vtd vtopt4\"")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"rmvdev -vtd vtscsi3\"")
+        expect(knife).to receive(:run_remote_command).with(@session, "viosvrcmd -m fakevirt -p fakevios -c \"rmlv -f backingdevice\"")
+        expect(knife).to receive(:run_remote_command).with(@session, "chhwres -r virtualio -m fakevirt -o r -p fakevios --rsubtype scsi -s 106")
+        expect(knife).to receive(:run_remote_command).with(@session, "mksyscfg -r prof -m fakevirt -o save -p fakevios -n `lssyscfg -r lpar -m fakevirt --filter \"lpar_names=fakevios\" -F curr_profile` --force")
+        expect(knife).to receive(:run_remote_command).with(@session, "rmsyscfg -r lpar -m fakevirt -n fakename")
+
+        knife.run
+      end
+    end
+  end
+end