cheffish 1.4.0 → 1.4.1

data/lib/cheffish/actor_provider_base.rb

@@ -1,131 +1,131 @@
-require 'cheffish/key_formatter'
-require 'cheffish/chef_provider_base'
-
-class Cheffish::ActorProviderBase < Cheffish::ChefProviderBase
-
-  def create_actor
-    if new_resource.before
-      new_resource.before.call(new_resource)
-    end
-
-    # Create or update the client/user
-    current_public_key = new_json['public_key']
-    differences = json_differences(current_json, new_json)
-    if current_resource_exists?
-      # Update the actor if it's different
-      if differences.size > 0
-        description = [ "update #{actor_type} #{new_resource.name} at #{actor_path}" ] + differences
-        converge_by description do
-          result = rest.put("#{actor_path}/#{new_resource.name}", normalize_for_put(new_json))
-          current_public_key, current_public_key_format = Cheffish::KeyFormatter.decode(result['public_key']) if result['public_key']
-        end
-      end
-    else
-      # Create the actor if it's missing
-      if !new_public_key
-        raise "You must specify a public key to create a #{actor_type}!  Use the private_key resource to create a key, and pass it in with source_key_path."
-      end
-      description = [ "create #{actor_type} #{new_resource.name} at #{actor_path}" ] + differences
-      converge_by description do
-        result = rest.post("#{actor_path}", normalize_for_post(new_json))
-        current_public_key, current_public_key_format = Cheffish::KeyFormatter.decode(result['public_key']) if result['public_key']
-      end
-    end
-
-    # Write out the public key
-    if new_resource.output_key_path
-      # TODO use inline_resource
-      key_content = Cheffish::KeyFormatter.encode(current_public_key, { :format => new_resource.output_key_format })
-      if !current_resource.output_key_path
-        action = 'create'
-      elsif key_content != IO.read(current_resource.output_key_path)
-        action = 'overwrite'
-      else
-        action = nil
-      end
-      if action
-        converge_by "#{action} public key #{new_resource.output_key_path}" do
-          IO.write(new_resource.output_key_path, key_content)
-        end
-      end
-      # TODO permissions?
-    end
-
-    if new_resource.after
-      new_resource.after.call(self, new_json, server_private_key, server_public_key)
-    end
-  end
-
-  def delete_actor
-    if current_resource_exists?
-      converge_by "delete #{actor_type} #{new_resource.name} at #{actor_path}" do
-        rest.delete("#{actor_path}/#{new_resource.name}")
-        Chef::Log.info("#{new_resource} deleted #{actor_type} #{new_resource.name} at #{rest.url}")
-      end
-    end
-    if current_resource.output_key_path
-      converge_by "delete public key #{current_resource.output_key_path}" do
-        ::File.unlink(current_resource.output_key_path)
-      end
-    end
-  end
-
-  def new_public_key
-    @new_public_key ||= begin
-      if new_resource.source_key
-        if new_resource.source_key.is_a?(String)
-          key, key_format = Cheffish::KeyFormatter.decode(new_resource.source_key)
-
-          if key.private?
-            key.public_key
-          else
-            key
-          end
-        elsif new_resource.source_key.private?
-          new_resource.source_key.public_key
-        else
-          new_resource.source_key
-        end
-      elsif new_resource.source_key_path
-        source_key_path = new_resource.source_key_path
-        if Pathname.new(source_key_path).relative?
-          source_key_str, source_key_path = Cheffish.get_private_key_with_path(source_key_path, run_context.config)
-        else
-          source_key_str = IO.read(source_key_path)
-        end
-        source_key, source_key_format = Cheffish::KeyFormatter.decode(source_key_str, new_resource.source_key_pass_phrase, source_key_path)
-        if source_key.private?
-          source_key.public_key
-        else
-          source_key
-        end
-      else
-        nil
-      end
-    end
-  end
-
-  def augment_new_json(json)
-    if new_public_key
-      json['public_key'] = new_public_key.to_pem
-    end
-    json
-  end
-
-  def load_current_resource
-    begin
-      json = rest.get("#{actor_path}/#{new_resource.name}")
-      @current_resource = json_to_resource(json)
-    rescue Net::HTTPServerException => e
-      if e.response.code == "404"
-        @current_resource = not_found_resource
-      else
-        raise
-      end
-    end
-
-    if new_resource.output_key_path && ::File.exist?(new_resource.output_key_path)
-      current_resource.output_key_path = new_resource.output_key_path
-    end
-  end
-end
+require 'cheffish/key_formatter'
+require 'cheffish/chef_provider_base'
+
+class Cheffish::ActorProviderBase < Cheffish::ChefProviderBase
+
+  def create_actor
+    if new_resource.before
+      new_resource.before.call(new_resource)
+    end
+
+    # Create or update the client/user
+    current_public_key = new_json['public_key']
+    differences = json_differences(current_json, new_json)
+    if current_resource_exists?
+      # Update the actor if it's different
+      if differences.size > 0
+        description = [ "update #{actor_type} #{new_resource.name} at #{actor_path}" ] + differences
+        converge_by description do
+          result = rest.put("#{actor_path}/#{new_resource.name}", normalize_for_put(new_json))
+          current_public_key, current_public_key_format = Cheffish::KeyFormatter.decode(result['public_key']) if result['public_key']
+        end
+      end
+    else
+      # Create the actor if it's missing
+      if !new_public_key
+        raise "You must specify a public key to create a #{actor_type}!  Use the private_key resource to create a key, and pass it in with source_key_path."
+      end
+      description = [ "create #{actor_type} #{new_resource.name} at #{actor_path}" ] + differences
+      converge_by description do
+        result = rest.post("#{actor_path}", normalize_for_post(new_json))
+        current_public_key, current_public_key_format = Cheffish::KeyFormatter.decode(result['public_key']) if result['public_key']
+      end
+    end
+
+    # Write out the public key
+    if new_resource.output_key_path
+      # TODO use inline_resource
+      key_content = Cheffish::KeyFormatter.encode(current_public_key, { :format => new_resource.output_key_format })
+      if !current_resource.output_key_path
+        action = 'create'
+      elsif key_content != IO.read(current_resource.output_key_path)
+        action = 'overwrite'
+      else
+        action = nil
+      end
+      if action
+        converge_by "#{action} public key #{new_resource.output_key_path}" do
+          IO.write(new_resource.output_key_path, key_content)
+        end
+      end
+      # TODO permissions?
+    end
+
+    if new_resource.after
+      new_resource.after.call(self, new_json, server_private_key, server_public_key)
+    end
+  end
+
+  def delete_actor
+    if current_resource_exists?
+      converge_by "delete #{actor_type} #{new_resource.name} at #{actor_path}" do
+        rest.delete("#{actor_path}/#{new_resource.name}")
+        Chef::Log.info("#{new_resource} deleted #{actor_type} #{new_resource.name} at #{rest.url}")
+      end
+    end
+    if current_resource.output_key_path
+      converge_by "delete public key #{current_resource.output_key_path}" do
+        ::File.unlink(current_resource.output_key_path)
+      end
+    end
+  end
+
+  def new_public_key
+    @new_public_key ||= begin
+      if new_resource.source_key
+        if new_resource.source_key.is_a?(String)
+          key, key_format = Cheffish::KeyFormatter.decode(new_resource.source_key)
+
+          if key.private?
+            key.public_key
+          else
+            key
+          end
+        elsif new_resource.source_key.private?
+          new_resource.source_key.public_key
+        else
+          new_resource.source_key
+        end
+      elsif new_resource.source_key_path
+        source_key_path = new_resource.source_key_path
+        if Pathname.new(source_key_path).relative?
+          source_key_str, source_key_path = Cheffish.get_private_key_with_path(source_key_path, run_context.config)
+        else
+          source_key_str = IO.read(source_key_path)
+        end
+        source_key, source_key_format = Cheffish::KeyFormatter.decode(source_key_str, new_resource.source_key_pass_phrase, source_key_path)
+        if source_key.private?
+          source_key.public_key
+        else
+          source_key
+        end
+      else
+        nil
+      end
+    end
+  end
+
+  def augment_new_json(json)
+    if new_public_key
+      json['public_key'] = new_public_key.to_pem
+    end
+    json
+  end
+
+  def load_current_resource
+    begin
+      json = rest.get("#{actor_path}/#{new_resource.name}")
+      @current_resource = json_to_resource(json)
+    rescue Net::HTTPServerException => e
+      if e.response.code == "404"
+        @current_resource = not_found_resource
+      else
+        raise
+      end
+    end
+
+    if new_resource.output_key_path && ::File.exist?(new_resource.output_key_path)
+      current_resource.output_key_path = new_resource.output_key_path
+    end
+  end
+end

data/lib/cheffish/basic_chef_client.rb

@@ -1,184 +1,184 @@
-require 'cheffish/version'
-require 'chef/dsl/recipe'
-require 'chef/event_dispatch/base'
-require 'chef/event_dispatch/dispatcher'
-require 'chef/node'
-require 'chef/run_context'
-require 'chef/runner'
-require 'forwardable'
-require 'chef/providers'
-require 'chef/resources'
-
-module Cheffish
-  class BasicChefClient
-    include Chef::DSL::Recipe
-
-    def initialize(node = nil, events = nil, **chef_config)
-      if !node
-        node = Chef::Node.new
-        node.name 'basic_chef_client'
-        node.automatic[:platform] = 'basic_chef_client'
-        node.automatic[:platform_version] = Cheffish::VERSION
-      end
-
-      # Decide on the config we want for this chef client
-      @chef_config = chef_config
-
-      with_chef_config do
-        @cookbook_name = 'basic_chef_client'
-        @event_catcher = BasicChefClientEvents.new
-        dispatcher = Chef::EventDispatch::Dispatcher.new(@event_catcher)
-        case events
-        when nil
-        when Array
-          events.each { |e| dispatcher.register(e) } if events
-        else
-          dispatcher.register(events)
-        end
-        @run_context = Chef::RunContext.new(node, {}, dispatcher)
-        @updated = []
-        @cookbook_name = 'basic_chef_client'
-      end
-    end
-
-    extend Forwardable
-
-    # Stuff recipes need
-    attr_reader :chef_config
-    attr_reader :run_context
-    attr_accessor :cookbook_name
-    attr_accessor :recipe_name
-    def_delegators :@run_context, :resource_collection, :immediate_notifications, :delayed_notifications
-
-    def add_resource(resource)
-      with_chef_config do
-        resource.run_context = run_context
-        run_context.resource_collection.insert(resource)
-      end
-    end
-
-    def load_block(&block)
-      with_chef_config do
-        @recipe_name = 'block'
-        instance_eval(&block)
-      end
-    end
-
-    def converge
-      with_chef_config do
-        Chef::Runner.new(self).converge
-      end
-    end
-
-    def updates
-      @event_catcher.updates
-    end
-
-    def updated?
-      @event_catcher.updates.size > 0
-    end
-
-    # Builds a resource sans context, which can be later used in a new client's
-    # add_resource() method.
-    def self.build_resource(type, name, created_at=nil, &resource_attrs_block)
-      created_at ||= caller[0]
-      result = BasicChefClient.new.tap do |client|
-        client.with_chef_config do
-          client.build_resource(type, name, created_at, &resource_attrs_block)
-        end
-      end
-      result
-    end
-
-    def self.inline_resource(provider, provider_action, *resources, &block)
-      events = ProviderEventForwarder.new(provider, provider_action)
-      client = BasicChefClient.new(provider.node, events)
-      client.with_chef_config do
-        resources.each do |resource|
-          client.add_resource(resource)
-        end
-      end
-      client.load_block(&block) if block
-      client.converge
-      client.updated?
-    end
-
-    def self.converge_block(node = nil, events = nil, &block)
-      client = BasicChefClient.new(node, events)
-      client.load_block(&block)
-      client.converge
-      client.updated?
-    end
-
-    def with_chef_config(&block)
-      old_chef_config = Chef::Config.save
-      if chef_config[:log_location]
-        old_loggers = Chef::Log.loggers
-        Chef::Log.init(chef_config[:log_location])
-      end
-      if chef_config[:log_level]
-        old_level = Chef::Log.level
-        Chef::Log.level(chef_config[:log_level])
-      end
-      # if chef_config[:stdout]
-      #   old_stdout = $stdout
-      #   $stdout = chef_config[:stdout]
-      # end
-      # if chef_config[:stderr]
-      #   old_stderr = $stderr
-      #   $stderr = chef_config[:stderr]
-      # end
-      begin
-        deep_merge_config(chef_config, Chef::Config)
-        block.call
-      ensure
-        # $stdout = old_stdout if chef_config[:stdout]
-        # $stderr = old_stderr if chef_config[:stderr]
-        if old_loggers
-          Chef::Log.logger = old_loggers.shift
-          old_loggers.each { |l| Chef::Log.loggers.push(l) }
-        elsif chef_config[:log_level]
-          Chef::Log.level = old_level
-        end
-        Chef::Config.restore(old_chef_config)
-      end
-    end
-
-    def deep_merge_config(src, dest)
-      src.each do |name, value|
-        if value.is_a?(Hash) && dest[name].is_a?(Hash)
-          deep_merge_config(value, dest[name])
-        else
-          dest[name] = value
-        end
-      end
-    end
-
-    class BasicChefClientEvents < Chef::EventDispatch::Base
-      def initialize
-        @updates = []
-      end
-
-      attr_reader :updates
-
-      # Called after a resource has been completely converged.
-      def resource_updated(resource, action)
-        updates << [ resource, action ]
-      end
-    end
-
-    class ProviderEventForwarder < Chef::EventDispatch::Base
-      def initialize(provider, provider_action)
-        @provider = provider
-        @provider_action = provider_action
-      end
-
-      attr_reader :provider
-      attr_reader :provider_action
-
-      def resource_update_applied(resource, action, update)
-        provider.run_context.events.resource_update_applied(provider.new_resource, provider_action, update)
-      end
-    end
-  end
-end
+require 'cheffish/version'
+require 'chef/dsl/recipe'
+require 'chef/event_dispatch/base'
+require 'chef/event_dispatch/dispatcher'
+require 'chef/node'
+require 'chef/run_context'
+require 'chef/runner'
+require 'forwardable'
+require 'chef/providers'
+require 'chef/resources'
+
+module Cheffish
+  class BasicChefClient
+    include Chef::DSL::Recipe
+
+    def initialize(node = nil, events = nil, **chef_config)
+      if !node
+        node = Chef::Node.new
+        node.name 'basic_chef_client'
+        node.automatic[:platform] = 'basic_chef_client'
+        node.automatic[:platform_version] = Cheffish::VERSION
+      end
+
+      # Decide on the config we want for this chef client
+      @chef_config = chef_config
+
+      with_chef_config do
+        @cookbook_name = 'basic_chef_client'
+        @event_catcher = BasicChefClientEvents.new
+        dispatcher = Chef::EventDispatch::Dispatcher.new(@event_catcher)
+        case events
+        when nil
+        when Array
+          events.each { |e| dispatcher.register(e) } if events
+        else
+          dispatcher.register(events)
+        end
+        @run_context = Chef::RunContext.new(node, {}, dispatcher)
+        @updated = []
+        @cookbook_name = 'basic_chef_client'
+      end
+    end
+
+    extend Forwardable
+
+    # Stuff recipes need
+    attr_reader :chef_config
+    attr_reader :run_context
+    attr_accessor :cookbook_name
+    attr_accessor :recipe_name
+    def_delegators :@run_context, :resource_collection, :immediate_notifications, :delayed_notifications
+
+    def add_resource(resource)
+      with_chef_config do
+        resource.run_context = run_context
+        run_context.resource_collection.insert(resource)
+      end
+    end
+
+    def load_block(&block)
+      with_chef_config do
+        @recipe_name = 'block'
+        instance_eval(&block)
+      end
+    end
+
+    def converge
+      with_chef_config do
+        Chef::Runner.new(self).converge
+      end
+    end
+
+    def updates
+      @event_catcher.updates
+    end
+
+    def updated?
+      @event_catcher.updates.size > 0
+    end
+
+    # Builds a resource sans context, which can be later used in a new client's
+    # add_resource() method.
+    def self.build_resource(type, name, created_at=nil, &resource_attrs_block)
+      created_at ||= caller[0]
+      result = BasicChefClient.new.tap do |client|
+        client.with_chef_config do
+          client.build_resource(type, name, created_at, &resource_attrs_block)
+        end
+      end
+      result
+    end
+
+    def self.inline_resource(provider, provider_action, *resources, &block)
+      events = ProviderEventForwarder.new(provider, provider_action)
+      client = BasicChefClient.new(provider.node, events)
+      client.with_chef_config do
+        resources.each do |resource|
+          client.add_resource(resource)
+        end
+      end
+      client.load_block(&block) if block
+      client.converge
+      client.updated?
+    end
+
+    def self.converge_block(node = nil, events = nil, &block)
+      client = BasicChefClient.new(node, events)
+      client.load_block(&block)
+      client.converge
+      client.updated?
+    end
+
+    def with_chef_config(&block)
+      old_chef_config = Chef::Config.save
+      if chef_config[:log_location]
+        old_loggers = Chef::Log.loggers
+        Chef::Log.init(chef_config[:log_location])
+      end
+      if chef_config[:log_level]
+        old_level = Chef::Log.level
+        Chef::Log.level(chef_config[:log_level])
+      end
+      # if chef_config[:stdout]
+      #   old_stdout = $stdout
+      #   $stdout = chef_config[:stdout]
+      # end
+      # if chef_config[:stderr]
+      #   old_stderr = $stderr
+      #   $stderr = chef_config[:stderr]
+      # end
+      begin
+        deep_merge_config(chef_config, Chef::Config)
+        block.call
+      ensure
+        # $stdout = old_stdout if chef_config[:stdout]
+        # $stderr = old_stderr if chef_config[:stderr]
+        if old_loggers
+          Chef::Log.logger = old_loggers.shift
+          old_loggers.each { |l| Chef::Log.loggers.push(l) }
+        elsif chef_config[:log_level]
+          Chef::Log.level = old_level
+        end
+        Chef::Config.restore(old_chef_config)
+      end
+    end
+
+    def deep_merge_config(src, dest)
+      src.each do |name, value|
+        if value.is_a?(Hash) && dest[name].is_a?(Hash)
+          deep_merge_config(value, dest[name])
+        else
+          dest[name] = value
+        end
+      end
+    end
+
+    class BasicChefClientEvents < Chef::EventDispatch::Base
+      def initialize
+        @updates = []
+      end
+
+      attr_reader :updates
+
+      # Called after a resource has been completely converged.
+      def resource_updated(resource, action)
+        updates << [ resource, action ]
+      end
+    end
+
+    class ProviderEventForwarder < Chef::EventDispatch::Base
+      def initialize(provider, provider_action)
+        @provider = provider
+        @provider_action = provider_action
+      end
+
+      attr_reader :provider
+      attr_reader :provider_action
+
+      def resource_update_applied(resource, action, update)
+        provider.run_context.events.resource_update_applied(provider.new_resource, provider_action, update)
+      end
+    end
+  end
+end