tylerrick-chef 0.10.8

data/lib/chef/rest/auth_credentials.rb

@@ -0,0 +1,71 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Thom May (<thom@clearairturbulence.org>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2009, 2010 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/exceptions'
+require 'mixlib/authentication/signedheaderauth'
+
+class Chef
+  class REST
+    class AuthCredentials
+      attr_reader :key_file, :client_name, :key, :raw_key
+
+      def initialize(client_name=nil, key_file=nil)
+        @client_name, @key_file = client_name, key_file
+        load_signing_key if sign_requests?
+      end
+
+      def sign_requests?
+        !!key_file
+      end
+
+      def signature_headers(request_params={})
+        raise ArgumentError, "Cannot sign the request without a client name, check that :node_name is assigned" if client_name.nil?
+        Chef::Log.debug("Signing the request as #{client_name}")
+
+        # params_in = {:http_method => :GET, :path => "/clients", :body => "", :host => "localhost"}
+        request_params             = request_params.dup
+        request_params[:timestamp] = Time.now.utc.iso8601
+        request_params[:user_id]   = client_name
+        host = request_params.delete(:host) || "localhost"
+
+        sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(request_params)
+        signed =  sign_obj.sign(key).merge({:host => host})
+        signed.inject({}){|memo, kv| memo["#{kv[0].to_s.upcase}"] = kv[1];memo}
+      end
+
+      private
+
+      def load_signing_key
+        @raw_key = IO.read(key_file).strip
+        @key = OpenSSL::PKey::RSA.new(@raw_key)
+      rescue SystemCallError, IOError => e
+        Chef::Log.warn "Failed to read the private key #{key_file}: #{e.inspect}"
+        raise Chef::Exceptions::PrivateKeyMissing, "I cannot read #{key_file}, which you told me to use to sign requests!"
+      rescue OpenSSL::PKey::RSAError
+        msg = "The file #{key_file} does not contain a correctly formatted private key.\n"
+        msg << "The key file should begin with '-----BEGIN RSA PRIVATE KEY-----' and end with '-----END RSA PRIVATE KEY-----'"
+        raise Chef::Exceptions::InvalidPrivateKey, msg
+      end
+
+    end
+  end
+end

data/lib/chef/rest/cookie_jar.rb

@@ -0,0 +1,31 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Thom May (<thom@clearairturbulence.org>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2009, 2010 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 'singleton'
+
+class Chef
+  class REST
+    class CookieJar < Hash
+      include Singleton
+    end
+  end
+end

data/lib/chef/rest/rest_request.rb

@@ -0,0 +1,213 @@
+#--
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Thom May (<thom@clearairturbulence.org>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2009, 2010 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 'uri'
+require 'net/http'
+require 'chef/rest/cookie_jar'
+
+# To load faster, we only want ohai's version string.
+# However, in ohai before 0.6.0, the version is defined
+# in ohai, not ohai/version
+begin
+  require 'ohai/version' #used in user agent string.
+rescue LoadError
+  require 'ohai'
+end
+
+require 'chef/version'
+
+class Chef
+  class REST
+    class RESTRequest
+
+      engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"
+
+      UA_COMMON = "/#{::Chef::VERSION} (#{engine}-#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}; ohai-#{Ohai::VERSION}; #{RUBY_PLATFORM}; +http://opscode.com)"
+      DEFAULT_UA = "Chef Client" << UA_COMMON
+
+      def self.user_agent=(ua)
+        @user_agent = ua
+      end
+
+      def self.user_agent
+        @user_agent ||= DEFAULT_UA
+      end
+
+      attr_reader :method, :url, :headers, :http_client, :http_request
+
+      def initialize(method, url, req_body, base_headers={})
+        @method, @url = method, url
+        @request_body = nil
+        @cookies = CookieJar.instance
+        configure_http_client
+        build_headers(base_headers)
+        configure_http_request(req_body)
+      end
+
+      def host
+        @url.host
+      end
+
+      def port
+        @url.port
+      end
+
+      def query
+        @url.query
+      end
+
+      def path
+        @url.path.empty? ? "/" : @url.path
+      end
+
+      def call
+        hide_net_http_bug do
+          http_client.request(http_request) do |response|
+            store_cookie(response)
+            yield response if block_given?
+            response
+          end
+        end
+      end
+
+      def config
+        Chef::Config
+      end
+
+      private
+
+      def hide_net_http_bug
+        yield
+      rescue NoMethodError => e
+        # http://redmine.ruby-lang.org/issues/show/2708
+        # http://redmine.ruby-lang.org/issues/show/2758
+        if e.to_s =~ /#{Regexp.escape(%q|undefined method `closed?' for nil:NilClass|)}/
+          Chef::Log.debug("Rescued error in http connect, re-raising as Errno::ECONNREFUSED to hide bug in net/http")
+          Chef::Log.debug("#{e.class.name}: #{e.to_s}")
+          Chef::Log.debug(e.backtrace.join("\n"))
+          raise Errno::ECONNREFUSED, "Connection refused attempting to contact #{url.scheme}://#{host}:#{port}"
+        else
+          raise
+        end
+      end
+
+      def store_cookie(response)
+        if response['set-cookie']
+          @cookies["#{host}:#{port}"] = response['set-cookie']
+        end
+      end
+
+      def build_headers(headers)
+        @headers = headers.dup
+        # TODO: need to set accept somewhere else
+        # headers.merge!('Accept' => "application/json") unless raw
+        @headers['X-Chef-Version'] = ::Chef::VERSION
+
+        if @cookies.has_key?("#{host}:#{port}")
+          @headers['Cookie'] = @cookies["#{host}:#{port}"]
+        end
+      end
+
+      #adapted from buildr/lib/buildr/core/transports.rb
+      def proxy_uri
+        proxy = Chef::Config["#{url.scheme}_proxy"]
+        proxy = URI.parse(proxy) if String === proxy
+        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 configure_http_client
+        http_proxy = proxy_uri
+        if http_proxy.nil?
+          @http_client = Net::HTTP.new(host, port)
+        else
+          Chef::Log.debug("Using #{http_proxy.host}:#{http_proxy.port} for proxy")
+          user = Chef::Config["#{url.scheme}_proxy_user"]
+          pass = Chef::Config["#{url.scheme}_proxy_pass"]
+          @http_client = Net::HTTP.Proxy(http_proxy.host, http_proxy.port, user, pass).new(host, port)
+        end
+        if url.scheme == "https"
+          @http_client.use_ssl = true
+          if config[:ssl_verify_mode] == :verify_none
+            @http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          elsif config[:ssl_verify_mode] == :verify_peer
+            @http_client.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          end
+          if config[:ssl_ca_path]
+            unless ::File.exist?(config[:ssl_ca_path])
+              raise Chef::Exceptions::ConfigurationError, "The configured ssl_ca_path #{config[:ssl_ca_path]} does not exist"
+            end
+            @http_client.ca_path = config[:ssl_ca_path]
+          elsif config[:ssl_ca_file]
+            unless ::File.exist?(config[:ssl_ca_file])
+              raise Chef::Exceptions::ConfigurationError, "The configured ssl_ca_file #{config[:ssl_ca_file]} does not exist"
+            end
+            @http_client.ca_file = config[:ssl_ca_file]
+          end
+          if (config[:ssl_client_cert] || config[:ssl_client_key])
+            unless (config[:ssl_client_cert] && config[:ssl_client_key])
+              raise Chef::Exceptions::ConfigurationError, "You must configure ssl_client_cert and ssl_client_key together"
+            end
+            unless ::File.exists?(config[:ssl_client_cert])
+              raise Chef::Exceptions::ConfigurationError, "The configured ssl_client_cert #{config[:ssl_client_cert]} does not exist"
+            end
+            unless ::File.exists?(config[:ssl_client_key])
+              raise Chef::Exceptions::ConfigurationError, "The configured ssl_client_key #{config[:ssl_client_key]} does not exist"
+            end
+            @http_client.cert = OpenSSL::X509::Certificate.new(::File.read(config[:ssl_client_cert]))
+            @http_client.key = OpenSSL::PKey::RSA.new(::File.read(config[:ssl_client_key]))
+          end
+        end
+
+        @http_client.read_timeout = config[:rest_timeout]
+      end
+
+
+      def configure_http_request(request_body=nil)
+        req_path = "#{path}"
+        req_path << "?#{query}" if query
+
+        @http_request = case method.to_s.downcase
+        when "get"
+          Net::HTTP::Get.new(req_path, headers)
+        when "post"
+          Net::HTTP::Post.new(req_path, headers)
+        when "put"
+          Net::HTTP::Put.new(req_path, headers)
+        when "delete"
+          Net::HTTP::Delete.new(req_path, headers)
+        when "head"
+          Net::HTTP::Head.new(req_path, headers)
+        else
+          raise ArgumentError, "You must provide :GET, :PUT, :POST, :DELETE or :HEAD as the method"
+        end
+
+        @http_request.body = request_body if (request_body && @http_request.request_body_permitted?)
+        # Optionally handle HTTP Basic Authentication
+        @http_request.basic_auth(url.user, url.password) if url.user
+        @http_request['User-Agent'] = self.class.user_agent
+      end
+
+    end
+  end
+end

data/lib/chef/role.rb

@@ -0,0 +1,343 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@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 'chef/run_list'
+require 'chef/index_queue'
+require 'chef/mash'
+require 'chef/json_compat'
+require 'chef/search/query'
+
+class Chef
+  class Role
+
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    include Chef::IndexQueue::Indexable
+
+    DESIGN_DOCUMENT = {
+      "version" => 6,
+      "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, :couchdb
+    attr_reader :couchdb_id
+
+    # Create a new Chef::Role object.
+    def initialize(couchdb=nil)
+      @name = ''
+      @description = ''
+      @default_attributes = Mash.new
+      @override_attributes = Mash.new
+      @env_run_lists = {"_default" => Chef::RunList.new}
+      @couchdb_rev = nil
+      @couchdb_id = nil
+      @couchdb = couchdb || Chef::CouchDB.new
+    end
+
+    def couchdb_id=(value)
+      @couchdb_id = value
+      self.index_id = value
+    end
+
+    def chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])
+    end
+
+    def self.chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])
+    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 run_list(*args)
+      if (args.length > 0)
+        @env_run_lists["_default"].reset!(args)
+      end
+      @env_run_lists["_default"]
+    end
+
+    alias_method :recipes, :run_list
+
+    # For run_list expansion
+    def run_list_for(environment)
+      if env_run_lists[environment].nil?
+        env_run_lists["_default"]
+      else
+        env_run_lists[environment]
+      end
+    end
+
+    def active_run_list_for(environment)
+      @env_run_lists.has_key?(environment) ? environment : '_default'
+    end
+
+    # Per environment run lists
+    def env_run_lists(env_run_lists=nil)
+      if (!env_run_lists.nil?)
+        unless env_run_lists.key?("_default")
+          msg = "_default key is required in env_run_lists.\n"
+          msg << "(env_run_lists: #{env_run_lists.inspect})"
+          raise Chef::Exceptions::InvalidEnvironmentRunListSpecification, msg
+        end
+        @env_run_lists.clear
+        env_run_lists.each { |k,v| @env_run_lists[k] = Chef::RunList.new(*Array(v))}
+      end
+      @env_run_lists
+    end
+
+    alias :env_run_list :env_run_lists
+
+    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
+      env_run_lists_without_default = @env_run_lists.dup
+      env_run_lists_without_default.delete("_default")
+      result = {
+        "name" => @name,
+        "description" => @description,
+        'json_class' => self.class.name,
+        "default_attributes" => @default_attributes,
+        "override_attributes" => @override_attributes,
+        "chef_type" => "role",
+        "run_list" => run_list,
+        "env_run_lists" => env_run_lists_without_default
+      }
+      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
+
+    def update_from!(o)
+      description(o.description)
+      recipes(o.recipes) if defined?(o.recipes)
+      default_attributes(o.default_attributes)
+      override_attributes(o.override_attributes)
+      env_run_lists(o.env_run_lists) unless o.env_run_lists.nil?
+      self
+    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"])
+
+      # _default run_list is in 'run_list' for newer clients, and
+      # 'recipes' for older clients.
+      env_run_list_hash = {"_default" => (o.has_key?("run_list") ? o["run_list"] : o["recipes"])}
+
+      # Clients before 0.10 do not include env_run_lists, so only
+      # merge if it's there.
+      if o["env_run_lists"]
+        env_run_list_hash.merge!(o["env_run_lists"])
+      end
+      role.env_run_lists(env_run_list_hash)
+
+      role.couchdb_rev = o["_rev"] if o.has_key?("_rev")
+      role.index_id = role.couchdb_id
+      role.couchdb_id = o["_id"] if o.has_key?("_id")
+      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.cdb_list(inflate=false, couchdb=nil)
+      rs = (couchdb || Chef::CouchDB.new).list("roles", inflate)
+      lookup = (inflate ? "value" : "key")
+      rs["rows"].collect { |r| r[lookup] }
+    end
+
+    # Get the list of all roles from the API.
+    def self.list(inflate=false)
+      if inflate
+        response = Hash.new
+        Chef::Search::Query.new.search(:role) do |n|
+          response[n.name] = n unless n.nil?
+        end
+        response
+      else
+        chef_server_rest.get_rest("roles")
+      end
+    end
+
+    # Load a role by name from CouchDB
+    def self.cdb_load(name, couchdb=nil)
+      (couchdb || Chef::CouchDB.new).load("role", name)
+    end
+
+    # Load a role by name from the API
+    def self.load(name)
+      chef_server_rest.get_rest("roles/#{name}")
+    end
+
+    def self.exists?(rolename, couchdb)
+      begin
+        self.cdb_load(rolename, couchdb)
+      rescue Chef::Exceptions::CouchDBNotFound
+        nil
+      end
+    end
+
+    def environment(env_name)
+      chef_server_rest.get_rest("roles/#{@name}/environments/#{env_name}")
+    end
+
+    def environments
+      chef_server_rest.get_rest("roles/#{@name}/environments")
+    end
+
+    # Remove this role from the CouchDB
+    def cdb_destroy
+      couchdb.delete("role", @name, couchdb_rev)
+    end
+
+    # Remove this role via the REST API
+    def destroy
+      chef_server_rest.delete_rest("roles/#{@name}")
+    end
+
+    # Save this role to the CouchDB
+    def cdb_save
+      self.couchdb_rev = couchdb.store("role", @name, self)["rev"]
+    end
+
+    # Save this role via the REST API
+    def save
+      begin
+        chef_server_rest.put_rest("roles/#{@name}", self)
+      rescue Net::HTTPServerException => e
+        raise e unless e.response.code == "404"
+        chef_server_rest.post_rest("roles", self)
+      end
+      self
+    end
+
+    # Create the role via the REST API
+    def create
+      chef_server_rest.post_rest("roles", self)
+      self
+    end
+
+    # Set up our CouchDB design document
+    def self.create_design_document(couchdb=nil)
+      (couchdb || 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"
+        # from_json returns object.class => json_class in the JSON.
+        Chef::JSONCompat.from_json(IO.read(js_file))
+      elsif File.exists?(rb_file) || force == "ruby"
+        role = Chef::Role.new
+        role.name(name)
+        role.from_file(rb_file)
+        role
+      else
+        raise Chef::Exceptions::RoleNotFound, "Role '#{name}' could not be loaded from disk"
+      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.cdb_load(short_name)
+          r.couchdb_rev = couch_role.couchdb_rev
+          Chef::Log.debug("Replacing role #{short_name} with data from #{role_file}")
+        rescue Chef::Exceptions::CouchDBNotFound
+          Chef::Log.debug("Creating role #{short_name} with data from #{role_file}")
+        end
+        r.cdb_save
+      end
+    end
+
+  end
+end