chef-resource 0.2.2

data/files/lib/chef_resource/chef_dsl/chef_resource_log.rb

@@ -0,0 +1,54 @@
+require 'chef/log'
+
+module ChefResource
+  module ChefDSL
+    #
+    # Handles events from the ChefResource Resource model and spits the data out
+    # to Chef for pretty green text.
+    #
+    class ChefResourceLog < ChefResource::Resource::ResourceLog
+      def log(level, str)
+        Chef::Log.public_send(level, "#{resource.resource_short_name} #{str}")
+      end
+
+      def action
+        resource.action[0]
+      end
+
+      # When load happens, notify Chef that the resource's current state is loaded.
+      def load_succeeded
+        super
+        resource.events.resource_current_state_loaded(resource, action, resource.current_resource)
+      end
+
+      # When an update succeeds, we mark the resource
+      def update_succeeded
+        super
+
+        if resource.updated_by_last_action?
+          resource.events.resource_updated(resource, action)
+        else
+          resource.events.resource_up_to_date(resource, action)
+        end
+      end
+
+      def action_skipped(description, update_guaranteed: true)
+        super
+
+        if update_guaranteed
+          resource.events.resource_update_applied(resource, action, description)
+          resource.updated_by_last_action true
+        end
+      end
+
+      # When an action succeeds, we mark the resource updated if it did anything.
+      def action_succeeded(**args)
+        description, updated = super
+        if updated
+          resource.events.resource_update_applied(resource, action, description)
+          resource.updated_by_last_action true
+        end
+      end
+    end
+  end
+end

data/files/lib/chef_resource/chef_dsl/resource_container_module.rb

@@ -0,0 +1,80 @@
+module ChefResource
+  module ChefDSL
+    module ResourceContainerModule
+      attr_reader :recipe_dsl_module
+
+      def resource_types
+        @resource_types ||= {}
+      end
+
+      # TODO also run this after libraries/ are parsed, and perhaps when method_missing
+      # is triggered.
+      def update_resource_definition_methods!
+        const_module = self
+
+        # Go through the constants in the module, trawling for Resources
+        seen = []
+        const_module.constants.each do |class_name|
+          resource_class = const_module.const_get(class_name)
+          next if !resource_class.is_a?(Class)
+          next if !(resource_class <= Chef::Resource)
+
+          resource_name = resource_class.dsl_name
+
+          seen << resource_name
+
+          # Detect conflicts: two Resources with the same resource_name
+          current_class_name = resource_types[resource_name]
+          if current_class_name != class_name
+            if current_class_name && const_module.const_defined?(current_class_name)
+              current_resource = const_module.const_get(current_class_name)
+              if current_resource != resource_class && current_resource.is_a?(Class) && current_resource <= Chef::Resource && current_resource_name == resource_name
+                raise "Both #{current_class_name} and #{class_name} map to #{resource_name}.  Choose a different dsl_name for one of them!"
+              end
+            end
+
+            # We don't overwrite real methods in the recipe DSL (if any?)
+            if !current_class_name && method_defined?(resource_name)
+              raise "Method #{resource_name} already exists in #{recipe_dsl_module}!  Not overwriting with resource definition for #{class_name}."
+            end
+
+            # Create / overwrite the current methods
+            emit_resource_definition_method(resource_name, class_name, resource_class)
+
+            resource_types[resource_name] = class_name
+          end
+        end
+
+        # Remove methods for constants that no longer exist
+        (seen - resource_types.keys).each do |resource_name|
+          const_module.remove_method(resource_name)
+          resource_types.delete(resource_name)
+        end
+      end
+
+      def emit_resource_definition_method(resource_name, class_name, actual_class)
+        # TODO handle definitions too?
+        if actual_class <= ChefResource::Resource
+          recipe_dsl_module.module_eval <<-EOM, __FILE__, __LINE__+1
+            def #{resource_name}(*identity, &update_block)
+              # TODO fix Chef: let declare_resource take the resource class
+              if update_block
+                declare_resource(#{actual_class.name}, *identity, caller[0], &update_block)
+              else
+                # If you don't pass a block, we assume you just wanted to construct
+                # a resource to use for reading.
+                build_resource(#{actual_class.name}, *identity, caller[0])
+              end
+            end
+          EOM
+        # else
+        #   recipe_dsl_module.module_eval <<-EOM, __FILE__, __LINE__+1
+        #     def #{resource_name}(name, &block)
+        #       declare_resource(#{resource_name.inspect}, name, caller[0], &block)
+        #     end
+        #   EOM
+        end
+      end
+    end
+  end
+end

data/files/lib/chef_resource/chef_dsl/resource_definition_dsl.rb

@@ -0,0 +1,128 @@
+require 'chef_resource/chef_dsl/chef_resource_extensions'
+require 'chef_resource/chef_dsl/chef_resource_class_extensions'
+require 'chef_resource/chef_dsl/chef_resource_base'
+require 'chef_resource/camel_case'
+require 'chef_resource/resource'
+require 'chef/dsl/recipe'
+require 'chef/resource'
+
+module ChefResource
+  module ChefDSL
+    #
+    # DSL for defining resources
+    #
+    module ResourceDefinitionDSL
+      #
+      # Create a new resource type under `Chef::Resource`.
+      #
+      # @param name [Symbol,String] The name of the resource (e.g. :my_resource)
+      # @param base_resource_class [Class,Symbol,String] The base resource class.
+      #   The new resource will derive from this base resource, and will have
+      #   all the same properties.  If a symbol or a string is passed, the name
+      #   (e.g. `:resource_name`) is searched for under Chef::Resource.
+      # @param class_name [Symbol,String] The name of the class to create under
+      #   Chef::Resource. If not specified, `name` is converted to a class name
+      #   (e.g. resource_name -> ResourceName).
+      # @param overwrite_resource [Boolean] Whether to overwrite the resource if
+      #   it already exists.  If set to `true`, and the resource class already
+      #   exists, it will be removed and re-created according to the new resource
+      #   definition.  Defaults to false.
+      # @param override_block A block that will be run in the context of the new
+      #   class, allowing you to type `property :name ...` and `recipe do`,
+      #   as well as `def self.blah` and `def blah`.
+      #
+      # @raise If the resource class already exists and `overwrite_resource` is
+      #   set to `false`.
+      #
+      # @example
+      #
+      # resource :resource_name, Chef::Resource::File do
+      #   property :mode, Fixnum, default: 0666
+      # end
+      #
+      def resource(name, base_resource_class=nil, class_name: nil, overwrite_resource: false, &override_block)
+        base_resource_class = ResourceDefinitionDSL.base_resource_class_for(base_resource_class)
+
+        name = name.to_sym
+        class_name ||= CamelCase.from_snake_case(name)
+
+        if Chef::Resource.const_defined?(class_name, false)
+          if overwrite_resource
+            Chef::Resource.const_set(class_name, nil)
+          else
+            raise "Cannot redefine resource #{name}, because Chef::Resource::#{class_name} already exists!  Pass overwrite_resource: true if you really meant to overwrite."
+          end
+        end
+
+        resource_class = Chef::Resource.class_eval <<-EOM, __FILE__, __LINE__+1
+          class #{class_name} < base_resource_class
+            if !(self <= ChefResource::ChefDSL::ChefResourceExtensions)
+              include ChefResource::ChefDSL::ChefResourceExtensions
+              extend ChefResource::ChefDSL::ChefResourceClassExtensions
+            end
+            self
+          end
+        EOM
+        resource_class.class_eval(&override_block)
+        Chef::Resource.update_resource_definition_methods!
+        resource_class
+      end
+
+      #
+      # ChefResource.defaults :my_file, :file, mode: 0666, owner: 'jkeiser'
+      #
+      def defaults(name, old_name=name, **defaults)
+        base_resource_class = ResourceDefinitionDSL.base_resource_class_for(old_name)
+        if base_resource_class.is_a?(ChefResource::Resource)
+          resource(name, base_resource_class, overwrite_resource: true) do
+            defaults.each do |name, value|
+              property name, default: value
+            end
+          end
+        else
+          Chef::DSL::Recipe.send(:define_method, name) do |name, &block|
+            declare_resource(old_name, name, caller[0]) do
+              defaults.each do |name, value|
+                public_send(name, value)
+              end
+            end
+          end
+        end
+      end
+
+      #
+      # ChefResource.define :resource_name, a: 1, b: 2 do
+      #   file 'x.txt' do
+      #     content 'hi'
+      #   end
+      # end
+      #
+      def define(name, *identity_params, overwrite_resource: true, **params, &recipe_block)
+        resource name do
+          identity_params.each do |name|
+            property name, identity: true
+          end
+          params.each do |name, value|
+            property name, default: value
+          end
+          recipe(&recipe_block)
+        end
+      end
+
+      private
+
+      def self.base_resource_class_for(base_resource_class)
+        case base_resource_class
+        when Class
+          # resource_class is a-ok if it's already a Class
+          base_resource_class
+        when nil
+          ChefResource::ChefDSL::ChefResourceBase
+        else
+          resource_class_name = CamelCase.from_snake_case(base_resource_class.to_s)
+          eval("Chef::Resource::#{resource_class_name}")
+        end
+      end
+    end
+  end
+end

data/files/lib/chef_resource/constants.rb

@@ -0,0 +1,8 @@
+module ChefResource
+  NOT_PASSED = Object.new
+  NOT_PASSED.instance_eval do
+    def to_s
+      "NOT_PASSED"
+    end
+  end
+end

data/files/lib/chef_resource/errors.rb

@@ -0,0 +1,31 @@
+module ChefResource
+  class ValidationError < StandardError
+    def initialize(message, value)
+      super("#{value} #{message}")
+      @value = value
+    end
+    attr_reader :value
+  end
+
+  class MustNotBeNullError < ValidationError
+  end
+
+  class ResourceStateError < StandardError
+    def initialize(message, resource)
+      super(message)
+      @resource = resource
+    end
+    attr_reader :resource
+  end
+
+  class ResourceCannotBeOpenedError < ResourceStateError
+  end
+
+  class PropertyDefinedError < ResourceStateError
+    def initialize(message, resource, property_type)
+      super(message, resource)
+      @property_type = property_type
+    end
+    attr_reader :property_type
+  end
+end

data/files/lib/chef_resource/lazy_proc.rb

@@ -0,0 +1,82 @@
+require 'chef_resource/constants'
+require 'chef_resource/simple_struct'
+
+module ChefResource
+  class LazyProc < Proc
+    #
+    # Create a new LazyProc
+    #
+    # @param switches A list of switches to turn on.
+    #   - :should_instance_eval: true if instance_eval is expected, false if
+    #     disallowed.  Default: false, except for type attributes like "default"
+    #     where it gets flipped to true.
+    # @param should_instance_eval [Boolean] true if instance_eval is expected, false if
+    #     disallowed.  Default: false, except for type attributes like "default"
+    #     where it gets flipped to true.
+    # @param block The block to run on get()
+    #
+    def initialize(*switches, should_instance_eval: NOT_PASSED, &block)
+      super(&block)
+      switches.each do |switch|
+        case switch
+        when :should_instance_eval
+          @should_instance_eval = true
+        else
+          raise ArgumentError, "Unrecognized argument #{switch.inspect}"
+        end
+      end
+      @should_instance_eval = should_instance_eval if should_instance_eval != NOT_PASSED
+    end
+
+    extend SimpleStruct
+
+    #
+    # Whether to use instance_eval on this lazy instance.
+    #
+    # Defaults to `false`.
+    #
+    boolean_property :should_instance_eval, default: "false"
+
+    #
+    # Get the value of this LazyProc.
+    #
+    # If #instance_eval? is true:
+    # - If the proc takes no arguments, runs `instance_eval()` with no parameters
+    # - If the proc takes arguments, runs `instance_exec(*args)`
+    # If #instance_eval? is false:
+    # - If the proc takes no arguments, runs `call()` with no arguments
+    # - If the proc takes exactly one mandatory argument, runs `call(instance)` with no other arguments
+    # - Otherwise, runs `call(instance, *args)`
+    #
+    # @param instance The instance to instance_eval against.
+    # @param args [Array] Arguments to pass to the function.  Do not pass (or pass `nil`)
+    #   to indicate the function never takes arguments.
+    #
+    # @return The computed value
+    #
+    def get(instance: nil, args: nil, instance_eval_by_default: NOT_PASSED)
+      if instance_eval_by_default != NOT_PASSED && !defined?(@should_instance_eval)
+        should_instance_eval = instance_eval_by_default
+      else
+        should_instance_eval = self.should_instance_eval?
+      end
+
+      if should_instance_eval
+        if arity == 0
+          instance.instance_eval(&self)
+        else
+          instance.instance_exec(*args, &self)
+        end
+      else
+        case arity
+        when 0
+          call()
+        when 1
+          call(instance)
+        else
+          call(instance, *args)
+        end
+      end
+    end
+  end
+end

data/files/lib/chef_resource/output/nested_converge.rb

@@ -0,0 +1,91 @@
+require 'chef_resource/output/nested_converge/styles'
+require 'chef_resource/output/nested_converge/open_resource'
+require 'chef_resource/resource/resource_events'
+require 'chef_resource/constants'
+
+module ChefResource
+  module Chef
+    module Output
+      class NestedConverge < StructResource
+        include ResourceEvents
+
+        property :indent_step, default: 2
+        property :styles, Styles, default: {
+          default nil
+          updated :green
+          warn  [ :timestamp, :gray ]
+          error [ :timestamp, :red ]
+          fatal [ :timestamp, :on_red, :white ]
+        }
+
+        class Styles < StructResource
+          property :default
+          property :identity_defined         { default }
+          property :fully_defined        { default }
+          property :updating     { default }
+          property :updated        { default }
+          property :not_updated    { default }
+          property :updated      { default }
+          property :update_failed  { default }
+          property :debug          { default }
+          property :info           { default }
+          property :warn           { default }
+          property :error          { default }
+          property :fatal          { default }
+        end
+
+        def open_resources
+          @open_resources ||= {}
+        end
+
+        def output_mutex
+          @mutex ||= Mutex.new
+        end
+
+        attr_accessor :current_resource
+        attr_accessor :current_stream
+        attr_accessor :at_line_begin
+
+        def print(open_resource, stream, str=NOT_PASSED, style)
+          if str == NOT_PASSED
+            str, stream = stream, :default
+          end
+          output_mutex.synchronize do
+            lines = str.lines
+            switch_stream(open_resource, stream, lines)
+          end
+        end
+
+        def switch_stream(open_resource, stream, lines, style)
+          if current_resource != resource
+            current_resource = resource
+            current_stream = stream
+            open_resource.header_lines(lines.shift, style)
+          elsif current_stream != stream
+            current_stream = stream
+            # TODO look at parents
+            puts open_resource.header_line(lines.shift)
+          end
+          output_mutex.synchronize do
+            if current_resource != resource
+              prev_resource, current_resource = current_resource, resource
+              prev_stream, current_stream = current_stream, stream
+            elsif current_stream != stream
+              prev_stream, current_stream = current_stream, stream
+            end
+            block.call(prev_resource, prev_stream)
+          end
+        end
+
+        def resource_event(resource, event, *args)
+          open_resources[resource] ||= ResourceFormat.new(self, resource)
+          open_resources[resource].resource_event(resource, event, *args)
+        end
+
+        def resource_closed(resource)
+          open_resources.delete(resource)
+        end
+      end
+    end
+  end
+end