cheffish 1.4.1 → 1.4.2

data/lib/cheffish/chef_run.rb

@@ -1,162 +1,162 @@
-require 'cheffish/basic_chef_client'
-
-module Cheffish
-  class ChefRun
-    #
-    # @param chef_config A hash with symbol keys that looks suspiciously similar to `Chef::Config`.
-    #        Some possible options:
-    #        - stdout: <IO object> - where to stream stdout to
-    #        - stderr: <IO object> - where to stream stderr to
-    #        - log_level: :debug|:info|:warn|:error|:fatal
-    #        - log_location: <path|IO object> - where to stream logs to
-    #        - verbose_logging: true|false - true if you want verbose logging in :debug
-    #
-    def initialize(chef_config={})
-      @chef_config = chef_config || {}
-    end
-
-    attr_reader :chef_config
-
-    class StringIOTee < StringIO
-      def initialize(*streams)
-        super()
-        @streams = streams.flatten.select { |s| !s.nil? }
-      end
-
-      attr_reader :streams
-
-      def write(*args, &block)
-        super
-        streams.each { |s| s.write(*args, &block) }
-      end
-    end
-
-    def client
-      @client ||= begin
-        chef_config = self.chef_config.dup
-        chef_config[:log_level] ||= :debug if !chef_config.has_key?(:log_level)
-        chef_config[:verbose_logging] = false if !chef_config.has_key?(:verbose_logging)
-        chef_config[:stdout] = StringIOTee.new(chef_config[:stdout])
-        chef_config[:stderr] = StringIOTee.new(chef_config[:stderr])
-        chef_config[:log_location] = StringIOTee.new(chef_config[:log_location])
-        @client = ::Cheffish::BasicChefClient.new(nil,
-          [ event_sink, Chef::Formatters.new(:doc, chef_config[:stdout], chef_config[:stderr]) ],
-          chef_config
-        )
-      end
-    end
-
-    def event_sink
-      @event_sink ||= EventSink.new
-    end
-
-    #
-    # output
-    #
-    def stdout
-      @client ? client.chef_config[:stdout].string : nil
-    end
-    def stderr
-      @client ? client.chef_config[:stderr].string : nil
-    end
-    def logs
-      @client ? client.chef_config[:log_location].string : nil
-    end
-    def logged_warnings
-      logs.lines.select { |l| l =~ /^\[[^\]]*\] WARN:/ }.join("\n")
-    end
-    def logged_errors
-      logs.lines.select { |l| l =~ /^\[[^\]]*\] ERROR:/ }.join("\n")
-    end
-    def logged_info
-      logs.lines.select { |l| l =~ /^\[[^\]]*\] INFO:/ }.join("\n")
-    end
-
-    def resources
-      client.resource_collection
-    end
-
-    def compile_recipe(&recipe)
-      client.load_block(&recipe)
-    end
-
-    def converge
-      begin
-        client.converge
-        @converged = true
-      rescue RuntimeError => e
-        @raised_exception = e
-        raise
-      end
-    end
-
-    def reset
-      @client = nil
-      @converged = nil
-      @stdout = nil
-      @stderr = nil
-      @logs = nil
-      @raised_exception = nil
-    end
-
-    def converged?
-      !!@converged
-    end
-
-    def converge_failed?
-      @raised_exception.nil? ? false : true
-    end
-
-    def updated?
-      client.updated?
-    end
-
-    def up_to_date?
-      !client.updated?
-    end
-
-    def output_for_failure_message
-      message = ""
-      if stdout && !stdout.empty?
-        message << "---                    ---\n"
-        message << "--- Chef Client Output ---\n"
-        message << "---                    ---\n"
-        message << stdout
-        message << "\n" if !stdout.end_with?("\n")
-      end
-      if stderr && !stderr.empty?
-        message << "---                          ---\n"
-        message << "--- Chef Client Error Output ---\n"
-        message << "---                          ---\n"
-        message << stderr
-        message << "\n" if !stderr.end_with?("\n")
-      end
-      if logs && !logs.empty?
-        message << "---                  ---\n"
-        message << "--- Chef Client Logs ---\n"
-        message << "---                  ---\n"
-        message << logs
-      end
-      message
-    end
-
-    class EventSink
-      def initialize
-        @events = []
-      end
-
-      attr_reader :events
-
-      def method_missing(method, *args)
-        @events << [ method, *args ]
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        # Chef::EventDispatch::Dispatcher calls #respond_to? to see (basically) if we'll accept an event;
-        # obviously, per above #method_missing, we'll accept whatever we're given. if there's a problem, it
-        # will surface higher up the stack.
-        true
-      end
-    end
-  end
-end
+require 'cheffish/basic_chef_client'
+
+module Cheffish
+  class ChefRun
+    #
+    # @param chef_config A hash with symbol keys that looks suspiciously similar to `Chef::Config`.
+    #        Some possible options:
+    #        - stdout: <IO object> - where to stream stdout to
+    #        - stderr: <IO object> - where to stream stderr to
+    #        - log_level: :debug|:info|:warn|:error|:fatal
+    #        - log_location: <path|IO object> - where to stream logs to
+    #        - verbose_logging: true|false - true if you want verbose logging in :debug
+    #
+    def initialize(chef_config={})
+      @chef_config = chef_config || {}
+    end
+
+    attr_reader :chef_config
+
+    class StringIOTee < StringIO
+      def initialize(*streams)
+        super()
+        @streams = streams.flatten.select { |s| !s.nil? }
+      end
+
+      attr_reader :streams
+
+      def write(*args, &block)
+        super
+        streams.each { |s| s.write(*args, &block) }
+      end
+    end
+
+    def client
+      @client ||= begin
+        chef_config = self.chef_config.dup
+        chef_config[:log_level] ||= :debug if !chef_config.has_key?(:log_level)
+        chef_config[:verbose_logging] = false if !chef_config.has_key?(:verbose_logging)
+        chef_config[:stdout] = StringIOTee.new(chef_config[:stdout])
+        chef_config[:stderr] = StringIOTee.new(chef_config[:stderr])
+        chef_config[:log_location] = StringIOTee.new(chef_config[:log_location])
+        @client = ::Cheffish::BasicChefClient.new(nil,
+          [ event_sink, Chef::Formatters.new(:doc, chef_config[:stdout], chef_config[:stderr]) ],
+          chef_config
+        )
+      end
+    end
+
+    def event_sink
+      @event_sink ||= EventSink.new
+    end
+
+    #
+    # output
+    #
+    def stdout
+      @client ? client.chef_config[:stdout].string : nil
+    end
+    def stderr
+      @client ? client.chef_config[:stderr].string : nil
+    end
+    def logs
+      @client ? client.chef_config[:log_location].string : nil
+    end
+    def logged_warnings
+      logs.lines.select { |l| l =~ /^\[[^\]]*\] WARN:/ }.join("\n")
+    end
+    def logged_errors
+      logs.lines.select { |l| l =~ /^\[[^\]]*\] ERROR:/ }.join("\n")
+    end
+    def logged_info
+      logs.lines.select { |l| l =~ /^\[[^\]]*\] INFO:/ }.join("\n")
+    end
+
+    def resources
+      client.resource_collection
+    end
+
+    def compile_recipe(&recipe)
+      client.load_block(&recipe)
+    end
+
+    def converge
+      begin
+        client.converge
+        @converged = true
+      rescue RuntimeError => e
+        @raised_exception = e
+        raise
+      end
+    end
+
+    def reset
+      @client = nil
+      @converged = nil
+      @stdout = nil
+      @stderr = nil
+      @logs = nil
+      @raised_exception = nil
+    end
+
+    def converged?
+      !!@converged
+    end
+
+    def converge_failed?
+      @raised_exception.nil? ? false : true
+    end
+
+    def updated?
+      client.updated?
+    end
+
+    def up_to_date?
+      !client.updated?
+    end
+
+    def output_for_failure_message
+      message = ""
+      if stdout && !stdout.empty?
+        message << "---                    ---\n"
+        message << "--- Chef Client Output ---\n"
+        message << "---                    ---\n"
+        message << stdout
+        message << "\n" if !stdout.end_with?("\n")
+      end
+      if stderr && !stderr.empty?
+        message << "---                          ---\n"
+        message << "--- Chef Client Error Output ---\n"
+        message << "---                          ---\n"
+        message << stderr
+        message << "\n" if !stderr.end_with?("\n")
+      end
+      if logs && !logs.empty?
+        message << "---                  ---\n"
+        message << "--- Chef Client Logs ---\n"
+        message << "---                  ---\n"
+        message << logs
+      end
+      message
+    end
+
+    class EventSink
+      def initialize
+        @events = []
+      end
+
+      attr_reader :events
+
+      def method_missing(method, *args)
+        @events << [ method, *args ]
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        # Chef::EventDispatch::Dispatcher calls #respond_to? to see (basically) if we'll accept an event;
+        # obviously, per above #method_missing, we'll accept whatever we're given. if there's a problem, it
+        # will surface higher up the stack.
+        true
+      end
+    end
+  end
+end

data/lib/cheffish/chef_run_data.rb

@@ -1,19 +1,19 @@
-require 'chef/config'
-require 'cheffish/with_pattern'
-
-module Cheffish
-  class ChefRunData
-    def initialize(config)
-      @local_servers = []
-      @current_chef_server = Cheffish.default_chef_server(config)
-    end
-
-    extend Cheffish::WithPattern
-    with :data_bag
-    with :environment
-    with :data_bag_item_encryption
-    with :chef_server
-
-    attr_reader :local_servers
-  end
-end
+require 'chef/config'
+require 'cheffish/with_pattern'
+
+module Cheffish
+  class ChefRunData
+    def initialize(config)
+      @local_servers = []
+      @current_chef_server = Cheffish.default_chef_server(config)
+    end
+
+    extend Cheffish::WithPattern
+    with :data_bag
+    with :environment
+    with :data_bag_item_encryption
+    with :chef_server
+
+    attr_reader :local_servers
+  end
+end

data/lib/cheffish/chef_run_listener.rb

@@ -1,30 +1,30 @@
-require 'chef/event_dispatch/base'
-
-module Cheffish
-  class ChefRunListener < Chef::EventDispatch::Base
-    def initialize(node)
-      @node = node
-    end
-
-    attr_reader :node
-
-    def run_complete(node)
-      disconnect
-    end
-
-    def run_failed(exception)
-      disconnect
-    end
-
-    private
-
-    def disconnect
-      # Stop the servers
-      if node.run_context
-        node.run_context.cheffish.local_servers.each do |server|
-          server.stop
-        end
-      end
-    end
-  end
-end
+require 'chef/event_dispatch/base'
+
+module Cheffish
+  class ChefRunListener < Chef::EventDispatch::Base
+    def initialize(node)
+      @node = node
+    end
+
+    attr_reader :node
+
+    def run_complete(node)
+      disconnect
+    end
+
+    def run_failed(exception)
+      disconnect
+    end
+
+    private
+
+    def disconnect
+      # Stop the servers
+      if node.run_context
+        node.run_context.cheffish.local_servers.each do |server|
+          server.stop
+        end
+      end
+    end
+  end
+end

data/lib/cheffish/key_formatter.rb

@@ -1,113 +1,113 @@
-require 'openssl'
-require 'net/ssh'
-require 'etc'
-require 'socket'
-require 'digest/md5'
-require 'base64'
-
-module Cheffish
-  class KeyFormatter
-    # Returns nil or key, format
-    def self.decode(str, pass_phrase=nil, filename='')
-      key_format = {}
-      key_format[:format] = format_of(str)
-
-      case key_format[:format]
-      when :openssh
-        key = decode_openssh_key(str, filename)
-      else
-        begin
-          key = OpenSSL::PKey.read(str) { pass_phrase }
-        rescue
-          return nil
-        end
-      end
-
-      key_format[:type] = type_of(key)
-      key_format[:size] = size_of(key) if size_of(key)
-      key_format[:pass_phrase] = pass_phrase if pass_phrase
-      # TODO cipher, exponent
-
-      [key, key_format]
-    end
-
-    def self.encode(key, key_format)
-      format = key_format[:format] || :pem
-      case format
-      when :openssh
-        encode_openssh_key(key)
-      when :pem
-        if key_format[:pass_phrase]
-          cipher = key_format[:cipher] || 'DES-EDE3-CBC'
-          key.to_pem(OpenSSL::Cipher.new(cipher), key_format[:pass_phrase])
-        else
-          key.to_pem
-        end
-      when :der
-        key.to_der
-      when :fingerprint, :pkcs1md5fingerprint
-        hexes = Digest::MD5.hexdigest(key.to_der)
-        # Put : between every pair of hexes
-        hexes.scan(/../).join(':')
-      when :rfc4716md5fingerprint
-        type, base64_data, etc = encode_openssh_key(key).split
-        data = Base64.decode64(base64_data)
-        hexes = Digest::MD5.hexdigest(data)
-        hexes.scan(/../).join(':')
-      when :pkcs8sha1fingerprint
-        if RUBY_VERSION.to_f >= 2.0
-          raise "PKCS8 SHA1 not supported in Ruby #{RUBY_VERSION}"
-        end
-        require 'openssl_pkcs8'
-        pkcs8_pem = key.to_pem_pkcs8
-        pkcs8_base64 = pkcs8_pem.split("\n").reject { |l| l =~ /^-----/ }
-        pkcs8_data = Base64.decode64(pkcs8_base64.join)
-        hexes = Digest::SHA1.hexdigest(pkcs8_data)
-        hexes.scan(/../).join(':')
-      else
-        raise "Unrecognized key format #{format}"
-      end
-    end
-
-    private
-
-    def self.encode_openssh_key(key)
-      # TODO there really isn't a method somewhere in net/ssh or openssl that does this??
-      type = key.ssh_type
-      data = [ key.to_blob ].pack('m0')
-      "#{type} #{data} #{Etc.getlogin}@#{Socket.gethostname}"
-    end
-
-    def self.decode_openssh_key(str, filename='')
-      Net::SSH::KeyFactory.load_data_public_key(str, filename)
-    end
-
-    def self.format_of(key_contents)
-      if key_contents.start_with?('-----BEGIN ')
-        :pem
-      elsif key_contents.start_with?('ssh-rsa ') || key_contents.start_with?('ssh-dss ')
-        :openssh
-      else
-        :der
-      end
-    end
-
-    def self.type_of(key)
-      case key.class
-      when OpenSSL::PKey::RSA
-        :rsa
-      when OpenSSL::PKey::DSA
-        :dsa
-      end
-    end
-
-    def self.size_of(key)
-      case key.class
-      when OpenSSL::PKey::RSA
-        key.n.num_bytes * 8
-      else
-        nil
-      end
-    end
-  end
-end
+require 'openssl'
+require 'net/ssh'
+require 'etc'
+require 'socket'
+require 'digest/md5'
+require 'base64'
+
+module Cheffish
+  class KeyFormatter
+    # Returns nil or key, format
+    def self.decode(str, pass_phrase=nil, filename='')
+      key_format = {}
+      key_format[:format] = format_of(str)
+
+      case key_format[:format]
+      when :openssh
+        key = decode_openssh_key(str, filename)
+      else
+        begin
+          key = OpenSSL::PKey.read(str) { pass_phrase }
+        rescue
+          return nil
+        end
+      end
+
+      key_format[:type] = type_of(key)
+      key_format[:size] = size_of(key) if size_of(key)
+      key_format[:pass_phrase] = pass_phrase if pass_phrase
+      # TODO cipher, exponent
+
+      [key, key_format]
+    end
+
+    def self.encode(key, key_format)
+      format = key_format[:format] || :pem
+      case format
+      when :openssh
+        encode_openssh_key(key)
+      when :pem
+        if key_format[:pass_phrase]
+          cipher = key_format[:cipher] || 'DES-EDE3-CBC'
+          key.to_pem(OpenSSL::Cipher.new(cipher), key_format[:pass_phrase])
+        else
+          key.to_pem
+        end
+      when :der
+        key.to_der
+      when :fingerprint, :pkcs1md5fingerprint
+        hexes = Digest::MD5.hexdigest(key.to_der)
+        # Put : between every pair of hexes
+        hexes.scan(/../).join(':')
+      when :rfc4716md5fingerprint
+        type, base64_data, etc = encode_openssh_key(key).split
+        data = Base64.decode64(base64_data)
+        hexes = Digest::MD5.hexdigest(data)
+        hexes.scan(/../).join(':')
+      when :pkcs8sha1fingerprint
+        if RUBY_VERSION.to_f >= 2.0
+          raise "PKCS8 SHA1 not supported in Ruby #{RUBY_VERSION}"
+        end
+        require 'openssl_pkcs8'
+        pkcs8_pem = key.to_pem_pkcs8
+        pkcs8_base64 = pkcs8_pem.split("\n").reject { |l| l =~ /^-----/ }
+        pkcs8_data = Base64.decode64(pkcs8_base64.join)
+        hexes = Digest::SHA1.hexdigest(pkcs8_data)
+        hexes.scan(/../).join(':')
+      else
+        raise "Unrecognized key format #{format}"
+      end
+    end
+
+    private
+
+    def self.encode_openssh_key(key)
+      # TODO there really isn't a method somewhere in net/ssh or openssl that does this??
+      type = key.ssh_type
+      data = [ key.to_blob ].pack('m0')
+      "#{type} #{data} #{Etc.getlogin}@#{Socket.gethostname}"
+    end
+
+    def self.decode_openssh_key(str, filename='')
+      Net::SSH::KeyFactory.load_data_public_key(str, filename)
+    end
+
+    def self.format_of(key_contents)
+      if key_contents.start_with?('-----BEGIN ')
+        :pem
+      elsif key_contents.start_with?('ssh-rsa ') || key_contents.start_with?('ssh-dss ')
+        :openssh
+      else
+        :der
+      end
+    end
+
+    def self.type_of(key)
+      case key.class
+      when OpenSSL::PKey::RSA
+        :rsa
+      when OpenSSL::PKey::DSA
+        :dsa
+      end
+    end
+
+    def self.size_of(key)
+      case key.class
+      when OpenSSL::PKey::RSA
+        key.n.num_bytes * 8
+      else
+        nil
+      end
+    end
+  end
+end