mbailey-chef 0.9.12.1

data/lib/chef/role.rb

@@ -0,0 +1,287 @@
+#
+# 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 'extlib'
+require 'json'
+
+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
+      @run_list = 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)
+      (args.length > 0) ? @run_list.reset!(args) : @run_list
+    end
+
+    alias_method :recipes, :run_list
+
+#     def recipes(*args)
+#       Chef::Log.warn "Chef::Role#recipes method is deprecated.  Please use Chef::Role#run_list"
+#       run_list(*args)
+#     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",
+        "run_list" => @run_list.run_list
+      }
+      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.run_list(if o.has_key?("run_list")
+                      o["run_list"]
+                    else
+                      o["recipes"]
+                    end)
+      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
+
+    # 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"
+        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
+      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

data/lib/chef/run_context.rb

@@ -0,0 +1,110 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008-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/resource_collection'
+require 'chef/node'
+require 'chef/role'
+require 'chef/log'
+require 'chef/mixin/language_include_recipe'
+
+class Chef
+  # == Chef::RunContext
+  # Value object that loads and tracks the context of a Chef run
+  class RunContext
+
+    # Used to load the node's recipes after expanding its run list
+    include Chef::Mixin::LanguageIncludeRecipe
+
+    attr_reader :node, :cookbook_collection, :definitions
+
+    # Needs to be settable so deploy can run a resource_collection independent
+    # of any cookbooks.
+    attr_accessor :resource_collection
+
+    # Creates a new Chef::RunContext 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::RunContext>:: Duh. :)
+    def initialize(node, cookbook_collection)
+      @node = node
+      @cookbook_collection = cookbook_collection
+      @resource_collection = Chef::ResourceCollection.new
+      @definitions = Hash.new
+      
+      # TODO: 5/18/2010 cw/timh - See note on Chef::Node's
+      # cookbook_collection attr_accessor
+      node.cookbook_collection = cookbook_collection
+
+      load
+    end
+
+    def load
+      foreach_cookbook_load_segment(:libraries) do |cookbook_name, filename|
+        Chef::Log.debug("Loading cookbook #{cookbook_name}'s library file: #{filename}")
+        require filename
+      end
+      
+      foreach_cookbook_load_segment(:providers) do |cookbook_name, filename|
+        Chef::Log.debug("Loading cookbook #{cookbook_name}'s providers from #{filename}")
+        Chef::Provider.build_from_file(cookbook_name, filename)
+      end
+      
+      foreach_cookbook_load_segment(:resources) do |cookbook_name, filename|
+        Chef::Log.debug("Loading cookbook #{cookbook_name}'s resources from #{filename}")
+        Chef::Resource.build_from_file(cookbook_name, filename)
+      end
+
+      node.load_attributes
+
+      foreach_cookbook_load_segment(:definitions) do |cookbook_name, filename|
+        Chef::Log.debug("Loading cookbook #{cookbook_name}'s definitions from #{filename}")
+        resourcelist = Chef::ResourceDefinitionList.new
+        resourcelist.from_file(filename)
+        definitions.merge!(resourcelist.defines) do |key, oldval, newval|
+          Chef::Log.info("Overriding duplicate definition #{key}, new found in #{filename}")
+          newval
+        end
+      end
+
+      # Retrieve the fully expanded list of recipes for the node by
+      # resolving roles; this step also merges attributes into the
+      # node from the roles/recipes included.
+      recipe_names = node.expand!
+
+      recipe_names.each do |recipe_name|
+        # TODO: timh/cw, 5-14-2010: It's distasteful to be including
+        # the DSL in a class outside the context of the DSL
+        include_recipe(recipe_name)
+      end
+    end
+
+    private
+    
+    def foreach_cookbook_load_segment(segment, &block)
+      cookbook_collection.each do |cookbook_name, cookbook|
+        segment_filenames = cookbook.segment_filenames(segment)
+        segment_filenames.each do |segment_filename|
+          block.call(cookbook_name, segment_filename)
+        end
+      end
+    end
+    
+  end
+end

data/lib/chef/run_list/run_list_expansion.rb

@@ -0,0 +1,172 @@
+#
+# Author:: Daniel DeLeo (<dan@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 'extlib'
+
+require 'chef/mixin/deep_merge'
+
+require 'chef/role'
+require 'chef/couchdb'
+require 'chef/rest'
+
+class Chef
+  class RunList
+    # Abstract Base class for expanding a run list. Subclasses must handle
+    # fetching roles from a data source by defining +fetch_role+
+    class RunListExpansion
+
+      attr_reader :run_list_items
+
+      attr_reader :recipes
+
+      attr_reader :default_attrs
+
+      attr_reader :override_attrs
+
+      attr_reader :errors
+
+      # The data source passed to the constructor. Not used in this class.
+      # In subclasses, this is a couchdb or Chef::REST object pre-configured
+      # to fetch roles from their correct location.
+      attr_reader :source
+
+      def initialize(run_list_items, source=nil)
+        @errors = Array.new
+
+        @run_list_items = run_list_items.dup
+        @source = source
+
+        @default_attrs = Mash.new
+        @override_attrs = Mash.new
+
+        @recipes = []
+
+        @applied_roles = {}
+      end
+
+      # Did we find any errors (expanding roles)?
+      def errors?
+        @errors.length > 0
+      end
+
+      alias :invalid? :errors?
+
+      # Iterates over the run list items, expanding roles. After this,
+      # +recipes+ will contain the fully expanded recipe list
+      def expand
+        @run_list_items.each_with_index do |entry, index|
+          case entry.type
+          when :recipe
+            recipes << entry.name unless recipes.include?(entry.name)
+          when :role
+            if role = inflate_role(entry.name)
+              apply_role_attributes(role)
+              @run_list_items.insert(index + 1, *role.run_list.run_list_items)
+            end
+          end
+        end
+      end
+
+      # Fetches and inflates a role
+      # === Returns
+      # Chef::Role  in most cases
+      # false       if the role has already been applied
+      # nil         if the role does not exist
+      def inflate_role(role_name)
+        return false if applied_role?(role_name) # Prevent infinite loops
+        applied_role(role_name)
+        fetch_role(role_name)
+      end
+
+      def apply_role_attributes(role)
+        @default_attrs = Chef::Mixin::DeepMerge.merge(@default_attrs, role.default_attributes)
+        @override_attrs = Chef::Mixin::DeepMerge.merge(@override_attrs, role.override_attributes)
+      end
+
+      def applied_role?(role_name)
+        @applied_roles.has_key?(role_name)
+      end
+
+      def applied_role(role_name)
+        @applied_roles[role_name] = true
+      end
+
+      def roles
+        @applied_roles.keys
+      end
+
+      # In subclasses, this method will fetch the role from the data source.
+      def fetch_role(name)
+        raise NotImplementedError
+      end
+
+      # When a role is not found, an error message is logged, but no
+      # exception is raised.  We do add an entry in the errors collection.
+      # === Returns
+      # nil
+      def role_not_found(name)
+        Chef::Log.error("Role #{name} is in the runlist but does not exist. Skipping expand.")
+        @errors << name
+        nil
+      end
+    end
+
+    # Expand a run list from disk. Suitable for chef-solo
+    class RunListExpansionFromDisk < RunListExpansion
+
+      def fetch_role(name)
+        Chef::Role.from_disk(name)
+      rescue Chef::Exceptions::RoleNotFound
+        role_not_found(name)
+      end
+
+    end
+
+    # Expand a run list from the chef-server API.
+    class RunListExpansionFromAPI < RunListExpansion
+
+      def rest
+        @rest ||= (source || Chef::REST.new(Chef::Config[:role_url]))
+      end
+
+      def fetch_role(name)
+        rest.get_rest("roles/#{name}")
+      rescue Net::HTTPServerException => e
+        if e.message == '404 "Not Found"'
+          role_not_found(name)
+        else
+          raise
+        end
+      end
+    end
+
+    # Expand a run list from couchdb. Used in chef-server-api
+    class RunListExpansionFromCouchDB < RunListExpansion
+
+      def couchdb
+        source
+      end
+
+      def fetch_role(name)
+        Chef::Role.cdb_load(name, couchdb)
+      rescue Chef::Exceptions::CouchDBNotFound
+        role_not_found(name)
+      end
+
+    end
+  end
+end