knife-pkg 0.0.1

data/lib/chef/knife/pkg_show_updates.rb

@@ -0,0 +1,100 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# 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.
+
+
+class Chef
+  class Knife
+    class PkgShowUpdates < PkgBase
+
+      banner 'knife pkg show updates QUERY (options)'
+
+      deps do
+        require 'net/ssh'
+        require 'net/ssh/multi'
+        require 'chef/knife/ssh'
+        require 'knife-pkg'
+      end
+
+      option :attribute,
+        :short => "-a ATTR",
+        :long => "--attribute ATTR",
+        :description => "The attribute to use for opening the connection - default depends on the context",
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_attribute] = key.strip }
+
+      option :ssh_user,
+        :short => "-x USERNAME",
+        :long => "--ssh-user USERNAME",
+        :description => "The ssh username"
+
+      option :ssh_password,
+        :short => "-P PASSWORD",
+        :long => "--ssh-password PASSWORD",
+        :description => "The ssh password"
+
+      option :ssh_port,
+        :short => "-p PORT",
+        :long => "--ssh-port PORT",
+        :description => "The ssh port",
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_port] = key.strip }
+
+      option :ssh_gateway,
+        :short => "-G GATEWAY",
+        :long => "--ssh-gateway GATEWAY",
+        :description => "The ssh gateway",
+        :proc => Proc.new { |key| Chef::Config[:knife][:ssh_gateway] = key.strip }
+
+      option :forward_agent,
+        :short => "-A",
+        :long => "--forward-agent",
+        :description => "Enable SSH agent forwarding",
+        :boolean => true
+
+      option :identity_file,
+        :short => "-i IDENTITY_FILE",
+        :long => "--identity-file IDENTITY_FILE",
+        :description => "The SSH identity file used for authentication"
+
+      option :host_key_verify,
+        :long => "--[no-]host-key-verify",
+        :description => "Verify host key, enabled by default.",
+        :boolean => true,
+        :default => true
+
+      option :sudo_required,
+        :short => "-z",
+        :long => "--sudo-required",
+        :description => "Use sudo",
+        :boolean => true,
+        :default => false
+
+      option :pkg_verbose,
+        :short => "-l",
+        :long => "--pkg-verbose",
+        :description => "More verbose output for package related things",
+        :boolean => true,
+        :default => false
+
+      
+      def run
+        super
+      end
+      
+      def process(node, session)
+        ui.info("===> " + extract_nested_value(node, config[:attribute]))
+        ::Knife::Pkg::PackageController.available_updates(node, session, pkg_options)
+      end
+    end
+  end
+end

data/lib/knife-pkg/controllers/debian.rb

@@ -0,0 +1,66 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# 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 'knife-pkg'
+
+module Knife
+  module Pkg
+    class DebianPackageController < PackageController
+
+      def initialize(node, session, opts = {})
+        super(node, session, opts)
+      end
+
+      def update_pkg_cache
+        ShellCommand.exec("#{sudo}apt-get update", @session)
+      end
+
+      def last_pkg_cache_update
+        result = ShellCommand.exec("stat -c %y /var/lib/apt/periodic/update-success-stamp", @session)
+        Time.parse(result.stdout.chomp)
+      end
+
+      def installed_version(package)
+        ShellCommand.exec("dpkg -p #{package.name} | grep -i Version: | awk '{print $2}'", @session).stdout.chomp
+      end
+
+      def available_updates
+        packages = Array.new
+        if !update_notifier_installed?
+          raise RuntimeError, "Gna!! No update-notifier(-common) installed!? Go ahead, install it and come back!"
+        else
+          result = ShellCommand.exec("#{sudo}/usr/lib/update-notifier/apt_check.py -p", @session)
+          result.stderr.split("\n").each do |item|
+            package = Package.new(item)
+            package.version = installed_version(package)
+            packages << package
+          end
+        end
+        packages
+      end
+
+      def update_package!(package)
+        cmd_string = "#{sudo} DEBIAN_FRONTEND=noninteractive apt-get install #{package.name} -y -o Dpkg::Options::='--force-confold'"
+        cmd_string += " -s" if @options[:dry_run]
+        ShellCommand.exec(cmd_string, @session)
+      end
+
+      def update_notifier_installed?
+          ShellCommand.exec("dpkg-query -W update-notifier-common 2>/dev/null || echo 'false'", @session).stdout.chomp != 'false'
+      end
+    end
+  end
+end

data/lib/knife-pkg/controllers/package_controller.rb

@@ -0,0 +1,171 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# 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 'knife-pkg'
+require 'chef/knife'
+
+module Knife
+  module Pkg
+    class PackageController
+
+      attr_accessor :node
+      attr_accessor :session
+      attr_accessor :options
+      attr_accessor :ui
+
+      def initialize(node, session, opts = {})
+        @node = node
+        @session = session
+        @options = opts
+      end
+
+      def self.ui
+        @ui ||= Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
+      end
+
+      def sudo
+        @options[:sudo] ? 'sudo ' : ''
+      end
+
+      ## ++ methods to implement
+      
+      # update the package cache 
+      # e.g apt-get update
+      def update_pkg_cache
+        raise NotImplementedError
+      end
+
+      # returns the `Time` of the last package cache update
+      def last_pkg_cache_update
+        raise NotImplementedError
+      end
+
+      # returns the version string of the installed package
+      def installed_version(package)
+        raise NotImplementedError
+      end
+
+      # returns an `Array` of all available updates
+      def available_updates
+        raise NotImplementedError
+      end
+
+      # updates a package
+      # should only execute a 'dry-run' if @options[:dry_run] is set
+      # returns a ShellCommandResult
+      def update_package!(package)
+        raise NotImplementedError
+      end
+
+      ## ++ methods to implement
+      
+
+      def update_package_verbose!(package)
+        result = update_package!(package)
+        if @options[:dry_run] || @options[:verbose]
+          ui.info(result.stdout)
+          ui.error(result.stderr)
+        end
+      end
+
+      def try_update_pkg_cache
+        if Time.now - last_pkg_cache_update > 86400 # 24 hours
+          @ui.info("Updating package cache...")
+          update_pkg_cache
+        end
+      end
+
+      def update_dialog(packages)
+        return if packages.count == 0
+
+        ui.info("\tThe following updates are available:") if packages.count > 0
+        packages.each do |package|
+          ui.info(ui.color("\t" + package.to_s, :yellow))
+        end
+
+        if UserDecision.yes?("\tDo you want to update all packages? [y|n]: ")
+          ui.info("\tupdating...")
+          packages.each do |p| 
+            update_package_verbose!(p) 
+          end
+          ui.info("\tall packages updated!")
+        else
+          packages.each do |package|
+            if UserDecision.yes?("\tDo you want to update #{package}? [y|n]: ")
+              result = update_package_verbose!(package)
+              ui.info("\t#{package} updated!")
+            end
+          end
+        end
+      end
+
+      def self.list_available_updates(updates)
+        updates.each do |update|
+          ui.info(ui.color("\t" + update.to_s, :yellow))
+        end
+      end
+
+      def self.update!(node, session, packages, opts)
+        ctrl = self.init_controller(node, session, opts)
+
+        auto_updates = packages.map { |u| Package.new(u) }
+        updates_for_dialog = Array.new
+
+        ctrl.try_update_pkg_cache
+        available_updates = ctrl.available_updates
+
+        available_updates.each do |avail|
+          if auto_updates.select { |p| p.name == avail.name }.count == 0
+            updates_for_dialog << avail
+          else
+            ui.info("\tUpdating #{avail.to_s}")
+            ctrl.update_package_verbose!(avail)
+          end
+        end
+
+        ctrl.update_dialog(updates_for_dialog)
+      end
+
+      def self.available_updates(node, session, opts = {})
+        ctrl = self.init_controller(node, session, opts)
+        ctrl.try_update_pkg_cache
+        updates = ctrl.available_updates
+        list_available_updates(updates)
+      end
+
+      def self.init_controller(node, session, opts)
+        begin
+          ctrl_name = self.controller_name(node.platform)
+          require File.join(File.dirname(__FILE__), ctrl_name)
+        rescue LoadError
+          raise NotImplementedError, "I'm sorry, but #{node.platform} is not supported!"
+        end
+        ctrl = Object.const_get('Knife').const_get('Pkg').const_get("#{ctrl_name.capitalize}PackageController").new(node, session, opts)
+        ctrl.ui = self.ui
+        ctrl
+      end
+
+      def self.controller_name(platform)
+        case platform
+        when 'debian', 'ubuntu'
+          'debian'
+        else
+          platform
+        end
+      end
+    end
+  end
+end

data/lib/knife-pkg/package.rb

@@ -0,0 +1,42 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# 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 'knife-pkg'
+
+module Knife
+  module Pkg
+    class Package
+      attr_accessor :name, :version
+
+      def initialize(name, version = '0.0')
+        @name = name.strip
+        @version = version
+      end
+
+      def to_s
+        @name + (version_to_s == '' ? '' : " #{version_to_s}")
+      end
+
+      def version_to_s
+        if @version.to_s != '0.0'
+          "(#{@version})"
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/knife-pkg/shell_command.rb

@@ -0,0 +1,61 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# 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.
+
+
+module Knife
+  module Pkg
+    class ShellCommand
+
+      def self.exec(cmd, session)
+
+        stdout_data, stderr_data = "", ""
+        exit_code, exit_signal = nil, nil
+        session.open_channel do |channel|
+          channel.exec(cmd) do |_, success|
+            raise RuntimeError, "Command \"#{@cmd}\" could not be executed!" if !success
+
+            channel.on_data do |_, data|
+              stdout_data += data
+            end
+
+            channel.on_extended_data do |_,_,data|
+              stderr_data += data
+            end
+
+            channel.on_request("exit-status") do |_,data|
+              exit_code = data.read_long
+            end
+
+            channel.on_request("exit-signal") do |_, data|
+              exit_signal = data.read_long
+            end
+          end
+        end
+        session.loop
+
+        result = ShellCommandResult.new(cmd, stdout_data, stderr_data, exit_code.to_i)
+
+        raise_error!(result) unless result.succeeded?
+
+        return result
+      end
+
+      def self.raise_error!(result)
+        raise RuntimeError, "Command failed! #{result.to_s}" 
+      end
+
+    end
+  end
+end

data/lib/knife-pkg/shell_command_result.rb

@@ -0,0 +1,43 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# 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.
+
+
+module Knife
+  module Pkg
+    class ShellCommandResult
+
+      attr_accessor :cmd
+      attr_accessor :stdout
+      attr_accessor :stderr
+      attr_accessor :exit_code
+
+      def initialize(cmd, stdout, stderr, exit_code)
+        @cmd = cmd
+        @stdout = stdout
+        @stderr = stderr
+        @exit_code = exit_code
+      end
+
+      def to_s
+        return "Command: \"#{@cmd}\", stdout: \"#{@stdout}\", stderr: \"#{@stderr}\", exit_code: \"#{@exit_code}\""
+      end
+
+      def succeeded?
+        return @exit_code.to_i == 0 ? true : false
+      end
+
+    end
+  end
+end

data/lib/knife-pkg/user_decision.rb

@@ -0,0 +1,44 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# 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'
+
+module Knife
+  module Pkg
+    class UserDecision
+
+      def self.ui
+        @ui ||= Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
+      end
+
+      def self.yes?(text)
+        decision = false
+        while true
+          response = ui.ask_question("#{text}", :default => false)
+          case response
+          when 'y'
+            decision = true
+            break
+          when 'n'
+            decision = false
+            break
+          end
+        end
+        decision
+      end
+    end
+  end
+end

data/lib/knife-pkg/version.rb

@@ -0,0 +1,5 @@
+module Knife
+  module Pkg
+    VERSION = '0.0.1'
+  end
+end

data/lib/knife-pkg.rb

@@ -0,0 +1,28 @@
+#
+# Copyright 2013, Holger Amann <holger@fehu.org>
+#
+# 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 'knife-pkg/version'
+require 'knife-pkg/package'
+require 'knife-pkg/shell_command'
+require 'knife-pkg/shell_command_result'
+require 'knife-pkg/user_decision'
+require 'knife-pkg/controllers/package_controller'
+
+module Knife
+  module Pkg
+    # Your code goes here...
+  end
+end

data/spec/controllers/debian_spec.rb

@@ -0,0 +1,45 @@
+require 'knife-pkg'
+require 'knife-pkg/controllers/debian'
+
+include Knife::Pkg
+
+describe 'DebianPackageController' do
+  describe '#new' do
+    it 'should create an instance of DebianPkgCtrl' do
+      p = DebianPackageController.new('a', 'b', :h => 1)
+      expect(p).to be_an_instance_of(DebianPackageController)
+      expect(p.node).to eq('a')
+      expect(p.session).to eq('b')
+      expect(p.options).to eq(:h => 1)
+    end
+  end
+
+  describe "#last_pkg_cache_update" do
+    it 'should return a time object' do
+      t = Time.now
+      result = ShellCommandResult.new(nil,"2013-10-07 09:58:34.000000000 +0200\n",nil,nil)
+      ShellCommand.stub(:exec).and_return(result)
+
+      p = DebianPackageController.new(nil, nil)
+      expect(p.last_pkg_cache_update).to be_an_instance_of Time
+      expect(p.last_pkg_cache_update).to eq(Time.parse("2013-10-07 09:58:34.000000000 +0200")) 
+    end
+  end
+
+  describe "#available_updates" do
+    it 'should raise an error if update-notifier is not installed' do
+      p = DebianPackageController.new(nil, nil)
+      p.stub(:update_notifier_installed?).and_return(false)
+      expect{p.available_updates}.to raise_error(/update-notifier/)
+    end
+
+    it 'should return an array' do
+      result = ShellCommandResult.new(nil, nil, "1\n2\n3", nil)
+      ShellCommand.stub(:exec).and_return(result)
+      p = DebianPackageController.new(nil, nil)
+      p.stub(:update_notifier_installed?).and_return(true)
+      p.stub(:installed_version).and_return("1.0.0")
+      expect(p.available_updates).to be_an_instance_of Array
+    end
+  end
+end

data/spec/controllers/package_controller_spec.rb

@@ -0,0 +1,28 @@
+require 'knife-pkg'
+
+include Knife::Pkg
+
+describe 'PackageController' do
+  describe '#new' do
+  end
+
+  describe '#sudo' do
+    it 'should return sudo prefix' do
+      p = PackageController.new(nil, nil, :sudo => true)
+      expect(p.sudo).to eq("sudo ")
+    end
+
+    it 'should return no sudo prefix' do
+      p = PackageController.new(nil, nil)
+      expect(p.sudo).to eq("")
+    end
+  end
+
+  describe '.init_controller' do
+    it 'should initialize the right package controller' do
+      FakeNode = Struct.new(:platform)
+      node = FakeNode.new("debian")
+      PackageController.init_controller(node, nil, nil)
+    end
+  end
+end

data/spec/package_spec.rb

@@ -0,0 +1,40 @@
+require 'knife-pkg'
+
+include Knife::Pkg
+
+describe 'Package' do
+  describe '#new' do
+    it 'should create an instance of Package' do
+      p = Package.new('test')
+      expect(p).to be_an_instance_of Package
+      expect(p.version).to eq('0.0')
+      expect(p.name).to eq('test')
+    end
+  end
+
+  describe '#version_to_s' do
+    it 'should return the version' do
+      p = Package.new('', '0.0.1')
+      expect(p.version_to_s).to eq('(0.0.1)')
+    end
+
+    it 'should return an empty string if version is not defined' do
+      p = Package.new('')
+      expect(p.version_to_s).to eq('')
+    end
+  end
+
+  describe '#to_s' do
+    it 'should return package name with version' do
+      p = Package.new('test','0.0.1')
+      expect(p.to_s).to eq('test (0.0.1)')
+    end
+
+    it 'should return package without version' do
+      p = Package.new('test')
+      expect(p.to_s).to eq('test')
+    end
+  end
+
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'knife-pkg'
+
+RSpec.configure do |config|
+  config.color_enabled    = true
+  config.formatter        = 'documentation'
+end