garcun 0.0.2

data/lib/garcon/chef/provider/recovery.rb

@@ -0,0 +1,80 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# 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 Garcon
+  module Recovery
+    def run_action_rescued(action = nil)
+      run_action_unrescued(action)
+      Chef::Log.debug "Finished running #{new_resource.resource_name}" \
+                      "[#{new_resource.name}] -- no exception"
+    rescue Exception => e
+      Chef::Log.info "#{new_resource.resource_name}[#{new_resource.name}] " \
+                     "failed with: #{e.inspect}"
+
+      if new_resource.instance_variable_defined?('@recovery_handlers'.to_sym)
+        new_resource.recovery_handlers.each do |recovery_struct|
+          if recovery_struct.options[:retries] > 0 &&
+            (recovery_struct.exceptions.any? { |klass| e.is_a?(klass) } ||
+             recovery_struct.exceptions.empty?)
+
+            recovery_struct.options[:retries] -= 1
+            instance_exec(new_resource, &recovery_struct.block)
+            run_action_rescued(action)
+            return
+          end
+        end
+      end
+      raise exception
+    end
+
+    def notify(action, resource)
+      run_context.resource_collection.find(resource).run_action(action)
+    end
+
+    def self.included(descendant)
+      descendant.class_eval do
+        alias_method :run_action_unrescued, :run_action
+        alias_method :run_action, :run_action_rescued
+      end
+    end
+
+    unless Chef::Provider.ancestors.include?(Recovery)
+      Chef::Provider.send(:include, Recovery)
+    end
+  end
+end
+
+class Chef
+  class Resource
+    class Recovery < Struct.new(:options, :exceptions, :block); end
+
+    attr_accessor :recovery_handlers
+
+    def recovery(*args, &block)
+      options    = { retries: 1 }
+      exceptions = []
+      args.each do |arg|
+        exceptions  << arg  if arg.is_a?(Class)
+        options.merge!(arg) if arg.is_a?(Hash)
+      end
+      @recovery_handlers ||= []
+      @recovery_handlers << Recovery.new(options || {}, exceptions || [], block)
+    end
+  end
+end

data/lib/garcon/chef/provider/zip_file.rb

@@ -0,0 +1,271 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# 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 'garcon'
+require 'find'
+
+class Chef
+  class Resource
+    class ZipFile < Chef::Resource
+      include Garcon
+
+      # Chef attributes
+      identity_attr :path
+      provides      :zip_file
+      state_attrs   :checksum, :owner, :group, :mode
+
+      # Actions
+      actions        :zip, :unzip
+      default_action :unzip
+
+      # Attributes
+      attribute :path,
+        kind_of: String,
+        name_attribute: true
+      attribute :source,
+        kind_of: [String, URI::HTTP],
+        callbacks: source_callbacks,
+        required: true
+      attribute :remove_after,
+        kind_of: [TrueClass, FalseClass],
+        default: false
+      attribute :overwrite,
+        kind_of: [TrueClass, FalseClass],
+        default: false
+      attribute :checksum,
+        kind_of: String,
+        regex:   /^[0-9a-f]{32}$|^[a-zA-Z0-9]{40,64}$/
+      attribute :owner,
+        kind_of: [String, Integer],
+        regex:   Chef::Config[:user_valid_regex]
+      attribute :group,
+        kind_of: [String, Integer],
+        regex:   Chef::Config[:group_valid_regex]
+      attribute :mode,
+        kind_of: Integer,
+        regex:   /^0?\d{3,4}$/
+      attribute :check_cert,
+        kind_of: [TrueClass, FalseClass],
+        default: true
+      attribute :header,
+        kind_of: String
+    end
+  end
+
+  class Provider
+    class ZipFile < Chef::Provider
+      include Chef::Mixin::EnforceOwnershipAndPermissions
+      include Garcon
+
+      def initialize(new_resource, run_context)
+        super
+        require_zip unless defined?(Zip)
+      end
+
+      # Shortcut to new_resource.
+      #
+      alias_method :r, :new_resource
+
+      # Boolean indicating if WhyRun is supported by this provider.
+      #
+      # @return [TrueClass, FalseClass]
+      #
+      # @api private
+      def whyrun_supported?
+        true
+      end
+
+      # Load and return the current resource.
+      #
+      # @return [Chef::Provider::ZipFile]
+      #
+      # @api private
+      def load_current_resource
+        @current_resource ||= Chef::Resource::ZipFile.new(r.name)
+        @current_resource
+      end
+
+      def action_unzip
+        converge_by "Unzip #{r.source} to #{r.path}" do
+          Zip::File.open(cached_file) do |zip|
+            zip.each do |entry|
+              path = ::File.join(r.path, entry.name)
+              FileUtils.mkdir_p(::File.dirname(path))
+              if r.overwrite && ::File.exist?(path) && !::File.directory?(path)
+                FileUtils.rm(path)
+              end
+              zip.extract(entry, path)
+            end
+          end
+          do_acl_changes
+          ::File.unlink(cached_file) if r.remove_after
+          r.updated_by_last_action(true)
+        end
+      end
+
+      def action_zip
+        if ::File.exists?(r.path) && !r.overwrite
+          Chef::Log.info "#{r.path} already exists - nothing to do"
+        else
+          ::File.unlink(r.path) if ::File.exists?(r.path)
+          if ::File.directory?(r.source)
+            converge_by "Zip #{r.source}" do
+              z = Zip::File.new(r.path, true)
+              Find.find(r.source) do |f|
+                next if f == r.source
+                zip_fname = f.sub(r.source, '')
+                z.add(zip_fname, f)
+              end
+              z.close
+              do_acl_changes
+              r.updated_by_last_action(true)
+            end
+          else
+            Chef::Log.info 'a valid directory must be specified for ziping'
+          end
+        end
+      end
+
+      # Implementation components *should* follow symlinks when managing access
+      # control (e.g., use chmod instead of lchmod even if the path we're
+      # managing is a symlink).
+      #
+      def manage_symlink_access?
+        false
+      end
+
+      private #   P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+      # Change file ownership and mode
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def do_acl_changes
+        if access_controls.requires_changes?
+          converge_by(access_controls.describe_changes) do
+            access_controls.set_all
+          end
+        end
+      end
+
+      # Ensure all prerequisite software is installed.
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def require_zip
+        require 'zip'
+      rescue LoadError
+        gem_rubyzip
+        require 'zip'
+      end
+
+      def gem_rubyzip
+        g ||= Chef::Resource::ChefGem.new('rubyzip', run_context)
+        g.compile_time(false) if respond_to?(:compile_time)
+        g.run_action :install
+      end
+
+      # Cache a file locally in Chef::Config[:file_cache_path].
+      #
+      # @note The file is gargbage collected at the end of a run.
+      #
+      # @return [String]
+      #   Path to the cached file.
+      #
+      def cached_file
+        if r.source =~ URI::ABS_URI &&
+          %w[ftp http https].include?(URI.parse(r.source).scheme)
+          file = ::File.basename(URI.unescape(URI.parse(r.source).path))
+          cache_file_path = file_cache_path(file)
+
+          d ||= Chef::Resource::Download.new(cache_file_path, run_context)
+          d.backup      false
+          d.source      r.source
+          d.owner       r.owner      if r.owner
+          d.group       r.group      if r.group
+          d.header      r.header     if r.header
+          d.checksum    r.checksum   if r.checksum
+          d.check_cert  r.check_cert
+          d.run_action  :create
+        else
+          cache_file_path = r.source
+        end
+
+        cache_file_path
+      end
+    end
+  end
+end
+
+# Chef::Platform mapping for resource and providers
+#
+# @return [undefined]
+#
+# @api private.
+Chef::Platform.set(
+  platform: :amazon,
+  resource: :zip_file,
+  provider:  Chef::Provider::ZipFile
+)
+
+# Chef::Platform mapping for resource and providers
+#
+# @return [undefined]
+#
+# @api private.
+Chef::Platform.set(
+  platform: :centos,
+  resource: :zip_file,
+  provider:  Chef::Provider::ZipFile
+)
+
+# Chef::Platform mapping for resource and providers
+#
+# @return [undefined]
+#
+# @api private.
+Chef::Platform.set(
+  platform: :oracle,
+  resource: :zip_file,
+  provider:  Chef::Provider::ZipFile
+)
+
+# Chef::Platform mapping for resource and providers
+#
+# @return [undefined]
+#
+# @api private.
+Chef::Platform.set(
+  platform: :redhat,
+  resource: :zip_file,
+  provider:  Chef::Provider::ZipFile
+)
+
+# Chef::Platform mapping for resource and providers
+#
+# @return [undefined]
+#
+# @api private.
+Chef::Platform.set(
+  platform: :scientific,
+  resource: :zip_file,
+  provider:  Chef::Provider::ZipFile
+)

data/lib/garcon/chef/resource/attribute.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# 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 'chef/mixin/params_validate'
+
+module Garcon
+  module Resource
+    class Attribute < ::Mash
+      include ::Chef::Mixin::ParamsValidate
+
+      def method_missing(method, *args, &block)
+        if (match = method.to_s.match(/(.*)=$/)) && args.size == 1
+          self[match[1]] = args.first
+        elsif (match = method.to_s.match(/(.*)\?$/)) && args.size == 0
+          key?(match[1])
+        elsif key?(method)
+          self[method]
+        else
+          super
+        end
+      end
+
+      def validate(map)
+        data = super(symbolize_keys, map)
+        data.each { |k,v| self[k.to_sym] = v }
+      end
+
+      def self.from_hash(hash)
+        mash = Attribute.new(hash)
+        mash.default = hash.default
+        mash
+      end
+    end
+  end
+end

data/lib/garcon/chef/resource/base_dsl.rb

@@ -0,0 +1,174 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# 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_relative 'attribute'
+
+module Garcon
+  module Resource
+    # Provide default_action and actions like LWRPBase.
+    #
+    module BaseDSL
+      module ClassMethods
+        # Imitate the behavior of the `Chef::Resource::LWRPBase` DSL providing
+        # a `default_action` method.
+        #
+        # @param [Symbol, String] name
+        #   The default action.
+        #
+        # @return [undefined]
+        #
+        def default_action(name = nil)
+          if name
+            @default_action = name
+            actions(name)
+          end
+          @default_action || (superclass.respond_to?(:default_action) &&
+                              superclass.default_action) ||
+                              :actions.first || :nothing
+        end
+
+        # Imitate the behavior of the `Chef::Resource::LWRPBase` LWRP DSL
+        # providing a `action` method.
+        #
+        # @param [Array<String, Symbol>] name
+        #   The default action.
+        #
+        # @return [undefined]
+        #
+        def actions(*names)
+          @actions ||= superclass.respond_to?(:actions) ?
+                       superclass.actions.dup : []
+          (@actions << names).flatten!.uniq!
+          @actions
+        end
+
+        def basic(source = nil)
+          source ||= self
+          hash    = Hash.new
+          pattern = Regexp.new('^_set_or_return_(.+)$')
+          source.public_methods(false).each do |method|
+            pattern.match(method) do |m|
+              attribute = m[1].to_sym
+              hash[attribute] = send(attribute)
+            end
+          end
+          Attribute.from_hash(hash)
+        end
+
+        def full(attribute = nil, source = nil, recursion = 3)
+          source ||= self
+          if attribute && (attribute.is_a?(Hash) || attribute.is_a?(Mash))
+            data = attribute
+          else
+            data = Hash.new
+          end
+          data = Mash.from_hash(data) unless data.is_a?(Mash)
+          data.merge!(attr_mash(source))
+          data = data.symbolize_keys
+          data.each do |k,v|
+            next unless v.is_a? String
+
+            for i in 1..recursion
+              v2 = v % data
+              v2 == v ? break : data[k] = v = v2
+            end
+          end
+          Attribute.from_hash(data)
+        end
+
+        # Imitate the behavior of the `Chef::Resource::LWRPBase` LWRP DSL
+        # providing a `attribute` method.
+        #
+        # @param [Symbol] name
+        #
+        # @param [Hash] opts
+        #
+        # @return [undefined]
+        #
+        def attribute(name, opts)
+          coerce = opts.delete(:coerce)
+          define_method(name) do |arg = nil, &block|
+            if coerce && !arg.nil?
+              arg = Garcon.coercer.coerce(arg, &coerce)
+              # arg = instance_exec(arg, &coerce)
+            else
+              arg = block if arg.nil?
+            end
+            set_or_return(name, arg, opts)
+          end
+        end
+
+        # Hook called when module is included, extends a descendant with class
+        # and instance methods.
+        #
+        # @param [Module] descendant
+        #   the module or class including Garcon::Resource::BaseDSL
+        #
+        # @return [self]
+        #
+        def included(descendant)
+          super
+          descendant.extend ClassMethods
+        end
+      end
+
+      extend ClassMethods
+
+      # Constructor for Chef::Resource::YourSuperAwesomeResource.
+      #
+      def initialize(*args)
+        super
+        @action = self.class.default_action if @action == :nothing
+        (@allowed_actions << self.class.actions).flatten!.uniq!
+      end
+    end
+  end
+
+  module Provider
+    # Helper to handle load_current_resource for direct subclasses of Provider
+    #
+    module BaseDSL
+      module ClassMethods
+        # Hook called when module is included, extends a descendant with class
+        # and instance methods.
+        #
+        # @param [Module] descendant
+        #   The module or class including Garcon::Provider::BaseDSL
+        #
+        # @return [self]
+        #
+        def included(descendant)
+          super
+          descendant.extend ClassMethods
+          if descendant.is_a?(Class) && descendant.superclass == Chef::Provider
+            descendant.class_exec { include Implementation }
+          end
+          descendant.class_exec { include Chef::DSL::Recipe }
+        end
+      end
+
+      module Implementation
+        def load_current_resource
+        end
+      end
+
+      extend ClassMethods
+    end
+  end
+end