knife-server 1.1.0 → 1.2.0

data/lib/knife/server/ec2_security_group.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 #
 # Author:: Fletcher Nichol (<fnichol@nichol.ca>)
 # Copyright:: Copyright (c) 2012 Fletcher Nichol
@@ -18,6 +19,7 @@
 
 module Knife
   module Server
+    # Sets up EC2 security groups for a Chef Server.
     class Ec2SecurityGroup
       def initialize(connection, ui)
         @aws  = connection
@@ -29,10 +31,10 @@ module Knife
 
         ip_permissions.each do |p|
           if permission_exists?(group, p)
-            @ui.msg "Inbound security group rule " +
+            @ui.msg "Inbound security group rule " \
               "#{p[:proto]}(#{p[:from]} -> #{p[:to]}) exists"
           else
-            @ui.msg "Creating inbound security group rule for " +
+            @ui.msg "Creating inbound security group rule for " \
               "#{p[:proto]}(#{p[:from]} -> #{p[:to]})"
             options = permission_options(group, p)
             @aws.authorize_security_group_ingress(group.name, options)
@@ -57,45 +59,46 @@ module Knife
       private
 
       def ip_permissions
-        [ {:proto => 'icmp',  :from => -1,  :to => -1},
-          {:proto => 'tcp',   :from => 0,   :to => 65535},
-          {:proto => 'udp',   :from => 0,   :to => 65535},
-          {:proto => 'tcp',   :from => 22,  :to => 22,  :cidr => '0.0.0.0/0'},
-          {:proto => 'tcp',   :from => 443, :to => 443, :cidr => '0.0.0.0/0'},
-          {:proto => 'tcp',   :from => 444, :to => 444, :cidr => '0.0.0.0/0'},
+        [
+          { :proto => "icmp", :from => -1,  :to => -1 },
+          { :proto => "tcp",  :from => 0,   :to => 65535 },
+          { :proto => "udp",  :from => 0,   :to => 65535 },
+          { :proto => "tcp",  :from => 22,  :to => 22,  :cidr => "0.0.0.0/0" },
+          { :proto => "tcp",  :from => 443, :to => 443, :cidr => "0.0.0.0/0" },
+          { :proto => "tcp",  :from => 444, :to => 444, :cidr => "0.0.0.0/0" }
         ].freeze
       end
 
       def permission_exists?(group, perm)
         group.ip_permissions.find do |p|
-          p['ipProtocol'] == perm[:proto] &&
-            p['fromPort'] == perm[:from] &&
-            p['toPort']   == perm[:to]
+          p["ipProtocol"] == perm[:proto] &&
+            p["fromPort"] == perm[:from] &&
+            p["toPort"]   == perm[:to]
         end
       end
 
-      def permission_options(group, opts)
+      def permission_options(group, opts) # rubocop:disable Metrics/MethodLength
         options = {
-          'IpPermissions' => [
+          "IpPermissions" => [
             {
-              'IpProtocol'  => opts[:proto],
-              'FromPort'    => opts[:from],
-              'ToPort'      => opts[:to]
+              "IpProtocol"  => opts[:proto],
+              "FromPort"    => opts[:from],
+              "ToPort"      => opts[:to]
             }
           ]
         }
 
         if opts[:cidr]
-          options['IpPermissions'].first['IpRanges'] = [
+          options["IpPermissions"].first["IpRanges"] = [
             {
-              'CidrIp'    => opts[:cidr]
+              "CidrIp" => opts[:cidr]
             }
           ]
         else
-          options['IpPermissions'].first['Groups'] = [
+          options["IpPermissions"].first["Groups"] = [
             {
-              'GroupName' => group.name,
-              'UserId'    => group.owner_id
+              "GroupName" => group.name,
+              "UserId"    => group.owner_id
             }
           ]
         end

data/lib/knife/server/ssh.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 #
 # Author:: Fletcher Nichol (<fnichol@nichol.ca>)
 # Copyright:: Copyright (c) 2012 Fletcher Nichol
@@ -16,13 +17,15 @@
 # limitations under the License.
 #
 
-require 'net/ssh'
+require "net/ssh"
 
 module Knife
   module Server
+    # Communicates with an SSH node.
     class SSH
       DEFAULT_OPTIONS = { :user => "root", :port => "22" }.freeze
-      USER_SWITCH_COMMAND = %[sudo USER=root HOME="$(getent passwd root | cut -d : -f 6)"]
+      USER_SWITCH_COMMAND =
+        %{sudo USER=root HOME="$(getent passwd root | cut -d : -f 6)"}.freeze
 
       def initialize(params)
         options = DEFAULT_OPTIONS.merge(params)
@@ -33,20 +36,49 @@ module Knife
       end
 
       def exec!(cmd)
+        result = ""
+        exit_code = nil
+        Net::SSH.start(@host, @user, @options) do |session|
+          exit_code = ssh_session(session, full_cmd(cmd), result)
+        end
+        if exit_code != 0
+          raise "SSH exited with code #{exit_code} for [#{full_cmd(cmd)}]"
+        end
+        result
+      end
+
+      def full_cmd(cmd)
         if @user == "root"
-          full_cmd = cmd
+          cmd
         else
-          full_cmd = [
-            USER_SWITCH_COMMAND,
-            %[bash -c '#{cmd}']
-          ].join(" ")
+          [USER_SWITCH_COMMAND, %{bash -c '#{cmd}'}].join(" ")
         end
+      end
 
-        result = ""
-        Net::SSH.start(@host, @user, @options) do |ssh|
-          result = ssh.exec!(full_cmd)
+      def ssh_session(session, cmd, result)
+        exit_code = nil
+        session.open_channel do |channel|
+
+          channel.request_pty
+
+          channel.exec(cmd) do |_ch, _success|
+
+            channel.on_data do |_ch, data|
+              result << data
+            end
+
+            channel.on_extended_data do |_ch, _type, data|
+              result << data
+            end
+
+            channel.on_request("exit-status") do |_ch, data|
+              exit_code = data.read_long
+            end
+          end
         end
-        result
+
+        session.loop
+        exit_code
       end
 
       # runs a script on the target host by passing it to the stdin of a sh
@@ -71,26 +103,30 @@ module Knife
         fi
         EOF
 
+        exec_ssh(wrapper, content)
+      end
+
+      def exec_ssh(wrapper, content) # rubocop:disable Metrics/MethodLength
         result = ""
         exit_status = nil
 
         Net::SSH.start(@host, @user, @options) do |ssh|
           ssh.open_channel do |ch|
-            ch.on_open_failed do |ch, code, desc|
+            ch.on_open_failed do |_, _, desc|
               raise "Connection Error to #{ip}: #{desc}"
             end
 
-            ch.exec(wrapper) do |channel, type, data|
-              # spit out the shell script and close stdin so sh can do its magic.
+            ch.exec(wrapper) do |channel, _, _|
+              # spit out the shell script and close stdin so sh can do its magic
               channel.send_data(content)
               channel.eof!
 
-              # then we just wait for sweet, sweet output.
-              channel.on_data do |ch2, data|
+              # then we just wait for sweet, sweet output
+              channel.on_data do |_, data|
                 result << data
               end
 
-              channel.on_request("exit-status") do |ch2, data|
+              channel.on_request("exit-status") do |_, data|
                 exit_status = data.read_long
               end
             end
@@ -101,7 +137,7 @@ module Knife
           ssh.loop
         end
 
-        return result, exit_status
+        [result, exit_status]
       end
     end
   end

data/lib/knife/server/version.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 #
 # Author:: Fletcher Nichol (<fnichol@nichol.ca>)
 # Copyright:: Copyright (c) 2012 Fletcher Nichol
@@ -18,6 +19,6 @@
 
 module Knife
   module Server
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end

data/spec/chef/knife/server_backup_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 #
 # Author:: Fletcher Nichol (<fnichol@nichol.ca>)
 # Copyright:: Copyright (c) 2012 Fletcher Nichol
@@ -16,9 +17,9 @@
 # limitations under the License.
 #
 
-require 'chef/knife/server_backup'
-require 'fakefs/spec_helpers'
-require 'timecop'
+require "chef/knife/server_backup"
+require "fakefs/spec_helpers"
+require "timecop"
 
 describe Chef::Knife::ServerBackup do
   include FakeFS::SpecHelpers
@@ -27,10 +28,10 @@ describe Chef::Knife::ServerBackup do
     Chef::Log.logger = Logger.new(StringIO.new)
     @knife = Chef::Knife::ServerBackup.new
     @stdout = StringIO.new
-    @knife.ui.stub!(:stdout).and_return(@stdout)
-    @knife.ui.stub(:msg)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:msg)
     @stderr = StringIO.new
-    @knife.ui.stub!(:stderr).and_return(@stderr)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
     @knife.config[:backup_dir] = "/baks"
 
     Chef::Config[:chef_server_url] = "https://chef.example.com:9876"
@@ -50,7 +51,7 @@ describe Chef::Knife::ServerBackup do
         @knife.config[:backup_dir] = nil
         Chef::Config[:file_backup_path] = "/da/bomb"
 
-        @knife.backup_dir.should eq(
+        expect(@knife.backup_dir).to eq(
           "/da/bomb/chef.example.com_20120102T030405-0000")
       end
     end
@@ -64,35 +65,37 @@ describe Chef::Knife::ServerBackup do
     let(:data_bag_item_list) { Hash["myitem" => "http://p/bags/mybag/myitem"] }
 
     before do
-      Chef::Node.stub(:list) { node_list }
-      Chef::Node.stub(:load).with("mynode") { stub_node("mynode") }
-      Chef::Role.stub(:list) { role_list }
-      Chef::Role.stub(:load).with("myrole") { stub_role("myrole") }
-      Chef::Environment.stub(:list) { env_list }
-      Chef::Environment.stub(:load).with("myenv") { stub_env("myenv") }
-      Chef::DataBag.stub(:list) { data_bag_list }
-      Chef::DataBag.stub(:load).with("mybag") { data_bag_item_list }
-      Chef::DataBagItem.stub(:load).
-        with("mybag", "myitem") { stub_bag_item("mybag", "myitem")}
+      allow(Chef::Node).to receive(:list) { node_list }
+      allow(Chef::Node).to receive(:load).with("mynode") { stub_node("mynode") }
+      allow(Chef::Role).to receive(:list) { role_list }
+      allow(Chef::Role).to receive(:load).with("myrole") { stub_role("myrole") }
+      allow(Chef::Environment).to receive(:list) { env_list }
+      allow(Chef::Environment).to receive(:load).
+        with("myenv") { stub_env("myenv") }
+      allow(Chef::DataBag).to receive(:list) { data_bag_list }
+      allow(Chef::DataBag).to receive(:load).
+        with("mybag") { data_bag_item_list }
+      allow(Chef::DataBagItem).to receive(:load).
+        with("mybag", "myitem") { stub_bag_item("mybag", "myitem") }
     end
 
     it "exits if component type is invalid" do
-      @knife.name_args = %w{nodes toasterovens}
+      @knife.name_args = %w[nodes toasterovens]
 
-      lambda { @knife.run }.should raise_error SystemExit
+      expect { @knife.run }.to raise_error SystemExit
     end
 
     context "for nodes" do
-      before { @knife.name_args = %w{nodes} }
+      before { @knife.name_args = %w[nodes] }
 
       it "creates the backup nodes dir" do
         @knife.run
 
-        File.directory?(["/baks", "nodes"].join("/")).should be_true
+        expect(File.directory?(["/baks", "nodes"].join("/"))).to be_truthy
       end
 
       it "sends a message to the ui" do
-        @knife.ui.should_receive(:msg).with(/mynode/)
+        expect(@knife.ui).to receive(:msg).with(/mynode/)
 
         @knife.run
       end
@@ -102,21 +105,22 @@ describe Chef::Knife::ServerBackup do
         json_str = File.open("/baks/nodes/mynode.json", "rb") { |f| f.read }
         json = JSON.parse(json_str, :create_additions => false)
 
-        json["name"].should eq("mynode")
+        expect(json["name"]).to eq("mynode")
       end
     end
 
     context "for roles" do
-      before { @knife.name_args = %w{roles} }
+      before { @knife.name_args = %w[roles] }
 
       it "creates the backup roles dir" do
         @knife.run
+        dir = File.join("/baks", "roles")
 
-        File.directory?(["/baks", "roles"].join("/")).should be_true
+        expect(File.directory?(dir)).to be_truthy
       end
 
       it "sends a message to the ui" do
-        @knife.ui.should_receive(:msg).with(/myrole/)
+        expect(@knife.ui).to receive(:msg).with(/myrole/)
 
         @knife.run
       end
@@ -126,63 +130,73 @@ describe Chef::Knife::ServerBackup do
         json_str = File.open("/baks/roles/myrole.json", "rb") { |f| f.read }
         json = JSON.parse(json_str, :create_additions => false)
 
-        json["name"].should eq("myrole")
+        expect(json["name"]).to eq("myrole")
       end
     end
 
     context "for environments" do
-      before { @knife.name_args = %w{environments} }
+      before { @knife.name_args = %w[environments] }
 
       it "creates the backup environments dir" do
         @knife.run
+        dir = File.join("/baks", "environments")
 
-        File.directory?(["/baks", "environments"].join("/")).should be_true
+        expect(File.directory?(dir)).to be_truthy
       end
 
       it "sends a message to the ui" do
-        @knife.ui.should_receive(:msg).with(/myenv/)
+        expect(@knife.ui).to receive(:msg).with(/myenv/)
 
         @knife.run
       end
 
       it "writes out each environment to a json file" do
         @knife.run
-        json_str = File.open("/baks/environments/myenv.json", "rb") { |f| f.read }
+        json_str = File.open("/baks/environments/myenv.json", "rb") do |f|
+          f.read
+        end
         json = JSON.parse(json_str, :create_additions => false)
 
-        json["name"].should eq("myenv")
+        expect(json["name"]).to eq("myenv")
       end
 
       it "skips the _default environment" do
-        Chef::Environment.stub(:list) { Hash["_default" => "http://url"] }
-        Chef::Environment.stub(:load).with("_default") { stub_env("_default") }
+        allow(Chef::Environment).to receive(:list) do
+          Hash["_default" => "http://url"]
+        end
+        allow(Chef::Environment).to receive(:load).with("_default") do
+          stub_env("_default")
+        end
         @knife.run
 
-        File.exists?("/baks/environments/_default.json").should_not be_true
+        expect(File.exist?("/baks/environments/_default.json")).to_not be_truthy
       end
     end
 
     context "for data_bags" do
-      before { @knife.name_args = %w{data_bags} }
+      before { @knife.name_args = %w[data_bags] }
 
       it "creates the backup data_bags dir" do
         @knife.run
+        dir = File.join("/baks", "data_bags")
 
-        File.directory?(["/baks", "data_bags"].join("/")).should be_true
+        expect(File.directory?(dir)).to be_truthy
       end
 
       it "sends messages to the ui" do
-        @knife.ui.should_receive(:msg).with(/myitem/)
+        expect(@knife.ui).to receive(:msg).with(/myitem/)
 
         @knife.run
       end
 
       it "writes out each data bag item to a json file" do
         @knife.run
-        json_str = File.open("/baks/data_bags/mybag/myitem.json", "rb") { |f| f.read }
+        json_str = File.open("/baks/data_bags/mybag/myitem.json", "rb") do |f|
+          f.read
+        end
         json = JSON.parse(json_str, :create_additions => false)
 
-        json["name"].should eq("data_bag_item_mybag_myitem")
+        expect(json["name"]).to eq("data_bag_item_mybag_myitem")
       end
     end
 
@@ -190,25 +204,25 @@ describe Chef::Knife::ServerBackup do
       it "writes a node file" do
         @knife.run
 
-        File.exists?("/baks/nodes/mynode.json").should be_true
+        expect(File.exist?("/baks/nodes/mynode.json")).to be_truthy
       end
 
       it "writes a role file" do
         @knife.run
 
-        File.exists?("/baks/roles/myrole.json").should be_true
+        expect(File.exist?("/baks/roles/myrole.json")).to be_truthy
       end
 
       it "writes an environment file" do
         @knife.run
 
-        File.exists?("/baks/environments/myenv.json").should be_true
+        expect(File.exist?("/baks/environments/myenv.json")).to be_truthy
       end
 
       it "writes a data bag item file" do
         @knife.run
 
-        File.exists?("/baks/data_bags/mybag/myitem.json").should be_true
+        expect(File.exist?("/baks/data_bags/mybag/myitem.json")).to be_truthy
       end
     end
   end