poise 2.0.0

data/lib/poise/helpers/inversion/options_resource.rb

@@ -0,0 +1,101 @@
+#
+# Copyright 2015, Noah Kantrowitz
+#
+# 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/mash'
+
+require 'poise/error'
+
+
+module Poise
+  module Helpers
+    module Inversion
+      # A mixin for inversion options resources.
+      #
+      # @api private
+      # @since 2.0.0
+      # @see Poise::Helpers::Inversion
+      module OptionsResource
+        include Poise
+
+        # Method missing delegation to allow DSL-style options.
+        #
+        # @example
+        #   my_app_options 'app' do
+        #     key1 'value1'
+        #     key2 'value2'
+        #   end
+        def method_missing(method_sym, *args, &block)
+          super(method_sym, *args, &block)
+        rescue NoMethodError
+          # First time we've seen this key and using it as an rvalue, NOPE.GIF.
+          raise unless !args.empty? || block || _options[method_sym]
+          if !args.empty? || block
+            _options[method_sym] = block || args.first
+          end
+          _options[method_sym]
+        end
+
+        # Insert the options data in to the run state. This has to match the
+        # layout used in {Poise::Helpers::Inversion::Provider.inversion_options}.
+        #
+        # @api private
+        def after_created
+          raise Poise::Error.new("Inversion resource name not set for #{self.class.name}") unless self.class.inversion_resource
+          node.run_state['poise_inversion'] ||= {}
+          node.run_state['poise_inversion'][self.class.inversion_resource] ||= {}
+          node.run_state['poise_inversion'][self.class.inversion_resource][resource] ||= {}
+          node.run_state['poise_inversion'][self.class.inversion_resource][resource][for_provider] ||= {}
+          node.run_state['poise_inversion'][self.class.inversion_resource][resource][for_provider].update(_options)
+        end
+
+        module ClassMethods
+          # @overload inversion_resource()
+          #   Return the inversion resource name for this class.
+          #   @return [Symbol]
+          # @overload inversion_resource(val)
+          #   Set the inversion resource name for this class. You can pass either
+          #   a symbol in DSL format or a resource class that uses Poise. This
+          #   name is used to determine which resources the inversion provider is
+          #   a candidate for.
+          #   @param val [Symbol, Class] Name to set.
+          #   @return [Symbol]
+          def inversion_resource(val=nil)
+            if val
+              val = val.resource_name if val.is_a?(Class)
+              Chef::Log.debug("[#{self.name}] Setting inversion resource to #{val}")
+              @poise_inversion_resource = val.to_sym
+            end
+            @poise_inversion_resource || (superclass.respond_to?(:inversion_resource) ? superclass.inversion_resource : nil)
+          end
+
+          # @api private
+          def included(klass)
+            super
+            klass.extend(ClassMethods)
+            klass.class_exec do
+              actions(:run)
+              attribute(:resource, kind_of: String, name_attribute: true)
+              attribute(:for_provider, kind_of: [String, Symbol], default: '*')
+              attribute(:_options, kind_of: Hash, default: lazy { Mash.new })
+            end
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/poise/helpers/lazy_default.rb

@@ -0,0 +1,62 @@
+#
+# Copyright 2013-2015, Noah Kantrowitz
+#
+# 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 Poise
+  module Helpers
+    # Resource mixin to allow lazyily-evaluated defaults in resource attributes.
+    # This is designed to be used with {LWRPPolyfill} or a similar #attributes
+    # method.
+    #
+    # @since 1.0.0
+    # @example
+    #   class MyResource < Chef::Resource
+    #     include Poise::Helpers::LWRPPolyfill
+    #     include Poise::Helpers::LazyDefault
+    #     attribute(:path, default: lazy { name + '_temp' })
+    #   end
+    module LazyDefault
+      # Override the default set_or_return to support lazy evaluation of the
+      # default value. This only actually matters when it is called from a class
+      # level context via #attributes.
+      def set_or_return(symbol, arg, validation)
+        if validation && validation[:default].is_a?(Chef::DelayedEvaluator)
+          validation = validation.dup
+          validation[:default] = instance_eval(&validation[:default])
+        end
+        super(symbol, arg, validation)
+      end
+
+      # @!classmethods
+      module ClassMethods
+        # Create a lazyily-evaluated block.
+        #
+        # @param block [Proc] Callable to return the default value.
+        # @return [Chef::DelayedEvaluator]
+        def lazy(&block)
+          Chef::DelayedEvaluator.new(&block)
+        end
+
+        def included(klass)
+          super
+          klass.extend(ClassMethods)
+        end
+      end
+
+      extend ClassMethods
+    end
+  end
+end

data/lib/poise/helpers/lwrp_polyfill.rb

@@ -0,0 +1,96 @@
+#
+# Copyright 2013-2015, Noah Kantrowitz
+#
+# 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 'poise/utils/resource_provider_mixin'
+
+
+module Poise
+  module Helpers
+    # A resource and provider mixin to add back some compatability with Chef's
+    # LWRPBase classes.
+    #
+    # @since 1.0.0
+    module LWRPPolyfill
+      include Poise::Utils::ResourceProviderMixin
+
+      # Provide default_action and actions like LWRPBase but better equipped for subclassing.
+      module Resource
+        def initialize(*args)
+          super
+          # Try to not stomp on stuff if already set in a parent
+          @action = self.class.default_action if @action == :nothing
+          (@allowed_actions << self.class.actions).flatten!.uniq!
+        end
+
+        # @!classmethods
+        module ClassMethods
+          def default_action(name=nil)
+            if name
+              @default_action = name
+              actions(name)
+            end
+            @default_action || ( respond_to?(:superclass) && superclass.respond_to?(:default_action) && superclass.default_action ) || actions.first || :nothing
+          end
+
+          def actions(*names)
+            @actions ||= ( respond_to?(:superclass) && superclass.respond_to?(:actions) ? superclass.actions.dup : [] )
+            (@actions << names).flatten!.uniq!
+            @actions
+          end
+
+          def attribute(name, opts)
+            # Ruby 1.8 can go to hell
+            define_method(name) do |arg=nil, &block|
+              arg = block if arg.nil? # Try to allow passing either
+              set_or_return(name, arg, opts)
+            end
+          end
+
+          def included(klass)
+            super
+            klass.extend(ClassMethods)
+          end
+        end
+
+        extend ClassMethods
+      end
+
+      # Helper to handle load_current_resource for direct subclasses of Provider
+      module Provider
+        # @!classmethods
+        module ClassMethods
+          def included(klass)
+            super
+            klass.extend(ClassMethods)
+
+            # Mask Chef::Provider#load_current_resource because it throws NotImplementedError.
+            if klass.is_a?(Class) && klass.superclass == Chef::Provider
+              klass.class_exec do
+                def load_current_resource
+                end
+              end
+            end
+
+            # Reinstate the Chef DSL, removed in Chef 12.
+            klass.class_exec { include Chef::DSL::Recipe }
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/poise/helpers/notifying_block.rb

@@ -0,0 +1,78 @@
+#
+# Copyright 2013-2015, Noah Kantrowitz
+#
+# 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 'poise/helpers/subcontext_block'
+require 'poise/subcontext/runner'
+
+
+module Poise
+  module Helpers
+    # A provider mixin to provide #notifying_block, a scoped form of Chef's
+    # use_inline_resources.
+    #
+    # @since 1.0.0
+    # @example
+    #   class MyProvider < Chef::Provider
+    #     include Chef::Helpers::NotifyingBlock
+    #
+    #     def action_run
+    #       notifying_block do
+    #         template '/etc/myapp.conf' do
+    #           # ...
+    #         end
+    #       end
+    #     end
+    #   end
+    module NotifyingBlock
+      include Poise::Helpers::SubcontextBlock
+
+      private
+
+      # Create and converge a subcontext for the recipe DSL. This is similar to
+      # Chef's use_inline_resources but is scoped to a block. All DSL resources
+      # declared inside the block will be converged when the block returns, and
+      # the updated_by_last_action flag will be set if any of the inner
+      # resources are updated.
+      #
+      # @api public
+      # @param block [Proc] Block to run in the subcontext.
+      # @return [void]
+      # @example
+      #   def action_run
+      #     notifying_block do
+      #       template '/etc/myapp.conf' do
+      #         # ...
+      #       end
+      #     end
+      #   end
+      def notifying_block(&block)
+        # Make sure to mark the resource as updated-by-last-action if
+        # any sub-run-context resources were updated (any actual
+        # actions taken against the system) during the
+        # sub-run-context convergence.
+        begin
+          subcontext = subcontext_block(&block)
+          # Converge the new context.
+          Poise::Subcontext::Runner.new(new_resource, subcontext).converge
+        ensure
+          new_resource.updated_by_last_action(
+            subcontext && subcontext.resource_collection.any?(&:updated?)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/poise/helpers/option_collector.rb

@@ -0,0 +1,117 @@
+#
+# Copyright 2013-2015, Noah Kantrowitz
+#
+# 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/mash'
+
+
+module Poise
+  module Helpers
+    # A resource mixin to add a new kind of attribute, an option collector.
+    # These attributes can act as mini-DSLs for things which would otherwise be
+    # key/value pairs.
+    #
+    # @since 1.0.0
+    # @example Defining an option collector
+    #   class MyResource < Chef::Resource
+    #     include Poise::Helpers::OptionCollector
+    #     attribute(:my_options, option_collector: true)
+    #   end
+    # @example Using an option collector
+    #   my_resource 'name' do
+    #     my_options do
+    #       key1 'value1'
+    #       key2 'value2'
+    #     end
+    #   end
+    module OptionCollector
+      # Instance context used to eval option blocks.
+      # @api private
+      class OptionEvalContext
+        attr_reader :_options
+
+        def initialize(parent)
+          @parent = parent
+          @_options = {}
+        end
+
+        def method_missing(method_sym, *args, &block)
+          @parent.send(method_sym, *args, &block)
+        rescue NameError
+          # Even though method= in the block will set a variable instead of
+          # calling method_missing, still try to cope in case of self.method=.
+          method_sym = method_sym.to_s.chomp('=').to_sym
+          if args.length > 0 || block
+            @_options[method_sym] = args.first || block
+          elsif !@_options.include?(method_sym)
+            # We haven't seen this name before, re-raise the NameError.
+            raise
+          end
+          @_options[method_sym]
+        end
+      end
+
+      # @!classmethods
+      module ClassMethods
+        # Override the normal #attribute() method to support defining option
+        # collectors too.
+        def attribute(name, options={})
+          # If present but false-y, make sure it is removed anyway so it
+          # doesn't confuse ParamsValidate.
+          if options.delete(:option_collector)
+            option_collector_attribute(name, options)
+          else
+            super
+          end
+        end
+
+        # Define an option collector attribute. Normally used via {.attribute}.
+        #
+        # @param name [String, Symbol] Name of the attribute to define.
+        # @param default [Object] Default value for the options.
+        def option_collector_attribute(name, default: {})
+          # Unlike LWRPBase.attribute, I don't care about Ruby 1.8. Worlds tiniest violin.
+          define_method(name.to_sym) do |arg=nil, &block|
+            iv_sym = :"@#{name}"
+
+            value = instance_variable_get(iv_sym) || begin
+              default = instance_eval(&default) if default.is_a?(Chef::DelayedEvaluator) # Handle lazy{}
+              Mash.new(default) # Wrap in a mash because fuck str vs sym.
+            end
+            if arg
+              raise Exceptions::ValidationFailed, "Option #{name} must be a Hash" if arg && !arg.is_a?(Hash)
+              # Should this and the update below be a deep merge?
+              value.update(arg)
+            end
+            if block
+              ctx = OptionEvalContext.new(self)
+              ctx.instance_exec(&block)
+              value.update(ctx._options)
+            end
+            instance_variable_set(iv_sym, value)
+            value
+          end
+        end
+
+        def included(klass)
+          super
+          klass.extend(ClassMethods)
+        end
+      end
+
+      extend ClassMethods
+    end
+  end
+end