chef 0.7.10

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

data/lib/chef/role.rb

@@ -0,0 +1,231 @@
+#
+# 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/config'
+require 'chef/mixin/params_validate'
+require 'chef/mixin/from_file'
+require 'chef/couchdb'
+require 'extlib'
+require 'json'
+
+class Chef
+  class Role 
+    
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    
+    DESIGN_DOCUMENT = {
+      "version" => 3,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "role") {
+              emit(doc.name, doc);
+            }
+          }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "role") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        },
+      },
+    }
+
+    attr_accessor :couchdb_rev
+    
+    # Create a new Chef::Role object.
+    def initialize()
+      @name = '' 
+      @description = '' 
+      @default_attributes = Mash.new
+      @override_attributes = Mash.new
+      @recipes = Array.new 
+      @couchdb_rev = nil
+      @couchdb = Chef::CouchDB.new
+    end
+
+    def name(arg=nil) 
+      set_or_return(
+        :name,
+        arg,
+        :regex => /^[\-[:alnum:]_]+$/
+      )
+    end
+
+    def description(arg=nil) 
+      set_or_return(
+        :description,
+        arg,
+        :kind_of => String
+      )
+    end
+
+    def recipes(*arg) 
+      arg.flatten!
+      if arg.length == 0
+        @recipes
+      else
+        arg.each do |entry|
+          raise ArgumentError, 'Recipes must be strings!' unless entry.kind_of?(String)
+        end
+        @recipes = arg
+      end
+    end
+
+    def default_attributes(arg=nil)
+      set_or_return(
+        :default_attributes,
+        arg,
+        :kind_of => Hash
+      )
+    end
+
+    def override_attributes(arg=nil)
+      set_or_return(
+        :override_attributes,
+        arg,
+        :kind_of => Hash
+      )
+    end
+
+    def to_hash
+      result = {
+        "name" => @name,
+        "description" => @description,
+        'json_class' => self.class.name,
+        "default_attributes" => @default_attributes,
+        "override_attributes" => @override_attributes,
+        "chef_type" => "role",
+        "recipes" => @recipes,
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result
+    end
+
+    # Serialize this object as a hash 
+    def to_json(*a)
+      to_hash.to_json(*a)
+    end
+    
+    # Create a Chef::Role from JSON
+    def self.json_create(o)
+      role = new
+      role.name(o["name"])
+      role.description(o["description"])
+      role.default_attributes(o["default_attributes"])
+      role.override_attributes(o["override_attributes"])
+      role.recipes(o["recipes"])
+      role.couchdb_rev = o["_rev"] if o.has_key?("_rev")
+      role 
+    end
+    
+    # List all the Chef::Role objects in the CouchDB.  If inflate is set to true, you will get
+    # the full list of all Roles, fully inflated.
+    def self.list(inflate=false)
+      rs = Chef::CouchDB.new.list("roles", inflate)
+      if inflate
+        rs["rows"].collect { |r| r["value"] }
+      else
+        rs["rows"].collect { |r| r["key"] }
+      end
+    end
+    
+    # Load a role by name from CouchDB
+    def self.load(name)
+      Chef::CouchDB.new.load("role", name)
+    end
+    
+    # Remove this role from the CouchDB
+    def destroy
+      @couchdb.delete("role", @name, @couchdb_rev)
+
+      if Chef::Config[:couchdb_version] == 0.9
+        rs = @couchdb.get_view("nodes", "by_run_list", :startkey => "role[#{@name}]", :endkey => "role[#{@name}]", :include_docs => true)
+        rs["rows"].each do |row| 
+          node = row["doc"]
+          node.run_list.remove("role[#{@name}]")
+          node.save
+        end
+      else
+       Chef::Node.list.each do |node|
+         n = Chef::Node.load(node)
+         n.run_list.remove("role[#{@name}]")
+         n.save
+       end
+      end
+    end
+    
+    # Save this role to the CouchDB
+    def save
+      results = @couchdb.store("role", @name, self)
+      @couchdb_rev = results["rev"]
+    end
+    
+    # Set up our CouchDB design document
+    def self.create_design_document
+      Chef::CouchDB.new.create_design_document("roles", DESIGN_DOCUMENT)
+    end
+    
+    # As a string
+    def to_s
+      "role[#{@name}]"
+    end
+
+    # Load a role from disk - prefers to load the JSON, but will happily load
+    # the raw rb files as well.
+    def self.from_disk(name, force=nil)
+      js_file = File.join(Chef::Config[:role_path], "#{name}.json")
+      rb_file = File.join(Chef::Config[:role_path], "#{name}.rb")
+
+      if File.exists?(js_file) || force == "json"
+        JSON.parse(IO.read(js_file))
+      elsif File.exists?(rb_file) || force == "ruby"
+        role = Chef::Role.new
+        role.name(name)
+        role.from_file(rb_file)
+        role
+      end
+    end
+
+    # Sync all the json roles with couchdb from disk
+    def self.sync_from_disk_to_couchdb
+      Dir[File.join(Chef::Config[:role_path], "*.json")].each do |role_file|
+        short_name = File.basename(role_file, ".json") 
+        Chef::Log.warn("Loading #{short_name}")
+        r = Chef::Role.from_disk(short_name, "json")
+        begin
+          couch_role = Chef::Role.load(short_name)
+          r.couchdb_rev = couch_role.couchdb_rev
+          Chef::Log.debug("Replacing role #{short_name} with data from #{role_file}")
+        rescue Net::HTTPServerException
+          Chef::Log.debug("Creating role #{short_name} with data from #{role_file}")
+        end
+        r.save
+      end
+    end
+
+  end
+end