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

data/lib/chef/provider/remote_file/ftp.rb

@@ -0,0 +1,183 @@
+#
+# Author:: Jesse Campbell (<hikeit@gmail.com>)
+# Copyright:: Copyright (c) 2013 Jesse Campbell
+# 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 'uri'
+require 'tempfile'
+require 'net/ftp'
+require 'chef/provider/remote_file'
+require 'chef/file_content_management/tempfile'
+
+class Chef
+  class Provider
+    class RemoteFile
+      class FTP
+
+        attr_reader :uri
+        attr_reader :new_resource
+        attr_reader :current_resource
+
+        def initialize(uri, new_resource, current_resource)
+          @uri = uri
+          @new_resource = new_resource
+          @current_resource = current_resource
+          validate_typecode!
+          validate_path!
+        end
+
+        def hostname
+          @uri.host
+        end
+
+        def port
+          @uri.port
+        end
+
+        def use_passive_mode?
+          ! new_resource.ftp_active_mode
+        end
+
+        def typecode
+          uri.typecode
+        end
+
+        def user
+          if uri.userinfo
+            URI.unescape(uri.user)
+          else
+            'anonymous'
+          end
+        end
+
+        def pass
+          if uri.userinfo
+            URI.unescape(uri.password)
+          else
+            nil
+          end
+        end
+
+        def directories
+          parse_path if @directories.nil?
+          @directories
+        end
+
+        def filename
+          parse_path if @filename.nil?
+          @filename
+        end
+
+
+        def fetch
+          with_connection do
+            get
+          end
+        end
+
+        def ftp
+          @ftp ||= Net::FTP.new
+        end
+
+        private
+
+        def with_proxy_env
+          saved_socks_env = ENV['SOCKS_SERVER']
+          ENV['SOCKS_SERVER'] = proxy_uri(@uri).to_s
+          yield
+        ensure
+          ENV['SOCKS_SERVER'] = saved_socks_env
+        end
+
+        def with_connection
+          with_proxy_env do
+            connect
+            yield
+          end
+        ensure
+          disconnect
+        end
+
+        def validate_typecode!
+          # Only support ascii and binary types
+          if typecode and /\A[ai]\z/ !~ typecode
+            raise ArgumentError, "invalid typecode: #{typecode.inspect}"
+          end
+        end
+
+        def validate_path!
+          parse_path
+        end
+
+        def connect
+          # The access sequence is defined by RFC 1738
+          ftp.connect(hostname, port)
+          ftp.passive = use_passive_mode?
+          ftp.login(user, pass)
+          directories.each do |cwd|
+            ftp.voidcmd("CWD #{cwd}")
+          end
+        end
+
+        def disconnect
+          ftp.close
+        end
+
+        # Fetches using Net::FTP, returns a Tempfile with the content
+        def get
+          tempfile = Chef::FileContentManagement::Tempfile.new(@new_resource).tempfile
+          if typecode
+            ftp.voidcmd("TYPE #{typecode.upcase}")
+          end
+          ftp.getbinaryfile(filename, tempfile.path)
+          tempfile
+        end
+
+        #adapted from buildr/lib/buildr/core/transports.rb via chef/rest/rest_client.rb
+        def proxy_uri(uri)
+          proxy = Chef::Config["ftp_proxy"]
+          proxy = URI.parse(proxy) if String === proxy
+          if Chef::Config["ftp_proxy_user"]
+            proxy.user = Chef::Config["ftp_proxy_user"]
+          end
+          if Chef::Config["ftp_proxy_pass"]
+            proxy.password = Chef::Config["ftp_proxy_pass"]
+          end
+          excludes = Chef::Config[:no_proxy].to_s.split(/\s*,\s*/).compact
+          excludes = excludes.map { |exclude| exclude =~ /:\d+$/ ? exclude : "#{exclude}:*" }
+          return proxy unless excludes.any? { |exclude| File.fnmatch(exclude, "#{host}:#{port}") }
+        end
+
+        def parse_path
+          path = uri.path.sub(%r{\A/}, '%2F') # re-encode the beginning slash because uri library decodes it.
+          directories = path.split(%r{/}, -1)
+          directories.each {|d|
+            d.gsub!(/%([0-9A-Fa-f][0-9A-Fa-f])/) { [$1].pack("H2") }
+          }
+          unless filename = directories.pop
+            raise ArgumentError, "no filename: #{path.inspect}"
+          end
+          if filename.length == 0 || filename.end_with?( "/" )
+            raise ArgumentError, "no filename: #{path.inspect}"
+          end
+
+          @directories, @filename = directories, filename
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/provider/remote_file/http.rb

@@ -0,0 +1,124 @@
+#
+# Author:: Jesse Campbell (<hikeit@gmail.com>)
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2013 Jesse Campbell
+# 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/rest'
+require 'chef/digester'
+require 'chef/provider/remote_file'
+require 'chef/provider/remote_file/cache_control_data'
+
+class Chef
+  class Provider
+    class RemoteFile
+
+      class HTTP
+
+        attr_reader :uri
+        attr_reader :new_resource
+        attr_reader :current_resource
+
+        # Parse the uri into instance variables
+        def initialize(uri, new_resource, current_resource)
+          @uri = uri
+          @new_resource = new_resource
+          @current_resource = current_resource
+        end
+
+        def headers
+          conditional_get_headers.merge(new_resource.headers)
+        end
+
+        def conditional_get_headers
+          cache_control_headers = {}
+          if last_modified = cache_control_data.mtime and want_mtime_cache_control?
+            cache_control_headers["if-modified-since"] = last_modified
+          end
+          if etag = cache_control_data.etag and want_etag_cache_control?
+            cache_control_headers["if-none-match"] = etag
+          end
+          Chef::Log.debug("Cache control headers: #{cache_control_headers.inspect}")
+          cache_control_headers
+        end
+
+        def fetch
+          tempfile = nil
+          begin
+            rest = Chef::REST.new(uri, nil, nil, http_client_opts)
+            tempfile = rest.streaming_request(uri, headers)
+            update_cache_control_data(tempfile, rest.last_response)
+          rescue Net::HTTPRetriableError => e
+            if e.response.is_a? Net::HTTPNotModified
+              tempfile = nil
+            else
+              raise e
+            end
+          end
+          
+          tempfile
+        end
+
+        private
+
+        def update_cache_control_data(tempfile, response)
+          cache_control_data.checksum = Chef::Digester.checksum_for_file(tempfile.path)
+          cache_control_data.mtime = last_modified_time_from(response)
+          cache_control_data.etag = etag_from(response)
+          cache_control_data.save
+        end
+
+        def cache_control_data
+          @cache_control_data ||= CacheControlData.load_and_validate(uri, current_resource.checksum)
+        end
+
+        def want_mtime_cache_control?
+          new_resource.use_last_modified
+        end
+
+        def want_etag_cache_control?
+          new_resource.use_etag
+        end
+
+        def last_modified_time_from(response)
+          response['last_modified'] || response['date']
+        end
+
+        def etag_from(response)
+          response['etag']
+        end
+
+        def http_client_opts
+          opts={}
+          # CHEF-3140
+          # 1. If it's already compressed, trying to compress it more will
+          # probably be counter-productive.
+          # 2. Some servers are misconfigured so that you GET $URL/file.tgz but
+          # they respond with content type of tar and content encoding of gzip,
+          # which tricks Chef::REST into decompressing the response body. In this
+          # case you'd end up with a tar archive (no gzip) named, e.g., foo.tgz,
+          # which is not what you wanted.
+          if uri.to_s =~ /gz$/
+            Chef::Log.debug("turning gzip compression off due to filename ending in gz")
+            opts[:disable_gzip] = true
+          end
+          opts
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/provider/remote_file/local_file.rb

@@ -0,0 +1,47 @@
+#
+# Author:: Jesse Campbell (<hikeit@gmail.com>)
+# Copyright:: Copyright (c) 2013 Jesse Campbell
+# 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 'uri'
+require 'tempfile'
+require 'chef/provider/remote_file'
+
+class Chef
+  class Provider
+    class RemoteFile
+      class LocalFile
+
+        attr_reader :uri
+        attr_reader :new_resource
+
+        def initialize(uri, new_resource, current_resource)
+          @new_resource = new_resource
+          @uri = uri
+        end
+
+        # Fetches the file at uri, returning a Tempfile-like File handle
+        def fetch
+          tempfile = Chef::FileContentManagement::Tempfile.new(new_resource).tempfile
+          Chef::Log.debug("#{new_resource} staging #{uri.path} to #{tempfile.path}")
+          FileUtils.cp(uri.path, tempfile.path)
+          tempfile
+        end
+
+      end
+    end
+  end
+end

data/lib/chef/provider/route.rb

@@ -152,6 +152,9 @@ class Chef::Provider::Route < Chef::Provider
       else
         Chef::Log.debug("#{@new_resource} route does not exist - nothing to do")
       end
+
+      #for now we always write the file (ugly but its what it is)
+      generate_config
     end
 
     def generate_config
@@ -169,9 +172,10 @@ class Chef::Provider::Route < Chef::Provider
             end
 
             conf[dev] = String.new if conf[dev].nil?
-            if resource.action == :add
+            case @action
+            when :add
               conf[dev] << config_file_contents(:add, :target => resource.target, :netmask => resource.netmask, :gateway => resource.gateway)
-            else
+            when :delete
               # need to do this for the case when the last route on an int
               # is removed
               conf[dev] << config_file_contents(:delete)

data/lib/chef/provider/ruby_block.rb

@@ -28,12 +28,15 @@ class Chef
         true
       end
 
-      def action_create
-        converge_by("execute the ruby block #{@new_resource.name}") do
+      def action_run
+        converge_by("execute the ruby block #{@new_resource.name}") do 
           @new_resource.block.call
           Chef::Log.info("#{@new_resource} called")
         end
       end
+
+      alias :action_create :action_run
+
     end
   end
 end

data/lib/chef/provider/script.rb

@@ -23,13 +23,18 @@ class Chef
   class Provider
     class Script < Chef::Provider::Execute
 
+      def initialize(new_resource, run_context)
+        super
+        @code = @new_resource.code
+      end
+      
       def action_run
-        script_file.puts(@new_resource.code)
+        script_file.puts(@code)
         script_file.close
 
         set_owner_and_group
 
-        @new_resource.command("\"#{@new_resource.interpreter}\" #{@new_resource.flags} \"#{script_file.path}\"")
+        @new_resource.command("\"#{interpreter}\" #{flags} \"#{script_file.path}\"")
         super
         converge_by(nil) do
           # ensure script is unlinked at end of converge!
@@ -52,6 +57,13 @@ class Chef
         @script_file && @script_file.close!
       end
 
+      def interpreter
+        @new_resource.interpreter
+      end
+
+      def flags
+        @new_resource.flags
+      end
     end
   end
 end

data/lib/chef/provider/service.rb

@@ -153,6 +153,21 @@ class Chef
         raise Chef::Exceptions::UnsupportedAction, "#{self.to_s} does not support :restart"
       end
 
+      protected
+
+      def default_init_command
+        if @new_resource.init_command
+          @new_resource.init_command
+        elsif self.instance_variable_defined?(:@init_command)
+          @init_command
+        end
+      end
+
+      def custom_command_for_action?(action)
+        method_name = "#{action}_command".to_sym
+        @new_resource.respond_to?(method_name) &&
+          !!@new_resource.send(method_name)
+      end
     end
   end
 end