chef 10.34.6 → 11.0.0.beta.0

data/lib/chef/provider/group/pw.rb

@@ -39,28 +39,16 @@ class Chef
         def create_group
           command = "pw groupadd"
           command << set_options
-          member_options = set_members_options
-          if member_options.empty?
-            run_command(:command => command)
-          else
-            member_options.each do |option|
-              run_command(:command => command + option)
-            end
-          end
+          command << set_members_option
+          run_command(:command => command)
         end
         
         # Manage the group when it already exists
         def manage_group
           command = "pw groupmod"
           command << set_options
-          member_options = set_members_options
-          if member_options.empty?
-            run_command(:command => command)
-          else
-            member_options.each do |option|
-              run_command(:command => command + option)
-            end
-          end
+          command << set_members_option
+          run_command(:command => command)
         end
         
         # Remove the group
@@ -82,52 +70,21 @@ class Chef
         end
 
         # Set the membership option depending on the current resource states
-        def set_members_options
-          opts = [ ]
-          members_to_be_added = [ ]
-          members_to_be_removed = [ ]
-
-          if @new_resource.append
-            # Append is set so we will only add members given in the
-            # members list and remove members given in the
-            # excluded_members list.
-            if @new_resource.members && !@new_resource.members.empty?
-              @new_resource.members.each do |member|
-                members_to_be_added << member if !@current_resource.members.include?(member)
-              end
-            end
-
-            if @new_resource.excluded_members && !@new_resource.excluded_members.empty?
-              @new_resource.excluded_members.each do |member|
-                members_to_be_removed << member if @current_resource.members.include?(member)
-              end
-            end
+        def set_members_option
+          opt = ""
+          unless @new_resource.members.empty?
+            opt << " -M #{@new_resource.members.join(',')}"
+            Chef::Log.debug("#{@new_resource} setting group members to #{@new_resource.members.join(', ')}")
           else
-            # Append is not set so we're resetting the membership of
-            # the group to the given members.
-            members_to_be_added = @new_resource.members
-            @current_resource.members.each do |member|
-              # No need to re-add a member if it's present in the new
-              # list of members
-              if members_to_be_added.include? member
-                members_to_be_added.delete member
-              else
-                members_to_be_removed << member
-              end
+            # New member list is empty so we should delete any old group members
+            unless @current_resource.members.empty?
+              opt << " -d #{@current_resource.members.join(',')}"
+              Chef::Log.debug("#{@new_resource} removing group members #{@current_resource.members.join(', ')}")
+            else
+              Chef::Log.debug("#{@new_resource} not changing group members, the group has no members")
             end
           end
-
-          unless members_to_be_added.empty?
-            Chef::Log.debug("#{@new_resource} adding group members: #{members_to_be_added.join(',')}")
-            opts << " -m #{members_to_be_added.join(',')}"
-          end
-
-          unless members_to_be_removed.empty?
-            Chef::Log.debug("#{@new_resource} removing group members: #{members_to_be_removed.join(',')}")
-            opts << " -d #{members_to_be_removed.join(',')}"
-          end
-
-          opts
+          opt
         end
         
       end

data/lib/chef/provider/group/suse.rb

@@ -39,24 +39,21 @@ class Chef
           end
         end
 
-        def set_members(members)
-          unless @current_resource.members.empty?
-            shell_out!("groupmod -R #{@current_resource.members.join(',')} #{@new_resource.group_name}")
+        def modify_group_members
+          unless @new_resource.members.empty?
+            if(@new_resource.append)
+              @new_resource.members.each do |member|
+                Chef::Log.debug("#{@new_resource} appending member #{member} to group #{@new_resource.group_name}")
+                shell_out!("groupmod -A #{member} #{@new_resource.group_name}")
+              end
+            else
+              Chef::Log.debug("#{@new_resource} setting group members to #{@new_resource.members.join(', ')}")
+              shell_out!("groupmod -A #{@new_resource.members.join(',')} #{@new_resource.group_name}")
+            end
+          else
+            Chef::Log.debug("#{@new_resource} not changing group members, the group has no members")
           end
-
-          unless members.empty?
-            shell_out!("groupmod -A #{members.join(',')} #{@new_resource.group_name}")
-          end
-        end
-
-        def add_member(member)
-          shell_out!("groupmod -A #{member} #{@new_resource.group_name}")
         end
-
-        def remove_member(member)
-          shell_out!("groupmod -R #{member} #{@new_resource.group_name}")
-        end
-
       end
     end
   end

data/lib/chef/provider/group/usermod.rb

@@ -17,14 +17,12 @@
 #
 
 require 'chef/provider/group/groupadd'
-require 'chef/mixin/shell_out'
 
 class Chef
   class Provider
     class Group
       class Usermod < Chef::Provider::Group::Groupadd
-        include Chef::Mixin::ShellOut
-
+        
         def load_current_resource
           super
         end
@@ -38,52 +36,32 @@ class Chef
             # No whyrun alternative: this component should be available in the base install of any given system that uses it
           end
 
-          requirements.assert(:modify, :manage) do |a|
-            a.assertion { @new_resource.members.empty? || @new_resource.append }
+          requirements.assert(:modify, :create) do |a|
+            a.assertion { @new_resource.members.empty? || @new_resource.append } 
             a.failure_message Chef::Exceptions::Group, "setting group members directly is not supported by #{self.to_s}, must set append true in group"
             # No whyrun alternative - this action is simply not supported.
           end
-
-          requirements.assert(:all_actions) do |a|
-            a.assertion { @new_resource.excluded_members.empty? }
-            a.failure_message Chef::Exceptions::Group, "excluded_members is not supported by #{self.to_s}"
-            # No whyrun alternative - this action is simply not supported.
-          end
         end
+        
+        def modify_group_members
+          case node[:platform]
+          when "openbsd", "netbsd", "aix", "solaris2"
+            append_flags = "-G"
+          when "solaris"
+            append_flags = "-a -G"
+          end
 
-        def set_members(members)
-          return if members.empty?
-          # This provider only supports adding members with
-          # append. Only if the action is create we will go
-          # ahead and add members.
-          if @new_resource.action == :create
-            members.each do |member|
-              add_member(member)
+          unless @new_resource.members.empty?
+            if(@new_resource.append)
+              @new_resource.members.each do |member|
+                Chef::Log.debug("#{@new_resource} appending member #{member} to group #{@new_resource.group_name}")
+                run_command(:command => "usermod #{append_flags} #{@new_resource.group_name} #{member}" )
+              end
             end
           else
-            raise Chef::Exceptions::UnsupportedAction, "Setting members directly is not supported by #{self.to_s}"
+            Chef::Log.debug("#{@new_resource} not changing group members, the group has no members")
           end
         end
-
-        def add_member(member)
-          shell_out!("usermod #{append_flags} #{@new_resource.group_name} #{member}")
-        end
-
-        def remove_member(member)
-          # This provider only supports adding members with
-          # append. This function should never be called.
-          raise Chef::Exceptions::UnsupportedAction, "Removing members members is not supported by #{self.to_s}"
-        end
-
-        def append_flags
-          case node[:platform]
-          when "openbsd", "netbsd", "aix", "solaris2", "smartos"
-            "-G"
-          when "solaris", "suse", "opensuse"
-            "-a -G"
-          end
-        end
-
       end
     end
   end

data/lib/chef/provider/group/windows.rb

@@ -57,20 +57,13 @@ class Chef
         
         def manage_group
           if @new_resource.append
-            members_to_be_added = [ ]
-            @new_resource.members.each do |member|
-              members_to_be_added << member if !@current_resource.members.include?(member)
+            begin
+              #ERROR_MEMBER_IN_ALIAS if a member already exists in the group
+              @net_group.local_add_members(@new_resource.members)
+            rescue
+              members = @new_resource.members + @current_resource.members
+              @net_group.local_set_members(members.uniq)
             end
-
-            # local_add_members will raise ERROR_MEMBER_IN_ALIAS if a
-            # member already exists in the group.
-            @net_group.local_add_members(members_to_be_added) unless members_to_be_added.empty?
-
-            members_to_be_removed = [ ]
-            @new_resource.excluded_members.each do |member|
-              members_to_be_removed << member if @current_resource.members.include?(member)
-            end
-            @net_group.local_delete_members(members_to_be_removed) unless members_to_be_removed.empty?
           else
             @net_group.local_set_members(@new_resource.members)
           end

data/lib/chef/provider/http_request.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -36,13 +36,9 @@ class Chef
       def action_head
         message = check_message(@new_resource.message)
         # returns true from Chef::REST if returns 2XX (Net::HTTPSuccess)
-        modified = @rest.run_request(
-          :HEAD,
-          @rest.create_url("#{@new_resource.url}?message=#{message}"),
-          @new_resource.headers,
-          false,
-          10,
-          false
+        modified = @rest.head(
+          "#{@new_resource.url}?message=#{message}",
+          @new_resource.headers
         )
         Chef::Log.info("#{@new_resource} HEAD to #{@new_resource.url} successful")
         Chef::Log.debug("#{@new_resource} HEAD request response: #{modified}")
@@ -53,76 +49,63 @@ class Chef
       end
 
       # Send a GET request to @new_resource.url, with ?message=@new_resource.message
-      def action_get  
+      def action_get
         converge_by("#{@new_resource} GET to #{@new_resource.url}") do
 
           message = check_message(@new_resource.message)
-          body = @rest.run_request(
-            :GET, 
-            @rest.create_url("#{@new_resource.url}?message=#{message}"),
-            @new_resource.headers,
+          body = @rest.get(
+            "#{@new_resource.url}?message=#{message}",
             false,
-            10,
-            false
+            @new_resource.headers
           )
           Chef::Log.info("#{@new_resource} GET to #{@new_resource.url} successful")
           Chef::Log.debug("#{@new_resource} GET request response: #{body}")
         end
       end
-      
+
       # Send a PUT request to @new_resource.url, with the message as the payload
-      def action_put 
+      def action_put
         converge_by("#{@new_resource} PUT to #{@new_resource.url}") do
           message = check_message(@new_resource.message)
-          body = @rest.run_request(
-            :PUT,
-            @rest.create_url("#{@new_resource.url}"),
-            @new_resource.headers,
+          body = @rest.put(
+            "#{@new_resource.url}",
             message,
-            10,
-            false
+            @new_resource.headers
           )
           Chef::Log.info("#{@new_resource} PUT to #{@new_resource.url} successful")
           Chef::Log.debug("#{@new_resource} PUT request response: #{body}")
         end
       end
-      
+
       # Send a POST request to @new_resource.url, with the message as the payload
       def action_post
         converge_by("#{@new_resource} POST to #{@new_resource.url}") do
           message = check_message(@new_resource.message)
-          body = @rest.run_request(
-            :POST,
-            @rest.create_url("#{@new_resource.url}"),
-            @new_resource.headers,
+          body = @rest.post(
+            "#{@new_resource.url}",
             message,
-            10,
-            false
+            @new_resource.headers
           )
           Chef::Log.info("#{@new_resource} POST to #{@new_resource.url} message: #{message.inspect} successful")
           Chef::Log.debug("#{@new_resource} POST request response: #{body}")
         end
       end
-      
+
       # Send a DELETE request to @new_resource.url
       def action_delete
         converge_by("#{@new_resource} DELETE to #{@new_resource.url}") do
-          body = @rest.run_request(
-            :DELETE,
-            @rest.create_url("#{@new_resource.url}"),
-            @new_resource.headers,
-            false,
-            10,
-            false
+          body = @rest.delete(
+            "#{@new_resource.url}",
+            @new_resource.headers
           )
           @new_resource.updated_by_last_action(true)
           Chef::Log.info("#{@new_resource} DELETE to #{@new_resource.url} successful")
           Chef::Log.debug("#{@new_resource} DELETE request response: #{body}")
         end
       end
-      
+
       private
-        
+
         def check_message(message)
           if message.kind_of?(Proc)
             message.call
@@ -130,7 +113,7 @@ class Chef
             message
           end
         end
-      
+
     end
   end
 end

data/lib/chef/provider/link.rb

@@ -27,6 +27,8 @@ require 'chef/scan_access_control'
 class Chef
   class Provider
     class Link < Chef::Provider
+
+      include Chef::Mixin::EnforceOwnershipAndPermissions
       include Chef::Mixin::ShellOut
       include Chef::Mixin::FileClass
 

data/lib/chef/provider/lwrp_base.rb

@@ -0,0 +1,150 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2008-2012 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/provider'
+
+class Chef
+  class Provider
+
+    # == Chef::Provider::LWRPBase
+    # Base class from which LWRP providers inherit.
+    class LWRPBase < Provider
+
+      # Chef::Provider::LWRPBase::InlineResources
+      # Implementation of inline resource convergence for LWRP providers. See
+      # Provider::LWRPBase.use_inline_resources for a longer explanation.
+      #
+      # This code is restricted to a module so that it can be selectively
+      # applied to providers on an opt-in basis.
+      module InlineResources
+
+        # Class methods for InlineResources. Overrides the `action` DSL method
+        # with one that enables inline resource convergence.
+        module ClassMethods
+          # Defines an action method on the provider, using
+          # recipe_eval_with_update_check to execute the given block.
+          def action(name, &block)
+            define_method("action_#{name}") do
+              recipe_eval_with_update_check(&block)
+            end
+          end
+        end
+
+        # Executes the given block in a temporary run_context with its own
+        # resource collection. After the block is executed, any resources
+        # declared inside are converged, and if any are updated, the
+        # new_resource will be marked updated.
+        def recipe_eval_with_update_check(&block)
+          saved_run_context = @run_context
+          temp_run_context = @run_context.dup
+          @run_context = temp_run_context
+          @run_context.resource_collection = Chef::ResourceCollection.new
+
+          return_value = instance_eval(&block)
+          Chef::Runner.new(@run_context).converge
+          return_value
+        ensure
+          @run_context = saved_run_context
+          if temp_run_context.resource_collection.any? {|r| r.updated? }
+            new_resource.updated_by_last_action(true)
+          end
+        end
+
+      end
+
+      extend Chef::Mixin::ConvertToClassName
+      extend Chef::Mixin::FromFile
+
+      include Chef::DSL::Recipe
+
+      # These were previously provided by Chef::Mixin::RecipeDefinitionDSLCore.
+      # They are not included by its replacment, Chef::DSL::Recipe, but
+      # they may be used in existing LWRPs.
+      include Chef::DSL::PlatformIntrospection
+      include Chef::DSL::DataQuery
+
+      def self.build_from_file(cookbook_name, filename, run_context)
+        provider_name = filename_to_qualified_string(cookbook_name, filename)
+
+        # Add log entry if we override an existing light-weight provider.
+        class_name = convert_to_class_name(provider_name)
+
+        if Chef::Provider.const_defined?(class_name)
+          Chef::Log.info("#{class_name} light-weight provider already initialized -- overriding!")
+        end
+
+        provider_class = Class.new(self)
+        provider_class.class_from_file(filename)
+
+        class_name = convert_to_class_name(provider_name)
+        Chef::Provider.const_set(class_name, provider_class)
+        Chef::Log.debug("Loaded contents of #{filename} into a provider named #{provider_name} defined in Chef::Provider::#{class_name}")
+
+        provider_class
+      end
+
+      # Enables inline evaluation of resources in provider actions.
+      #
+      # Without this option, any resources declared inside the LWRP are added
+      # to the resource collection after the current position at the time the
+      # action is executed. Because they are added to the primary resource
+      # collection for the chef run, they can notify other resources outside
+      # the LWRP, and potentially be notified by resources outside the LWRP
+      # (but this is complicated by the fact that they don't exist until the
+      # provider executes). In this mode, it is impossible to correctly set the
+      # updated_by_last_action flag on the parent LWRP resource, since it
+      # executes and returns before its component resources are run.
+      #
+      # With this option enabled, each action creates a temporary run_context
+      # with its own resource collection, evaluates the action's code in that
+      # context, and then converges the resources created. If any resources
+      # were updated, then this provider's new_resource will be marked updated.
+      #
+      # In this mode, resources created within the LWRP cannot interact with
+      # external resources via notifies, though notifications to other
+      # resources within the LWRP will work. Delayed notifications are executed
+      # at the conclusion of the provider's action, *not* at the end of the
+      # main chef run.
+      #
+      # This mode of evaluation is experimental, but is believed to be a better
+      # set of tradeoffs than the append-after mode, so it will likely become
+      # the default in a future major release of Chef.
+      #
+      def self.use_inline_resources
+        extend InlineResources::ClassMethods
+        include InlineResources
+      end
+
+      # DSL for defining a provider's actions.
+      def self.action(name, &block)
+        define_method("action_#{name}") do
+          instance_eval(&block)
+        end
+      end
+
+      # no-op `load_current_resource`. Allows simple LWRP providers to work
+      # without defining this method explicitly (silences
+      # Chef::Exceptions::Override exception)
+      def load_current_resource
+      end
+
+    end
+  end
+end