microwave 0.1006.33 → 1.0.0

data/lib/chef/run_list.rb

@@ -1,161 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Nuo Yan (<nuoyan@opscode.com>)
-# Author:: Tim Hinderliter (<tim@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Author:: Seth Falcon (<seth@opscode.com>)
-# Copyright:: Copyright (c) 2008-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/run_list/run_list_item'
-require 'chef/run_list/run_list_expansion'
-require 'chef/run_list/versioned_recipe_list'
-require 'chef/mixin/params_validate'
-
-class Chef
-  class RunList
-    include Enumerable
-    include Chef::Mixin::ParamsValidate
-
-    # @run_list_items is an array of RunListItems that describe the items to
-    # execute in order. RunListItems can load from and convert to the string
-    # forms users set on roles and nodes.
-    # For example:
-    #   @run_list_items = ['recipe[foo::bar]', 'role[webserver]']
-    # Thus,
-    #   self.role_names would return ['webserver']
-    #   self.recipe_names would return ['foo::bar']
-    attr_reader :run_list_items
-
-    # For backwards compat
-    alias :run_list :run_list_items
-
-    def initialize(*run_list_items)
-      @run_list_items = run_list_items.map { |i| coerce_to_run_list_item(i) }
-    end
-
-    def role_names
-      @run_list_items.inject([]){|memo, run_list_item| memo << run_list_item.name if run_list_item.role? ; memo}
-    end
-
-    alias :roles :role_names
-
-    def recipe_names
-      @run_list_items.inject([]){|memo, run_list_item| memo << run_list_item.name if run_list_item.recipe? ; memo}
-    end
-
-    alias :recipes :recipe_names
-
-    # Add an item of the form "recipe[foo::bar]" or "role[webserver]";
-    # takes a String or a RunListItem
-    def <<(run_list_item)
-      run_list_item = coerce_to_run_list_item(run_list_item)
-      @run_list_items << run_list_item unless @run_list_items.include?(run_list_item)
-      self
-    end
-
-    alias :push :<<
-
-    def ==(other)
-      if other.kind_of?(Chef::RunList)
-        other.run_list_items == @run_list_items
-      else
-        return false unless other.respond_to?(:size) && (other.size == @run_list_items.size)
-        other_run_list_items = other.dup
-
-        other_run_list_items.map! { |item| coerce_to_run_list_item(item) }
-        other_run_list_items == @run_list_items
-      end
-    end
-
-    def to_s
-      @run_list_items.join(", ")
-    end
-
-    def to_json(*args)
-      to_a.to_json(*args)
-    end
-
-    def empty?
-      @run_list_items.length == 0 ? true : false
-    end
-
-    def [](pos)
-      @run_list_items[pos]
-    end
-
-    def []=(pos, item)
-      @run_list_items[pos] = parse_entry(item)
-    end
-
-    def each(&block)
-      @run_list_items.each { |i| block.call(i) }
-    end
-
-    def each_index(&block)
-      @run_list_items.each_index { |i| block.call(i) }
-    end
-
-    def include?(item)
-      @run_list_items.include?(parse_entry(item))
-    end
-
-    def reset!(*args)
-      @run_list_items.clear
-      args.flatten.each do |item|
-        if item.kind_of?(Chef::RunList)
-          item.each { |r| self << r }
-        else
-          self << item
-        end
-      end
-      self
-    end
-
-    def remove(item)
-      @run_list_items.delete_if{|i| i == item}
-      self
-    end
-    alias :delete :remove
-
-    # Expands this run_list: recursively expand roles into their included
-    # recipes.
-    # Returns a RunListExpansion object.
-    def expand(environment, data_source='disk', expansion_opts={})
-      expansion = expansion_for_data_source(environment, data_source, expansion_opts)
-      expansion.expand
-      expansion
-    end
-
-    # Converts a string run list entry to a RunListItem object.
-    def parse_entry(entry)
-      RunListItem.new(entry)
-    end
-
-    def coerce_to_run_list_item(item)
-      item.kind_of?(RunListItem) ? item : parse_entry(item)
-    end
-
-    def expansion_for_data_source(environment, data_source, opts={})
-      case data_source.to_s
-      when 'disk'
-        RunListExpansionFromDisk.new(environment, @run_list_items)
-      end
-    end
-
-
-  end
-end
-

data/lib/chef/run_list/run_list_expansion.rb

@@ -1,159 +0,0 @@
-#
-# 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'
-
-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 :errors
-
-      attr_reader :environment
-
-      # 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(environment, run_list_items, source=nil)
-        @environment = environment
-        @errors = 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 = {}
-      end
-
-      # Did we find any errors (expanding roles)?
-      def errors?
-        @errors.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)
-        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
-
-      # 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)
-        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
-
-      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)
-        if entry = items.shift
-          case entry.type
-          when :recipe
-            recipes.add_recipe(entry.name, entry.version)
-          when :role
-            if role = inflate_role(entry.name)
-              expand_run_list_items(role.run_list_for(@environment).run_list_items)
-              apply_role_attributes(role)
-            end
-          end
-          expand_run_list_items(items)
-        end
-      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
-
-  end
-end

data/lib/chef/run_list/run_list_item.rb

@@ -1,92 +0,0 @@
-#
-# 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}))$}
-
-      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]
-          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

data/lib/chef/run_list/versioned_recipe_list.rb

@@ -1,68 +0,0 @@
-#
-# 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