giraffesoft-chef 0.7.15

data/lib/chef/resource_collection.rb

@@ -0,0 +1,204 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009 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'
+
+class Chef
+  class ResourceCollection
+    include Enumerable
+
+    def initialize
+      @resources = Array.new
+      @resources_by_name = Hash.new
+      @insert_after_idx = nil
+    end
+    
+    def [](index)
+      @resources[index]
+    end
+    
+    def []=(index, arg)
+      is_chef_resource(arg)
+      @resources[index] = arg 
+      @resources_by_name[arg.to_s] = index
+    end
+
+    def <<(*args)
+      args.flatten.each do |a|
+        is_chef_resource(a)
+        @resources << a
+        @resources_by_name[a.to_s] = @resources.length - 1 
+      end
+    end
+
+    def insert(resource)
+      is_chef_resource(resource)
+      if @insert_after_idx
+        # in the middle of executing a run, so any resources inserted now should
+        # be placed after the most recent addition done by the currently executing
+        # resource
+        @resources.insert(@insert_after_idx + 1, resource)
+        # update name -> location mappings and register new resource
+        @resources_by_name.each_key do |key|
+          @resources_by_name[key] += 1 if @resources_by_name[key] > @insert_after_idx
+        end
+        @resources_by_name[resource.to_s] = @insert_after_idx + 1
+        @insert_after_idx += 1
+      else  
+        @resources << resource
+        @resources_by_name[resource.to_s] = @resources.length - 1
+      end
+    end
+    
+    def push(*args)
+      args.flatten.each do |a|
+        is_chef_resource(a)
+        @resources.push(a)
+        @resources_by_name[a.to_s] = @resources.length - 1
+      end
+    end
+  
+    def each
+      @resources.each do |r|
+        yield r
+      end
+    end
+
+    def execute_each_resource
+      @resources.each_with_index do |r, idx|
+        @insert_after_idx = idx
+        yield r
+      end
+    end
+    
+    def each_index
+      @resources.each_index do |i|
+        yield i
+      end
+    end
+    
+    def lookup(resource)
+      lookup_by = nil
+      if resource.kind_of?(Chef::Resource)
+        lookup_by = resource.to_s
+      elsif resource.kind_of?(String)
+        lookup_by = resource
+      else
+        raise ArgumentError, "Must pass a Chef::Resource or String to lookup"
+      end
+      res = @resources_by_name[lookup_by]
+      unless res
+        raise ArgumentError, "Cannot find a resource matching #{lookup_by} (did you define it first?)"
+      end
+      @resources[res]
+    end
+
+    # Find existing resources by searching the list of existing resources.  Possible
+    # forms are:
+    #
+    # resources(:file => "foobar")
+    # resources(:file => [ "foobar", "baz" ])
+    # resources("file[foobar]", "file[baz]")
+    # resources("file[foobar,baz]")
+    #
+    # Returns the matching resource, or an Array of matching resources. 
+    #
+    # Raises an ArgumentError if you feed it bad lookup information
+    # Raises a Runtime Error if it can't find the resources you are looking for.
+    def resources(*args)
+      results = Array.new
+      args.each do |arg|
+        case arg
+        when Hash
+          results << find_resource_by_hash(arg)
+        when String
+          results << find_resource_by_string(arg)
+        else
+          raise ArgumentError, "resources takes arguments as a hash or strings!"
+        end
+      end
+      flat_results = results.flatten
+      flat_results.length == 1 ? flat_results[0] : flat_results
+    end
+    
+    # Serialize this object as a hash 
+    def to_json(*a)
+      instance_vars = Hash.new
+      self.instance_variables.each do |iv|
+        instance_vars[iv] = self.instance_variable_get(iv)
+      end
+      results = {
+        'json_class' => self.class.name,
+        'instance_vars' => instance_vars
+      }
+      results.to_json(*a)
+    end
+    
+    def self.json_create(o)
+      collection = self.new()
+      o["instance_vars"].each do |k,v|
+        collection.instance_variable_set(k.to_sym, v)
+      end
+      collection
+    end
+
+    private
+    
+      def find_resource_by_hash(arg)
+        results = Array.new
+        arg.each do |resource_name, name_list|
+          names = name_list.kind_of?(Array) ? name_list : [ name_list ]
+          names.each do |name|
+            res_name = "#{resource_name.to_s}[#{name}]"
+            results << lookup(res_name)
+          end
+        end
+        return results
+      end
+
+      def find_resource_by_string(arg)
+        results = Array.new
+        case arg
+        when /^(.+)\[(.+?),(.+)\]$/
+          resource_type = $1
+          arg =~ /^.+\[(.+)\]$/
+          resource_list = $1
+          resource_list.split(",").each do |name|
+            resource_name = "#{resource_type}[#{name}]" 
+            results << lookup(resource_name)
+          end
+        when /^(.+)\[(.+)\]$/
+          resource_type = $1
+          name = $2
+          resource_name = "#{resource_type}[#{name}]"
+          results << lookup(resource_name)
+        else
+          raise ArgumentError, "You must have a string like resource_type[name]!"
+        end
+        return results
+      end
+
+      def is_chef_resource(arg)
+        unless arg.kind_of?(Chef::Resource)
+          raise ArgumentError, "Members must be Chef::Resource's" 
+        end
+        true
+      end
+  end
+end

data/lib/chef/resource_definition.rb

@@ -0,0 +1,67 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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/mixin/from_file'
+require 'chef/mixin/params_validate'
+
+class Chef
+  class ResourceDefinition
+    
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    
+    attr_accessor :name, :params, :recipe, :node
+    
+    def initialize(node=nil)
+      @name = nil
+      @params = Hash.new
+      @recipe = nil
+      @node = node
+    end
+    
+    def define(resource_name, prototype_params=nil, &block)
+      unless resource_name.kind_of?(Symbol)
+        raise ArgumentError, "You must use a symbol when defining a new resource!"
+      end
+      @name = resource_name
+      if prototype_params
+        unless prototype_params.kind_of?(Hash)
+          raise ArgumentError, "You must pass a hash as the prototype parameters for a definition."
+        end
+        @params = prototype_params
+      end
+      if Kernel.block_given?
+        @recipe = block
+      else
+        raise ArgumentError, "You must pass a block to a definition."
+      end
+      true
+    end
+    
+    # When we do the resource definition, we're really just setting new values for
+    # the paramaters we prototyped at the top.  This method missing is as simple as
+    # it gets.
+    def method_missing(symbol, *args)
+      @params[symbol] = args.length == 1 ? args[0] : args
+    end
+    
+    def to_s
+      "#{name.to_s}"
+    end
+  end
+end

data/lib/chef/rest.rb

@@ -0,0 +1,238 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Thom May (<thom@clearairturbulence.org>)
+# Copyright:: Copyright (c) 2008 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/mixin/params_validate'
+require 'chef/openid_registration'
+require 'net/https'
+require 'uri'
+require 'json'
+require 'tempfile'
+require 'singleton'
+
+class Chef
+  class REST
+
+    class CookieJar < Hash
+      include Singleton
+    end
+    
+    attr_accessor :url, :cookies
+    
+    def initialize(url)
+      @url = url
+      @cookies = CookieJar.instance
+    end
+    
+    # Register for an OpenID
+    def register(user, pass, validation_token=nil)
+      Chef::Log.debug("Registering #{user} for an openid") 
+      registration = nil
+      begin
+        registration = get_rest("registrations/#{user}")
+      rescue Net::HTTPServerException => e
+        unless e.message =~ /^404/
+          raise e
+        end
+      end
+      unless registration
+        post_rest(
+          "registrations", 
+          { 
+            :id => user, 
+            :password => pass, 
+            :validation_token => validation_token 
+          }
+        )
+      end
+    end
+    
+    # Authenticate 
+    def authenticate(user, pass)
+      Chef::Log.debug("Authenticating #{user} via openid") 
+      response = post_rest('openid/consumer/start', { 
+        "openid_identifier" => "#{Chef::Config[:openid_url]}/openid/server/node/#{user}",
+        "submit" => "Verify"
+      })
+      post_rest(
+        "#{Chef::Config[:openid_url]}#{response["action"]}",
+        { "password" => pass }
+      )
+    end
+
+    # Send an HTTP GET request to the path
+    #
+    # === Parameters
+    # path:: The path to GET
+    # raw:: Whether you want the raw body returned, or JSON inflated.  Defaults 
+    #   to JSON inflated.
+    def get_rest(path, raw=false)
+      run_request(:GET, create_url(path), false, 10, raw)    
+    end                               
+                          
+    # Send an HTTP DELETE request to the path
+    def delete_rest(path)             
+      run_request(:DELETE, create_url(path))       
+    end                               
+    
+    # Send an HTTP POST request to the path                                  
+    def post_rest(path, json)          
+      run_request(:POST, create_url(path), json)    
+    end                               
+                                      
+    # Send an HTTP PUT request to the path
+    def put_rest(path, json)           
+      run_request(:PUT, create_url(path), json)
+    end
+    
+    def create_url(path)
+      if path =~ /^(http|https):\/\//
+        URI.parse(path)
+      else
+        URI.parse("#{@url}/#{path}")
+      end
+    end
+    
+    # Actually run an HTTP request.  First argument is the HTTP method,
+    # which should be one of :GET, :PUT, :POST or :DELETE.  Next is the
+    # URL, then an object to include in the body (which will be converted with
+    # .to_json) and finally, the limit of HTTP Redirects to follow (10).
+    #
+    # Typically, you won't use this method -- instead, you'll use one of
+    # the helper methods (get_rest, post_rest, etc.)
+    #
+    # Will return the body of the response on success.
+    def run_request(method, url, data=false, limit=10, raw=false)
+      http_retry_delay = Chef::Config[:http_retry_delay] 
+      http_retry_count = Chef::Config[:http_retry_count]
+
+      raise ArgumentError, 'HTTP redirect too deep' if limit == 0 
+
+      http = Net::HTTP.new(url.host, url.port)
+      if url.scheme == "https"
+        http.use_ssl = true 
+        if Chef::Config[:ssl_verify_mode] == :verify_none
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        if File.exists?(Chef::Config[:ssl_client_cert])
+          http.cert = OpenSSL::X509::Certificate.new(File.read(Chef::Config[:ssl_client_cert]))
+          http.key = OpenSSL::PKey::RSA.new(File.read(Chef::Config[:ssl_client_key]))
+        end
+      end
+      http.read_timeout = Chef::Config[:rest_timeout]
+      headers = Hash.new
+      unless raw
+        headers = { 
+          'Accept' => "application/json",
+        }
+      end
+      if @cookies.has_key?("#{url.host}:#{url.port}")
+        headers['Cookie'] = @cookies["#{url.host}:#{url.port}"]
+      end
+      req = nil
+      case method
+      when :GET
+        req_path = "#{url.path}"
+        req_path << "?#{url.query}" if url.query
+        req = Net::HTTP::Get.new(req_path, headers)
+      when :POST
+        headers["Content-Type"] = 'application/json' if data
+        req = Net::HTTP::Post.new(url.path, headers)          
+        req.body = data.to_json if data
+      when :PUT
+        headers["Content-Type"] = 'application/json' if data
+        req = Net::HTTP::Put.new(url.path, headers)
+        req.body = data.to_json if data
+      when :DELETE
+        req_path = "#{url.path}"
+        req_path << "?#{url.query}" if url.query
+        req = Net::HTTP::Delete.new(req_path, headers)
+      else
+        raise ArgumentError, "You must provide :GET, :PUT, :POST or :DELETE as the method"
+      end
+      
+      # Optionally handle HTTP Basic Authentication
+      req.basic_auth(url.user, url.password) if url.user
+
+      Chef::Log.debug("Sending HTTP Request via #{req.method} to #{req.path}")
+      res = nil
+      tf = nil
+      http_retries = 1
+
+      begin
+        res = http.request(req) do |response|
+          if raw
+            tf = Tempfile.new("chef-rest") 
+            # Stolen from http://www.ruby-forum.com/topic/166423
+            # Kudos to _why!
+            size, total = 0, response.header['Content-Length'].to_i
+            response.read_body do |chunk|
+              tf.write(chunk) 
+              size += chunk.size
+              if size == 0
+                Chef::Log.debug("#{req.path} done (0 length file)")
+              elsif total == 0
+                Chef::Log.debug("#{req.path} (zero content length)")
+              else
+                Chef::Log.debug("#{req.path}" + " %d%% done (%d of %d)" % [(size * 100) / total, size, total])
+              end
+            end
+            tf.close 
+            tf
+          else
+            response.read_body
+          end
+          response
+        end
+      rescue Errno::ECONNREFUSED
+        Chef::Log.error("Connection refused connecting to #{url.host}:#{url.port} for #{req.path} #{http_retries}/#{http_retry_count}")
+        sleep(http_retry_delay)
+        retry if (http_retries += 1) < http_retry_count
+        raise Errno::ECONNREFUSED, "Connection refused connecting to #{url.host}:#{url.port} for #{req.path}, giving up"
+      rescue Timeout::Error
+        Chef::Log.error("Timeout connecting to #{url.host}:#{url.port} for #{req.path}, retry #{http_retries}/#{http_retry_count}")
+        sleep(http_retry_delay)
+        retry if (http_retries += 1) < http_retry_count
+        raise Timeout::Error, "Timeout connecting to #{url.host}:#{url.port} for #{req.path}, giving up"
+      end
+      
+      if res.kind_of?(Net::HTTPSuccess)
+        if res['set-cookie']
+          @cookies["#{url.host}:#{url.port}"] = res['set-cookie']
+        end
+        if res['content-type'] =~ /json/
+          JSON.parse(res.body)
+        else
+          if raw
+            tf
+          else
+            res.body
+          end
+        end
+      elsif res.kind_of?(Net::HTTPFound) or res.kind_of?(Net::HTTPMovedPermanently)
+        if res['set-cookie']
+          @cookies["#{url.host}:#{url.port}"] = res['set-cookie']
+        end
+        run_request(:GET, create_url(res['location']), false, limit - 1, raw)
+      else
+        res.error!
+      end
+    end
+ 
+  end
+end