[OC-3564] move core Chef to the repo root \o/ \m/

The opscode/chef repository now only contains the core Chef library code
used by chef-client, knife and chef-solo!

3 files changed, 358 insertions, 0 deletions

diff --git a/lib/chef/run_list/run_list_expansion.rb b/lib/chef/run_list/run_list_expansion.rb
new file mode 100644
index 0000000000..7b8108a2d4
--- /dev/null
+++ b/lib/chef/run_list/run_list_expansion.rb
@@ -0,0 +1,191 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2010, 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.
+
+require 'chef/mash'
+
+require 'chef/mixin/deep_merge'
+
+require 'chef/role'
+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
+
+      # A VersionedRecipeList of recipes. Populated only after #expand
+      # is called.
+      attr_reader :recipes
+
+      attr_reader :default_attrs
+
+      attr_reader :override_attrs
+
+      attr_reader :environment
+
+      attr_reader :missing_roles_with_including_role
+
+      # 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
+
+      # Returns a Hash of the form "including_role" => "included_role_or_recipe".
+      # This can be used to show the expanded run list (ordered) graph.
+      # ==== Caveats
+      # * Duplicate roles are not shown.
+      attr_reader :run_list_trace
+
+      def initialize(environment, run_list_items, source=nil)
+        @environment = environment
+        @missing_roles_with_including_role = Array.new
+
+        @run_list_items = run_list_items.dup
+        @source = source
+
+        @default_attrs = Mash.new
+        @override_attrs = Mash.new
+
+        @recipes = Chef::RunList::VersionedRecipeList.new
+
+        @applied_roles = {}
+        @run_list_trace = Hash.new {|h, key| h[key] = [] }
+      end
+
+      # Did we find any errors (expanding roles)?
+      def errors?
+        @missing_roles_with_including_role.length > 0
+      end
+
+      alias :invalid? :errors?
+
+      # Recurses over the run list items, expanding roles. After this,
+      # +recipes+ will contain the fully expanded recipe list
+      def expand
+        # Sure do miss function arity when being recursive
+        expand_run_list_items(@run_list_items)
+      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, included_by)
+        return false if applied_role?(role_name) # Prevent infinite loops
+        applied_role(role_name)
+        fetch_role(role_name, included_by)
+      end
+
+      def apply_role_attributes(role)
+        @default_attrs = Chef::Mixin::DeepMerge.role_merge(@default_attrs, role.default_attributes)
+        @override_attrs = Chef::Mixin::DeepMerge.role_merge(@override_attrs, role.override_attributes)
+      end
+
+      def applied_role?(role_name)
+        @applied_roles.has_key?(role_name)
+      end
+
+      # Returns an array of role names that were expanded; this
+      # includes any roles that were in the original, pre-expansion
+      # run_list as well as roles processed during
+      # expansion. Populated only after #expand is called.
+      def roles
+        @applied_roles.keys
+      end
+
+      # In subclasses, this method will fetch the role from the data source.
+      def fetch_role(name, included_by)
+        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, included_by)
+        Chef::Log.error("Role #{name} (included by '#{included_by}') is in the runlist but does not exist. Skipping expand.")
+        @missing_roles_with_including_role << [name, included_by]
+        nil
+      end
+
+      def errors
+        @missing_roles_with_including_role.map {|item| item.first }
+      end
+
+      private
+
+      # these methods modifies internal state based on arguments, so hide it.
+
+      def applied_role(role_name)
+        @applied_roles[role_name] = true
+      end
+
+      def expand_run_list_items(items, included_by="top level")
+        if entry = items.shift
+          @run_list_trace[included_by.to_s] << entry.to_s
+
+          case entry.type
+          when :recipe
+            recipes.add_recipe(entry.name, entry.version)
+          when :role
+            if role = inflate_role(entry.name, included_by)
+              expand_run_list_items(role.run_list_for(@environment).run_list_items, role)
+              apply_role_attributes(role)
+            end
+          end
+          expand_run_list_items(items, included_by)
+        end
+      end
+
+    end
+
+    # Expand a run list from disk. Suitable for chef-solo
+    class RunListExpansionFromDisk < RunListExpansion
+
+      def fetch_role(name, included_by)
+        Chef::Role.from_disk(name)
+      rescue Chef::Exceptions::RoleNotFound
+        role_not_found(name, included_by)
+      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, included_by)
+        rest.get_rest("roles/#{name}")
+      rescue Net::HTTPServerException => e
+        if e.message == '404 "Not Found"'
+          role_not_found(name, included_by)
+        else
+          raise
+        end
+      end
+    end
+
+  end
+end
diff --git a/lib/chef/run_list/run_list_item.rb b/lib/chef/run_list/run_list_item.rb
new file mode 100644
index 0000000000..43bb239754
--- /dev/null
+++ b/lib/chef/run_list/run_list_item.rb
@@ -0,0 +1,99 @@
+#
+# 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.
+
+class Chef
+  class RunList
+    class RunListItem
+      QUALIFIED_RECIPE             = %r{^recipe\[([^\]@]+)(@([0-9]+(\.[0-9]+){1,2}))?\]$}
+      QUALIFIED_ROLE               = %r{^role\[([^\]]+)\]$}
+      VERSIONED_UNQUALIFIED_RECIPE = %r{^([^@]+)(@([0-9]+(\.[0-9]+){1,2}))$}
+      FALSE_FRIEND                 = %r{[\[\]]}
+
+      attr_reader :name, :type, :version
+
+
+      def initialize(item)
+        @version = nil
+        case item
+        when Hash
+          assert_hash_is_valid_run_list_item!(item)
+          @type = (item['type'] || item[:type]).to_sym
+          @name = item['name'] || item[:name]
+          if (item.has_key?('version') || item.has_key?(:version))
+            @version = item['version'] || item[:version]
+          end
+        when String
+          if match = QUALIFIED_RECIPE.match(item)
+            # recipe[recipe_name]
+            # recipe[recipe_name@1.0.0]
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
+          elsif match = QUALIFIED_ROLE.match(item)
+            # role[role_name]
+            @type = :role
+            @name = match[1]
+          elsif match = VERSIONED_UNQUALIFIED_RECIPE.match(item)
+            # recipe_name@1.0.0
+            @type = :recipe
+            @name = match[1]
+            @version = match[3] if match[3]
+          elsif match = FALSE_FRIEND.match(item)
+            # Recipe[recipe_name]
+            # roles[role_name]
+            name = match[1]
+            raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be recipe[#{name}] or role[#{name}]"
+
+          else
+            # recipe_name
+            @type = :recipe
+            @name = item
+          end
+        else
+          raise ArgumentError, "Unable to create #{self.class} from #{item.class}:#{item.inspect}: must be a Hash or String"
+        end
+      end
+
+      def to_s
+        "#{@type}[#{@name}#{@version ? "@#{@version}" :""}]"
+      end
+
+      def role?
+        @type == :role
+      end
+
+      def recipe?
+        @type == :recipe
+      end
+
+      def ==(other)
+        if other.kind_of?(String)
+          self.to_s == other.to_s
+        else
+          other.respond_to?(:type) && other.respond_to?(:name) && other.respond_to?(:version) && other.type == @type && other.name == @name && other.version == @version
+        end
+      end
+
+      def assert_hash_is_valid_run_list_item!(item)
+        unless (item.key?('type')|| item.key?(:type)) && (item.key?('name') || item.key?(:name))
+          raise ArgumentError, "Initializing a #{self.class} from a hash requires that it have a 'type' and 'name' key"
+        end
+      end
+
+    end
+  end
+end
diff --git a/lib/chef/run_list/versioned_recipe_list.rb b/lib/chef/run_list/versioned_recipe_list.rb
new file mode 100644
index 0000000000..0eefded964
--- /dev/null
+++ b/lib/chef/run_list/versioned_recipe_list.rb
@@ -0,0 +1,68 @@
+#
+# Author:: Stephen Delano (<stephen@opscode.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright 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/version_class'
+require 'chef/version_constraint'
+
+# Why does this class exist?
+# Why did we not just modify RunList/RunListItem?
+class Chef
+  class RunList
+    class VersionedRecipeList < Array
+
+      def initialize
+        super
+        @versions = Hash.new
+      end
+
+      def add_recipe(name, version=nil)
+        if version && @versions.has_key?(name)
+          unless Chef::Version.new(@versions[name]) == Chef::Version.new(version)
+            raise Chef::Exceptions::CookbookVersionConflict, "Run list requires #{name} at versions #{@versions[name]} and #{version}"
+          end
+        end
+        @versions[name] = version if version
+        self << name unless self.include?(name)
+      end
+
+      def with_versions
+        self.map {|recipe_name| {:name => recipe_name, :version => @versions[recipe_name]}}
+      end
+
+      # Return an Array of Hashes, each of the form:
+      #  {:name => RECIPE_NAME, :version_constraint => Chef::VersionConstraint }
+      def with_version_constraints
+        self.map do |recipe_name|
+          constraint = Chef::VersionConstraint.new(@versions[recipe_name])
+          { :name => recipe_name, :version_constraint => constraint }
+        end
+      end
+
+      # Return an Array of Strings, each of the form:
+      #  "NAME@VERSION"
+      def with_version_constraints_strings
+        self.map do |recipe_name|
+          if @versions[recipe_name]
+            "#{recipe_name}@#{@versions[recipe_name]}"
+          else
+            recipe_name
+          end
+        end
+      end
+    end
+  end
+end