rmm-chef 0.10.0.rc.0

data/lib/chef/config.rb

@@ -0,0 +1,244 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Author:: AJ Christensen (<aj@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/log'
+require 'mixlib/config'
+
+class Chef
+  class Config
+
+    extend Mixlib::Config
+
+    # Manages the chef secret session key
+    # === Returns
+    # <newkey>:: A new or retrieved session key
+    #
+    def self.manage_secret_key
+      newkey = nil
+      if Chef::FileCache.has_key?("chef_server_cookie_id")
+        newkey = Chef::FileCache.load("chef_server_cookie_id")
+      else
+        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+        newkey = ""
+        40.times { |i| newkey << chars[rand(chars.size-1)] }
+        Chef::FileCache.store("chef_server_cookie_id", newkey)
+      end
+      newkey
+    end
+
+    def self.inspect
+      configuration.inspect
+    end
+
+    # Override the config dispatch to set the value of multiple server options simultaneously
+    #
+    # === Parameters
+    # url<String>:: String to be set for all of the chef-server-api URL's
+    #
+    config_attr_writer :chef_server_url do |url|
+      configure do |c|
+        [ :registration_url,
+          :template_url,
+          :remotefile_url,
+          :search_url,
+          :chef_server_url,
+          :role_url ].each do |u|
+            c[u] = url
+        end
+      end
+      url
+    end
+
+    # When you are using ActiveSupport, they monkey-patch 'daemonize' into Kernel.
+    # So while this is basically identical to what method_missing would do, we pull
+    # it up here and get a real method written so that things get dispatched
+    # properly.
+    config_attr_writer :daemonize do |v|
+      configure do |c|
+        c[:daemonize] = v
+      end
+    end
+
+    # Override the config dispatch to set the value of log_location configuration option
+    #
+    # === Parameters
+    # location<IO||String>:: Logging location as either an IO stream or string representing log file path
+    #
+    config_attr_writer :log_location do |location|
+      if location.respond_to? :sync=
+        location.sync = true
+        location
+      elsif location.respond_to? :to_str
+        f = File.new(location.to_str, "a")
+        f.sync = true
+        f
+      end
+    end
+
+    # Override the config dispatch to set the value of authorized_openid_providers when openid_providers (deprecated) is used
+    #
+    # === Parameters
+    # providers<Array>:: An array of openid providers that are authorized to login to the chef server
+    #
+    config_attr_writer :openid_providers do |providers|
+      configure { |c| c[:authorized_openid_providers] = providers }
+      providers
+    end
+
+    # Turn on "path sanity" by default. See also: http://wiki.opscode.com/display/chef/User+Environment+PATH+Sanity
+    enforce_path_sanity(true)
+
+    # Used when OpenID authentication is enabled in the Web UI
+    authorized_openid_identifiers nil
+    authorized_openid_providers nil
+    openid_cstore_couchdb false
+    openid_cstore_path "/var/chef/openid/cstore"
+
+    # The number of times the client should retry when registering with the server
+    client_registration_retries 5
+
+    # Where the cookbooks are located. Meaning is somewhat context dependent between
+    # knife, chef-client, and chef-solo.
+    cookbook_path [ "/var/chef/cookbooks", "/var/chef/site-cookbooks" ]
+
+    # Where files are stored temporarily during uploads
+    sandbox_path "/var/chef/sandboxes"
+
+    # Where cookbook files are stored on the server (by content checksum)
+    checksum_path "/var/chef/checksums"
+
+    # CouchDB database name to use
+    couchdb_database "chef"
+
+    couchdb_url "http://localhost:5984"
+
+    # Where chef's cache files should be stored
+    file_cache_path "/var/chef/cache"
+
+    # Where backups of chef-managed files should go
+    file_backup_path "/var/chef/backup"
+
+    ## Daemonization Settings ##
+    # What user should Chef run as?
+    user nil
+    # What group should the chef-server, -solr, -solr-indexer run as
+    group nil
+    umask 0022
+
+    http_retry_count 5
+    http_retry_delay 5
+    interval nil
+    json_attribs nil
+    log_level :info
+    log_location STDOUT
+    verbose_logging nil
+    node_name nil
+    node_path "/var/chef/node"
+
+    pid_file nil
+
+    chef_server_url   "http://localhost:4000"
+    registration_url  "http://localhost:4000"
+    template_url      "http://localhost:4000"
+    role_url          "http://localhost:4000"
+    remotefile_url    "http://localhost:4000"
+    search_url        "http://localhost:4000"
+
+    client_url "http://localhost:4042"
+
+    rest_timeout 300
+    run_command_stderr_timeout 120
+    run_command_stdout_timeout 120
+    solo  false
+    splay nil
+
+    # Set these to enable SSL authentication / mutual-authentication
+    # with the server
+    ssl_client_cert nil
+    ssl_client_key nil
+    ssl_verify_mode :verify_none
+    ssl_ca_path nil
+    ssl_ca_file nil
+
+
+    # Where should chef-solo look for role files?
+    role_path "/var/chef/roles"
+
+    # Where should chef-solo download recipes from?
+    recipe_url nil
+
+    solr_url "http://localhost:8983"
+    solr_jetty_path "/var/chef/solr-jetty"
+    solr_data_path "/var/chef/solr/data"
+    solr_home_path "/var/chef/solr"
+    solr_heap_size "256M"
+    solr_java_opts nil
+
+    # Parameters for connecting to RabbitMQ
+    amqp_host '0.0.0.0'
+    amqp_port '5672'
+    amqp_user 'chef'
+    amqp_pass 'testing'
+    amqp_vhost '/chef'
+    # Setting this to a UUID string also makes the queue durable
+    # (persist across rabbitmq restarts)
+    amqp_consumer_id "default"
+
+    client_key "/etc/chef/client.pem"
+    validation_key "/etc/chef/validation.pem"
+    validation_client_name "chef-validator"
+    web_ui_client_name "chef-webui"
+    web_ui_key "/etc/chef/webui.pem"
+    web_ui_admin_user_name  "admin"
+    web_ui_admin_default_password "p@ssw0rd1"
+
+    # Server Signing CA
+    #
+    # In truth, these don't even have to change
+    signing_ca_cert "/var/chef/ca/cert.pem"
+    signing_ca_key "/var/chef/ca/key.pem"
+    signing_ca_user nil
+    signing_ca_group nil
+    signing_ca_country "US"
+    signing_ca_state "Washington"
+    signing_ca_location "Seattle"
+    signing_ca_org "Chef User"
+    signing_ca_domain "opensource.opscode.com"
+    signing_ca_email "opensource-cert@opscode.com"
+
+    # Report Handlers
+    report_handlers []
+
+    # Exception Handlers
+    exception_handlers []
+
+    # Checksum Cache
+    # Uses Moneta on the back-end
+    cache_type "BasicFile"
+    cache_options({ :path => "/var/chef/cache/checksums", :skip_expires => true })
+
+    # Arbitrary knife configuration data
+    knife Hash.new
+
+    # Those lists of regular expressions define what chef considers a
+    # valid user and group name
+    user_valid_regex [ /^([-a-zA-Z0-9_.]+)$/, /^\d+$/ ]
+    group_valid_regex [ /^([-a-zA-Z0-9_.\\ ]+)$/, /^\d+$/ ]
+  end
+end

data/lib/chef/cookbook/chefignore.rb

@@ -0,0 +1,66 @@
+#--
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2011 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.
+#
+
+class Chef
+  class Cookbook
+    class Chefignore
+
+      COMMENTS_AND_WHITESPACE = /^\w*(?:#.*)?$/
+
+      attr_reader :ignores
+
+      def initialize(ignore_file_or_repo)
+        @ignore_file = find_ignore_file(ignore_file_or_repo)
+        @ignores = parse_ignore_file
+      end
+
+      def remove_ignores_from(file_list)
+        Array(file_list).inject([]) do |unignored, file|
+          ignored?(file) ? unignored : unignored << file
+        end
+      end
+
+      def ignored?(file_name)
+        @ignores.any? {|glob| File.fnmatch?(glob, file_name)}
+      end
+
+      private
+
+      def parse_ignore_file
+        ignore_globs = []
+        if File.exist?(@ignore_file) && File.readable?(@ignore_file)
+          File.foreach(@ignore_file) do |line|
+            ignore_globs << line.strip unless line =~ COMMENTS_AND_WHITESPACE
+          end
+        else
+          Chef::Log.debug("No chefignore file found at #@ignore_file no files will be ignored")
+        end
+        ignore_globs
+      end
+
+      def find_ignore_file(path)
+        if File.basename(path) =~ /chefignore/
+          path
+        else
+          File.join(path, 'chefignore')
+        end
+      end
+    end
+  end
+end
+

data/lib/chef/cookbook/cookbook_collection.rb

@@ -0,0 +1,45 @@
+#--
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Copyright:: Copyright (c) 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/mash'
+
+class Chef
+  # == Chef::CookbookCollection
+  # This class is the consistent interface for a node to obtain its
+  # cookbooks by name.
+  #
+  # This class is basically a glorified Hash, but since there are
+  # several ways this cookbook information is collected,
+  # (e.g. CookbookLoader for solo, hash of auto-vivified Cookbook
+  # objects for lazily-loaded remote cookbooks), it gets transformed
+  # into this.
+  class CookbookCollection < Mash
+
+    # The input is a mapping of cookbook name to CookbookVersion objects. We
+    # simply extract them
+    def initialize(cookbook_versions={})
+      super() do |hash, key|
+        raise Chef::Exceptions::CookbookNotFound, "Cookbook #{key} not found. " <<
+          "If you're loading #{key} from another cookbook, make sure you configure the dependency in your metadata"
+      end
+      cookbook_versions.each{ |cookbook_name, cookbook_version| self[cookbook_name] = cookbook_version }
+    end
+
+  end
+end

data/lib/chef/cookbook/cookbook_version_loader.rb

@@ -0,0 +1,173 @@
+
+require 'chef/config'
+require 'chef/cookbook_version'
+require 'chef/cookbook/chefignore'
+require 'chef/cookbook/metadata'
+
+class Chef
+  class Cookbook
+    class CookbookVersionLoader
+
+      FILETYPES_SUBJECT_TO_IGNORE = [ :attribute_filenames,
+                                      :definition_filenames,
+                                      :recipe_filenames,
+                                      :template_filenames,
+                                      :file_filenames,
+                                      :library_filenames,
+                                      :resource_filenames,
+                                      :provider_filenames]
+
+
+      attr_reader :cookbook_name
+      attr_reader :cookbook_settings
+      attr_reader :metadata_filenames
+
+      def initialize(path, chefignore=nil)
+        @cookbook_path = File.expand_path( path )
+        @cookbook_name = File.basename( path )
+        @chefignore = chefignore
+        @metadata = Hash.new
+        @relative_path = /#{Regexp.escape(@cookbook_path)}\/(.+)$/
+        @cookbook_settings = {
+          :attribute_filenames  => {},
+          :definition_filenames => {},
+          :recipe_filenames     => {},
+          :template_filenames   => {},
+          :file_filenames       => {},
+          :library_filenames    => {},
+          :resource_filenames   => {},
+          :provider_filenames   => {},
+          :root_filenames       => {}
+        }
+
+        @metadata_filenames = []
+      end
+
+      def load_cookbooks
+        load_as(:attribute_filenames, 'attributes', '*.rb')
+        load_as(:definition_filenames, 'definitions', '*.rb')
+        load_as(:recipe_filenames, 'recipes', '*.rb')
+        load_as(:library_filenames, 'libraries', '*.rb')
+        load_recursively_as(:template_filenames, "templates", "*")
+        load_recursively_as(:file_filenames, "files", "*")
+        load_recursively_as(:resource_filenames, "resources", "*.rb")
+        load_recursively_as(:provider_filenames, "providers", "*.rb")
+        load_root_files
+
+        remove_ignored_files
+
+        if File.exists?(File.join(@cookbook_path, "metadata.rb"))
+          @metadata_filenames << File.join(@cookbook_path, "metadata.rb")
+        elsif File.exists?(File.join(@cookbook_path, "metadata.json"))
+          @metadata_filenames << File.join(@cookbook_path, "metadata.json")
+        end
+
+        if empty?
+          Chef::Log.warn "found a directory #{cookbook_name} in the cookbook path, but it contains no cookbook files. skipping."
+        end
+        @cookbook_settings
+      end
+
+      def cookbook_version
+        return nil if empty?
+
+        Chef::CookbookVersion.new(@cookbook_name.to_sym).tap do |c|
+          c.root_dir             = @cookbook_path
+          c.attribute_filenames  = cookbook_settings[:attribute_filenames].values
+          c.definition_filenames = cookbook_settings[:definition_filenames].values
+          c.recipe_filenames     = cookbook_settings[:recipe_filenames].values
+          c.template_filenames   = cookbook_settings[:template_filenames].values
+          c.file_filenames       = cookbook_settings[:file_filenames].values
+          c.library_filenames    = cookbook_settings[:library_filenames].values
+          c.resource_filenames   = cookbook_settings[:resource_filenames].values
+          c.provider_filenames   = cookbook_settings[:provider_filenames].values
+          c.root_filenames       = cookbook_settings[:root_filenames].values
+          c.metadata_filenames   = @metadata_filenames
+          c.metadata             = metadata(c)
+        end
+      end
+
+      # Generates the Cookbook::Metadata object
+      def metadata(cookbook_version)
+        @metadata = Chef::Cookbook::Metadata.new(cookbook_version)
+        @metadata_filenames.each do |metadata_file|
+          case metadata_file
+          when /\.rb$/
+            apply_ruby_metadata(metadata_file)
+          when /\.json$/
+            apply_json_metadata(metadata_file)
+          else
+            raise RuntimeError, "Invalid metadata file: #{metadata_file} for cookbook: #{cookbook_version}"
+          end
+        end
+        @metadata
+      end
+
+      def empty?
+        cookbook_settings.inject(true) do |all_empty, files|
+          all_empty && files.last.empty?
+        end
+      end
+
+      def merge!(other_cookbook_loader)
+        other_cookbook_settings = other_cookbook_loader.cookbook_settings
+        @cookbook_settings.each do |file_type, file_list|
+          file_list.merge!(other_cookbook_settings[file_type])
+        end
+        @metadata_filenames.concat(other_cookbook_loader.metadata_filenames)
+      end
+
+      def chefignore
+        @chefignore ||= Chefignore.new(File.basename(@cookbook_path))
+      end
+
+      def load_root_files
+        Dir.glob(File.join(@cookbook_path, '*'), File::FNM_DOTMATCH).each do |file|
+          next if File.directory?(file)
+          @cookbook_settings[:root_filenames][file[@relative_path, 1]] = file
+        end
+      end
+
+      def load_recursively_as(category, category_dir, glob)
+        file_spec = File.join(@cookbook_path, category_dir, '**', glob)
+        Dir.glob(file_spec, File::FNM_DOTMATCH).each do |file|
+          next if File.directory?(file)
+          @cookbook_settings[category][file[@relative_path, 1]] = file
+        end
+      end
+
+      def load_as(category, *path_glob)
+        Dir[File.join(@cookbook_path, *path_glob)].each do |file|
+          @cookbook_settings[category][file[@relative_path, 1]] = file
+        end
+      end
+
+      def remove_ignored_files
+        @cookbook_settings.each_value do |file_list|
+          file_list.reject! do |relative_path, full_path|
+            chefignore.ignored?(relative_path)
+          end
+        end
+      end
+
+      def apply_ruby_metadata(file)
+        begin
+          @metadata.from_file(file)
+        rescue JSON::ParserError
+          Chef::Log.error("Error evaluating metadata.rb for #@cookbook_name in " + file)
+          raise
+        end
+      end
+
+      def apply_json_metadata(file)
+        begin
+          @metadata.from_json(IO.read(file))
+        rescue JSON::ParserError
+          Chef::Log.error("Couldn't parse cookbook metadata JSON for #@cookbook_name in " + file)
+          raise
+        end
+      end
+
+    end
+  end
+end