chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/resource/powershell_script.rb

@@ -0,0 +1,31 @@
+#
+# Author:: Adam Edwards (<adamed@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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/resource/windows_script'
+
+class Chef
+  class Resource
+    class PowershellScript < Chef::Resource::WindowsScript
+
+      def initialize(name, run_context=nil)
+        super(name, run_context, :powershell_script, "powershell.exe")
+      end
+      
+    end
+  end
+end

data/lib/chef/resource/registry_key.rb

@@ -0,0 +1,86 @@
+# Author:: Prajakta Purohit (<prajakta@opscode.com>)
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+#
+# Copyright:: 2011, Opscode, Inc.
+#
+# 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/provider/registry_key'
+require 'chef/resource'
+
+class Chef
+  class Resource
+    class RegistryKey < Chef::Resource
+
+      identity_attr :key
+      state_attrs :values
+
+      def initialize(name, run_context=nil)
+        super
+        @resource_name = :registry_key
+        @action = :create
+        @architecture = :machine
+        @recursive = false
+        @key = name
+        @values = []
+        @allowed_actions.push(:create, :create_if_missing, :delete, :delete_key)
+      end
+
+      def key(arg=nil)
+        set_or_return(
+          :key,
+          arg,
+          :kind_of => String
+        )
+      end
+      def values(arg=nil)
+        if not arg.nil?
+          if arg.is_a?(Hash)
+            @values = [ arg ]
+          elsif arg.is_a?(Array)
+            @values = arg
+          else
+            raise ArgumentError, "Bad type for RegistryKey resource, use Hash or Array"
+          end
+          @values.each do |v|
+            raise ArgumentError, "Missing name key in RegistryKey values hash" unless v.has_key?(:name)
+            raise ArgumentError, "Missing type key in RegistryKey values hash" unless v.has_key?(:type)
+            raise ArgumentError, "Missing data key in RegistryKey values hash" unless v.has_key?(:data)
+            v.each_key do |key|
+              raise ArgumentError, "Bad key #{key} in RegistryKey values hash" unless [:name,:type,:data].include?(key)
+            end
+            raise ArgumentError, "Type of name => #{v[:name]} should be string" unless v[:name].is_a?(String)
+            raise Argument Error "Type of type => #{v[:name]} should be symbol" unless v[:type].is_a?(Symbol)
+          end
+        elsif self.instance_variable_defined?(:@values) == true
+          @values
+        end
+      end
+      def recursive(arg=nil)
+        set_or_return(
+          :recursive,
+          arg,
+          :kind_of => [TrueClass, FalseClass]
+        )
+      end
+      def architecture(arg=nil)
+        set_or_return(
+          :architecture,
+          arg,
+          :kind_of => Symbol
+        )
+      end
+
+    end
+  end
+end

data/lib/chef/resource/remote_directory.rb

@@ -51,6 +51,12 @@ class Chef
         @provider = Chef::Provider::RemoteDirectory
       end
 
+      if Chef::Platform.windows?
+        # create a second instance of the 'rights' attribute
+        rights_attribute(:files_rights)
+      end
+
+
       def source(args=nil)
         set_or_return(
           :source,
@@ -83,11 +89,6 @@ class Chef
         )
       end
 
-      if Chef::Platform.windows?
-        # create a second instance of the 'rights' attribute
-        Chef::Mixin::Securable.rights_attribute(:files_rights)
-      end
-
       def files_mode(arg=nil)
         set_or_return(
           :files_mode,

data/lib/chef/resource/remote_file.rb

@@ -32,55 +32,92 @@ class Chef
         super
         @resource_name = :remote_file
         @action = "create"
-        @source = ::File.basename(name)
-        @cookbook = nil
+        @source = []
+        @use_etag = true
+        @use_last_modified = true
+        @ftp_active_mode = false
+        @headers = {}
         @provider = Chef::Provider::RemoteFile
       end
 
-      def source(args=nil)
+      def source(*args)
+        if not args.empty?
+          args = Array(args).flatten
+          validate_source(args)
+          @source = args
+        elsif self.instance_variable_defined?(:@source) == true
+          @source
+        end
+      end
+
+      def checksum(args=nil)
         set_or_return(
-          :source,
+          :checksum,
           args,
           :kind_of => String
         )
       end
 
-      def cookbook(args=nil)
+      # Disable or enable ETag and Last Modified conditional GET. Equivalent to
+      #   use_etag(true_or_false)
+      #   use_last_modified(true_or_false)
+      def use_conditional_get(true_or_false)
+        use_etag(true_or_false)
+        use_last_modified(true_or_false)
+      end
+
+      def use_etag(args=nil)
         set_or_return(
-          :cookbook,
+          :use_etag,
           args,
-          :kind_of => String
+          :kind_of => [ TrueClass, FalseClass ]
         )
       end
 
-      def checksum(args=nil)
+      alias :use_etags :use_etag
+
+      def use_last_modified(args=nil)
         set_or_return(
-          :checksum,
+          :use_last_modified,
           args,
-          :kind_of => String
+          :kind_of => [ TrueClass, FalseClass ]
         )
       end
 
-      # The provider that should be used for this resource.
-      # === Returns:
-      # Chef::Provider::RemoteFile    when the source is an absolute URI, like
-      #                               http://www.google.com/robots.txt
-      # Chef::Provider::CookbookFile  when the source is a relative URI, like
-      #                               'myscript.pl', 'dir/config.conf'
-      def provider
-        if absolute_uri?(source)
-          Chef::Provider::RemoteFile
-        else
-          Chef::Log.warn("remote_file is deprecated for fetching files from cookbooks. Use cookbook_file instead")
-          Chef::Log.warn("From #{self.to_s} on #{source_line}")
-          Chef::Provider::CookbookFile
-        end
+      def ftp_active_mode(args=nil)
+        set_or_return(
+          :ftp_active_mode,
+          args,
+          :kind_of => [ TrueClass, FalseClass ]
+        )
+      end
+
+      def headers(args=nil)
+        set_or_return(
+          :headers,
+          args,
+          :kind_of => Hash
+        )
+      end
+
+      def after_created
+        validate_source(@source)
       end
 
       private
 
+      def validate_source(source)
+        raise ArgumentError, "#{resource_name} has an empty source" if source.empty?
+        source.each do |src|
+          unless absolute_uri?(src)
+            raise Exceptions::InvalidRemoteFileURI,
+              "#{src.inspect} is not a valid `source` parameter for #{resource_name}. `source` must be an absolute URI or an array of URIs."
+          end
+        end
+      end
+
       def absolute_uri?(source)
-        URI.parse(source).absolute?
+        source.kind_of?(String) and URI.parse(source).absolute?
       rescue URI::InvalidURIError
         false
       end

data/lib/chef/resource/route.rb

@@ -31,7 +31,7 @@ class Chef
         super
         @resource_name = :route
         @target = name
-        @action = :add
+        @action = [:add]
         @allowed_actions.push(:add, :delete)
         @netmask = nil
         @gateway = nil

data/lib/chef/resource/ruby_block.rb

@@ -26,8 +26,8 @@ class Chef
       def initialize(name, run_context=nil)
         super
         @resource_name = :ruby_block
-        @action = "create"
-        @allowed_actions.push(:create)
+        @action = "run"
+        @allowed_actions << :create << :run
         @block_name = name
       end
 

data/lib/chef/resource/service.rb

@@ -40,6 +40,7 @@ class Chef
         @status_command = nil
         @restart_command = nil
         @reload_command = nil
+        @init_command = nil
         @priority = nil
         @action = "nothing"
         @startup_type = :automatic
@@ -108,6 +109,19 @@ class Chef
         )
       end
 
+      # The path to the init script associated with the service. On many
+      # distributions this is '/etc/init.d/SERVICE_NAME' by default. In
+      # non-standard configurations setting this value will save having to
+      # specify overrides for the start_command, stop_command and
+      # restart_command attributes.
+      def init_command(arg=nil)
+        set_or_return(
+          :init_command,
+          arg,
+          :kind_of => [ String ]
+        )
+      end
+
       # if the service is enabled or not
       def enabled(arg=nil)
         set_or_return(

data/lib/chef/resource/template.rb

@@ -29,6 +29,9 @@ class Chef
 
       provides :template, :on_platforms => :all
 
+      attr_reader :inline_helper_blocks
+      attr_reader :inline_helper_modules
+
       def initialize(name, run_context=nil)
         super
         @resource_name = :template
@@ -38,6 +41,9 @@ class Chef
         @local = false
         @variables = Hash.new
         @provider = Chef::Provider::Template
+        @inline_helper_blocks = {}
+        @inline_helper_modules = []
+        @helper_modules = []
       end
 
       def source(file=nil)
@@ -71,6 +77,145 @@ class Chef
           :kind_of => [ TrueClass, FalseClass ]
         )
       end
+
+      # Declares a helper method to be defined in the template context when
+      # rendering.
+      #
+      # === Example:
+      #
+      # ==== Basic usage:
+      # Given the following helper:
+      #   helper(:static_value) { "hello from helper" }
+      # A template with the following code:
+      #   <%= static_value %>
+      # Will render as;
+      #   hello from helper
+      #
+      # ==== Referencing Instance Variables:
+      # Any instance variables available to the template can be referenced in
+      # the method body. For example, you can simplify accessing app-specific
+      # node attributes like this:
+      #   helper(:app) { @node[:my_app_attributes] }
+      # And use it in a template like this:
+      #   <%= app[:listen_ports] %>
+      # This is equivalent to the non-helper template code:
+      #   <%= @node[:my_app_attributes][:listen_ports] %>
+      #
+      # ==== Method Arguments:
+      # Helper methods can also take arguments. The syntax available for
+      # argument specification will be dependent on ruby version. Ruby 1.8 only
+      # supports a subset of the argument specification syntax available for
+      # method definition, whereas 1.9 supports the full syntax.
+      #
+      # Continuing the above example of simplifying attribute access, we can
+      # define a helper to look up app-specific attributes like this:
+      #   helper(:app) { |setting| @node[:my_app_attributes][setting] }
+      # The template can then look up attributes like this:
+      #   <%= app(:listen_ports) %>
+      def helper(method_name, &block)
+        unless block_given?
+          raise Exceptions::ValidationFailed,
+            "`helper(:method)` requires a block argument (e.g., `helper(:method) { code }`)"
+        end
+
+        unless method_name.kind_of?(Symbol)
+          raise Exceptions::ValidationFailed,
+            "method_name argument to `helper(method_name)` must be a symbol (e.g., `helper(:method) { code }`)"
+        end
+
+        @inline_helper_blocks[method_name] = block
+      end
+
+      # Declares a module to define helper methods in the template's context
+      # when rendering. There are two primary forms.
+      #
+      # === Inline Module Definition
+      # When a block is given, the block is used to define a module which is
+      # then mixed in to the template context w/ `extend`.
+      #
+      # ==== Inline Module Example
+      # Given the following code in the template resource:
+      #   helpers do
+      #     # Add "syntax sugar" for referencing app-specific attributes
+      #     def app(attribute)
+      #       @node[:my_app_attributes][attribute]
+      #     end
+      #   end
+      # You can use it in the template like so:
+      #   <%= app(:listen_ports) %>
+      # Which is equivalent to:
+      #   <%= @node[:my_app_attributes][:listen_ports] %>
+      #
+      # === External Module Form
+      # When a module name is given, the template context will be extended with
+      # that module. This is the recommended way to customize template contexts
+      # when you need to define more than an handful of helper functions (but
+      # also try to keep your template helpers from getting out of hand--if you
+      # have very complex logic in your template helpers, you should further
+      # extract your code into separate libraries).
+      #
+      # ==== External Module Example
+      # To extract the above inline module code to a library, you'd create a
+      # library file like this:
+      #   module MyTemplateHelper
+      #     # Add "syntax sugar" for referencing app-specific attributes
+      #     def app(attribute)
+      #       @node[:my_app_attributes][attribute]
+      #     end
+      #   end
+      # And in the template resource:
+      #   helpers(MyTemplateHelper)
+      # The template code in the above example will work unmodified.
+      def helpers(module_name=nil,&block)
+        if block_given? and !module_name.nil?
+          raise Exceptions::ValidationFailed,
+            "Passing both a module and block to #helpers is not supported. Call #helpers multiple times instead"
+        elsif block_given?
+          @inline_helper_modules << block
+        elsif module_name.kind_of?(::Module)
+          @helper_modules << module_name
+        elsif module_name.nil?
+          raise Exceptions::ValidationFailed,
+            "#helpers requires either a module name or inline module code as a block.\n" +
+            "e.g.: helpers do; helper_code; end;\n" +
+            "OR: helpers(MyHelpersModule)"
+        else
+          raise Exceptions::ValidationFailed,
+            "Argument to #helpers must be a module. You gave #{module_name.inspect} (#{module_name.class})"
+        end
+      end
+
+      # Compiles all helpers from inline method definitions, inline module
+      # definitions, and external modules into an Array of Modules. The context
+      # object for the template is extended with these modules to provide
+      # per-resource template logic.
+      def helper_modules
+        compiled_helper_methods + compiled_helper_modules + @helper_modules
+      end
+
+      private
+
+      # compiles helper methods into a module that can be included in template context
+      def compiled_helper_methods
+        if inline_helper_blocks.empty?
+          []
+        else
+          resource_helper_blocks = inline_helper_blocks
+          helper_mod = Module.new do
+            resource_helper_blocks.each do |method_name, method_body|
+              define_method(method_name, &method_body)
+            end
+          end
+          [ helper_mod ]
+        end
+      end
+
+      def compiled_helper_modules
+        @inline_helper_modules.map do |module_body|
+          Module.new(&module_body)
+        end
+      end
+
     end
   end
 end