giraffesoft-chef 0.7.15

data/lib/chef/compile.rb

@@ -0,0 +1,170 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@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/cookbook_loader'
+require 'chef/resource_collection'
+require 'chef/node'
+require 'chef/role'
+require 'chef/log'
+require 'chef/mixin/deep_merge'
+
+class Chef
+  class Compile
+      
+    attr_accessor :node, :cookbook_loader, :collection, :definitions
+    
+    # Creates a new Chef::Compile object and populates its fields. This object gets
+    # used by the Chef Server to generate a fully compiled recipe list for a node.
+    #
+    # === Returns
+    # object<Chef::Compile>:: Duh. :)
+    def initialize(node=nil)
+      @node = node 
+      @cookbook_loader = Chef::CookbookLoader.new
+      @collection = Chef::ResourceCollection.new
+      @definitions = Hash.new
+      @recipes = Array.new
+      @default_attributes = Array.new
+      @override_attributes = Array.new
+
+      load_libraries
+      load_providers
+      load_resources
+      load_attributes
+      load_definitions
+      load_recipes
+    end
+    
+    # Looks up the node via the "name" argument, first from CouchDB, then by calling
+    # Chef::Node.find_file(name)
+    #
+    # The first step in compiling the catalog. Results available via the node accessor.
+    #
+    # === Returns
+    # node<Chef::Node>:: The loaded Chef Node
+    def load_node(name)
+      Chef::Log.debug("Loading Chef Node #{name} from CouchDB")
+      @node = Chef::Node.load(name)
+      Chef::Log.debug("Loading Recipe for Chef Node #{name}")
+      @node.find_file(name)
+      @node
+    end
+    
+    # Load all the attributes, from every cookbook
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_attributes()
+      recipes, default_attrs, override_attrs = expand_node
+
+      @cookbook_loader.each do |cookbook|
+        cookbook.load_attributes(@node)
+      end
+
+      true
+    end
+    
+    # Load all the definitions, from every cookbook, so they are available when we process
+    # the recipes.
+    #
+    # Results available via the definitions accessor.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_definitions()
+      @cookbook_loader.each do |cookbook|
+        hash = cookbook.load_definitions
+        @definitions.merge!(hash)
+      end
+      true
+    end
+    
+    # Load all the libraries, from every cookbook, so they are available when we process
+    # the recipes.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_libraries()
+      @cookbook_loader.each do |cookbook|
+        cookbook.load_libraries
+      end
+      true
+    end
+
+    # Load all the providers, from every cookbook, so they are available when we process
+    # the recipes.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_providers()
+      @cookbook_loader.each do |cookbook|
+        cookbook.load_providers
+      end
+      true
+    end
+
+    # Load all the resources, from every cookbook, so they are available when we process
+    # the recipes.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_resources()
+      @cookbook_loader.each do |cookbook|
+        cookbook.load_resources
+      end
+      true
+    end
+    
+    # Load all the recipes specified in the node data (loaded via load_node, above.)
+    # 
+    # The results are available via the collection accessor (which returns a Chef::ResourceCollection 
+    # object)
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_recipes
+      expand_node
+      @recipes.each do |recipe|
+        if @node.run_state[:seen_recipes].has_key?(recipe)
+          Chef::Log.debug("I am not loading #{recipe}, because I have already seen it.")
+          next
+        end
+        Chef::Log.debug("Loading Recipe #{recipe}")
+        @node.run_state[:seen_recipes][recipe] = true
+
+        rmatch = recipe.match(/(.+?)::(.+)/)
+        if rmatch
+         cookbook = @cookbook_loader[rmatch[1]]
+         cookbook.load_recipe(rmatch[2], @node, @collection, @definitions, @cookbook_loader)
+        else
+         cookbook = @cookbook_loader[recipe]
+         cookbook.load_recipe("default", @node, @collection, @definitions, @cookbook_loader)
+        end
+      end
+      true
+    end
+
+    def expand_node
+      @recipes, @default_attributes, @override_attributes = @node.run_list.expand
+      @node.default = @default_attributes
+      @node.override = @override_attributes
+      return @recipes, @default_attributes, @override_attributes
+    end
+    
+  end
+end

data/lib/chef/config.rb

@@ -0,0 +1,141 @@
+#
+# 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 '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
+
+
+    # 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,
+          :openid_url,
+          :template_url,
+          :remotefile_url,
+          :search_url,
+          :role_url ].each do |u| 
+            c[u] = url
+        end
+      end
+      url
+    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
+      elsif location.respond_to? :to_str
+        File.new(location.to_str, "a")
+      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
+
+    authorized_openid_identifiers nil
+    authorized_openid_providers nil
+    chef_server_url nil
+    cookbook_path [ "/var/chef/site-cookbooks", "/var/chef/cookbooks" ]
+    couchdb_database "chef"
+    couchdb_url "http://localhost:5984"
+    couchdb_version nil
+    daemonize nil
+    delay 0
+    executable_path ENV['PATH'] ? ENV['PATH'].split(File::PATH_SEPARATOR) : []
+    file_cache_path "/var/chef/cache"
+    file_store_path "/var/chef/store"
+    group nil
+    http_retry_count 5
+    http_retry_delay 5
+    interval nil
+    json_attribs nil
+    log_level :info
+    log_location STDOUT
+    node_name nil
+    node_path "/var/chef/node"
+    openid_cstore_couchdb false
+    openid_cstore_path "/var/chef/openid/cstore"
+    openid_providers nil
+    openid_store_couchdb false
+    openid_store_path "/var/chef/openid/db"
+    openid_url "http://localhost:4001"
+    pid_file nil
+    queue_host "localhost"
+    queue_password ""
+    queue_port 61613
+    queue_retry_count 5
+    queue_retry_delay 5
+    queue_user ""
+    queue_prefix nil
+    registration_url "http://localhost:4000"
+    remotefile_url "http://localhost:4000"
+    rest_timeout 60
+    run_command_stderr_timeout 120
+    run_command_stdout_timeout 120
+    search_index_path "/var/chef/search_index"
+    search_url "http://localhost:4000"
+    solo  false
+    splay nil
+    ssl_client_cert ""
+    ssl_client_key ""
+    ssl_verify_mode :verify_none
+    template_url "http://localhost:4000"
+    user nil
+    validation_token nil
+    role_path "/var/chef/roles"
+    role_url "http://localhost:4000"
+    recipe_url nil
+  end
+end

data/lib/chef/cookbook.rb

@@ -0,0 +1,171 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@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 'chef/node'
+require 'chef/resource_definition'
+require 'chef/recipe'
+require 'chef/mixin/convert_to_class_name'
+
+class Chef
+  class Cookbook
+    include Chef::Mixin::ConvertToClassName
+    
+    attr_accessor :attribute_files, :definition_files, :template_files, :remote_files, 
+                  :lib_files, :resource_files, :provider_files, :name
+    attr_reader :recipe_files
+    
+    # Creates a new Chef::Cookbook object.  
+    #
+    # === Returns
+    # object<Chef::Cookbook>:: Duh. :)
+    def initialize(name)
+      @name = name
+      @attribute_files = Array.new
+      @definition_files = Array.new
+      @template_files = Array.new
+      @remote_files = Array.new
+      @recipe_files = Array.new
+      @recipe_names = Hash.new
+      @lib_files = Array.new
+      @resource_files = Array.new
+      @provider_files = Array.new
+    end
+    
+    # Loads all the library files in this cookbook via require.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_libraries
+      @lib_files.each do |file|
+        Chef::Log.debug("Loading cookbook #{name} library file: #{file}")
+        require file
+      end
+      true
+    end
+    
+    # Loads all the attribute files in this cookbook within a particular <Chef::Node>.
+    #
+    # === Parameters
+    # node<Chef::Node>:: The Chef::Node to apply the attributes to
+    #
+    # === Returns
+    # node<Chef::Node>:: The updated Chef::Node object
+    #
+    # === Raises
+    # <ArgumentError>:: If the argument is not a kind_of? <Chef::Node>
+    def load_attributes(node)
+      unless node.kind_of?(Chef::Node)
+        raise ArgumentError, "You must pass a Chef::Node to load_attributes!"
+      end
+      @attribute_files.each do |file|
+        Chef::Log.debug("Loading attributes from #{file}")
+        node.from_file(file)
+      end
+      node
+    end
+    
+    # Loads all the resource definitions in this cookbook.
+    #
+    # === Returns
+    # definitions<Hash>: A hash of <Chef::ResourceDefinition> objects, keyed by name.
+    def load_definitions
+      results = Hash.new
+      @definition_files.each do |file|
+        Chef::Log.debug("Loading cookbook #{name}'s definitions from #{file}")
+        resourcedef = Chef::ResourceDefinition.new
+        resourcedef.from_file(file)
+        results[resourcedef.name] = resourcedef
+      end
+      results
+    end
+
+    # Loads all the resources in this cookbook.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_resources
+      @resource_files.each do |file|
+        Chef::Log.debug("Loading cookbook #{name}'s resources from #{file}")
+        Chef::Resource.build_from_file(name, file)
+      end
+    end
+    
+    # Loads all the providers in this cookbook.
+    #
+    # === Returns
+    # true:: Always returns true
+    def load_providers
+      @provider_files.each do |file|
+        Chef::Log.debug("Loading cookbook #{name}'s providers from #{file}")
+        Chef::Provider.build_from_file(name, file)
+      end
+    end
+    
+    def recipe_files=(*args)
+      @recipe_files = args.flatten
+      @recipe_files.each_index do |i|
+        file = @recipe_files[i]
+        case file
+        when /(.+\/)(.+).rb$/
+          @recipe_names[$2] = i
+        when /(.+).rb$/
+          @recipe_names[$1] = i
+        else  
+          @recipe_names[file] = i
+        end
+      end
+      @recipe_files
+    end
+    
+    def recipe?(name)
+      lookup_name = name
+      if name =~ /(.+)::(.+)/
+        cookbook_name = $1
+        lookup_name = $2
+        return false unless cookbook_name == @name
+      end
+      @recipe_names.has_key?(lookup_name)
+    end
+    
+    def recipes
+      results = Array.new
+      @recipe_names.each_key do |rname|
+        results << "#{@name}::#{rname}"
+      end
+      results
+    end
+    
+    def load_recipe(name, node, collection=nil, definitions=nil, cookbook_loader=nil)
+      cookbook_name = @name
+      recipe_name = nil
+      nmatch = name.match(/^(.+?)::(.+)$/)
+      recipe_name = nmatch ? nmatch[2] : name
+      
+      unless @recipe_names.has_key?(recipe_name)
+        raise ArgumentError, "Cannot find a recipe matching #{recipe_name} in cookbook #{@name}"
+      end
+      Chef::Log.debug("Found recipe #{recipe_name} in cookbook #{cookbook_name}") if Chef::Log.debug?
+      recipe = Chef::Recipe.new(cookbook_name, recipe_name, node, 
+                                collection, definitions, cookbook_loader)
+      recipe.from_file(@recipe_files[@recipe_names[recipe_name]])
+      recipe
+    end
+    
+  end
+end