chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/lib/chef/node.rb

@@ -21,19 +21,16 @@
 
 require 'forwardable'
 require 'chef/config'
-require 'chef/cookbook/cookbook_collection'
 require 'chef/nil_argument'
-require 'chef/mixin/check_helper'
 require 'chef/mixin/params_validate'
 require 'chef/mixin/from_file'
-require 'chef/mixin/language_include_attribute'
 require 'chef/mixin/deep_merge'
+require 'chef/dsl/include_attribute'
+require 'chef/dsl/platform_introspection'
 require 'chef/environment'
-require 'chef/couchdb'
 require 'chef/rest'
 require 'chef/run_list'
 require 'chef/node/attribute'
-require 'chef/index_queue'
 require 'chef/mash'
 require 'chef/json_compat'
 require 'chef/search/query'
@@ -43,144 +40,34 @@ class Chef
 
     extend Forwardable
 
-    def_delegators :construct_attributes, :keys, :each_key, :each_value, :key?, :has_key?
+    def_delegators :attributes, :keys, :each_key, :each_value, :key?, :has_key?
 
-    attr_accessor :recipe_list, :couchdb, :couchdb_rev, :run_state, :run_list
-    attr_accessor :override_attrs, :default_attrs, :normal_attrs, :automatic_attrs
-    attr_reader :couchdb_id
+    attr_accessor :recipe_list, :run_state, :run_list
 
-    # TODO: 5/18/2010 cw/timh. cookbook_collection should be removed
-    # from here and for any place it's needed, it should be accessed
-    # through a Chef::RunContext
-    attr_accessor :cookbook_collection
+    # RunContext will set itself as run_context via this setter when
+    # initialized. This is needed so DSL::IncludeAttribute (in particular,
+    # #include_recipe) can access the run_context to determine if an attributes
+    # file has been seen yet.
+    #--
+    # TODO: This is a pretty ugly way to solve that problem.
+    attr_accessor :run_context
 
-    include Chef::Mixin::CheckHelper
     include Chef::Mixin::FromFile
+    include Chef::DSL::IncludeAttribute
+    include Chef::DSL::PlatformIntrospection
+
     include Chef::Mixin::ParamsValidate
-    include Chef::Mixin::LanguageIncludeAttribute
-    include Chef::IndexQueue::Indexable
-
-    DESIGN_DOCUMENT = {
-      "version" => 11,
-      "language" => "javascript",
-      "views" => {
-        "all" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "node") {
-              emit(doc.name, doc);
-            }
-          }
-          EOJS
-        },
-        "all_id" => {
-          "map" => <<-EOJS
-          function(doc) {
-            if (doc.chef_type == "node") {
-              emit(doc.name, doc.name);
-            }
-          }
-          EOJS
-        },
-        "status" => {
-          "map" => <<-EOJS
-            function(doc) {
-              if (doc.chef_type == "node") {
-                var to_emit = { "name": doc.name, "chef_environment": doc.chef_environment };
-                if (doc["attributes"]["fqdn"]) {
-                  to_emit["fqdn"] = doc["attributes"]["fqdn"];
-                } else {
-                  to_emit["fqdn"] = "Undefined";
-                }
-                if (doc["attributes"]["ipaddress"]) {
-                  to_emit["ipaddress"] = doc["attributes"]["ipaddress"];
-                } else {
-                  to_emit["ipaddress"] = "Undefined";
-                }
-                if (doc["attributes"]["ohai_time"]) {
-                  to_emit["ohai_time"] = doc["attributes"]["ohai_time"];
-                } else {
-                  to_emit["ohai_time"] = "Undefined";
-                }
-                if (doc["attributes"]["uptime"]) {
-                  to_emit["uptime"] = doc["attributes"]["uptime"];
-                } else {
-                  to_emit["uptime"] = "Undefined";
-                }
-                if (doc["attributes"]["platform"]) {
-                  to_emit["platform"] = doc["attributes"]["platform"];
-                } else {
-                  to_emit["platform"] = "Undefined";
-                }
-                if (doc["attributes"]["platform_version"]) {
-                  to_emit["platform_version"] = doc["attributes"]["platform_version"];
-                } else {
-                  to_emit["platform_version"] = "Undefined";
-                }
-                if (doc["run_list"]) {
-                  to_emit["run_list"] = doc["run_list"];
-                } else {
-                  to_emit["run_list"] = "Undefined";
-                }
-                emit(doc.name, to_emit);
-              }
-            }
-          EOJS
-        },
-        "by_run_list" => {
-          "map" => <<-EOJS
-            function(doc) {
-              if (doc.chef_type == "node") {
-                if (doc['run_list']) {
-                  for (var i=0; i < doc.run_list.length; i++) {
-                    emit(doc['run_list'][i], doc.name);
-                  }
-                }
-              }
-            }
-          EOJS
-        },
-        "by_environment" => {
-          "map" => <<-EOJS
-            function(doc) {
-              if (doc.chef_type == "node") {
-                var env = (doc['chef_environment'] == null ? "_default" : doc['chef_environment']);
-                emit(env, doc.name);
-              }
-            }
-          EOJS
-        }
-      },
-    }
 
     # Create a new Chef::Node object.
-    def initialize(couchdb=nil)
+    def initialize
       @name = nil
 
       @chef_environment = '_default'
-      @normal_attrs = Mash.new
-      @override_attrs = Mash.new
-      @default_attrs = Mash.new
-      @automatic_attrs = Mash.new
       @run_list = Chef::RunList.new
 
-      @couchdb_rev = nil
-      @couchdb_id = nil
-      @couchdb = couchdb || Chef::CouchDB.new
-
-      @run_state = {
-        :template_cache => Hash.new,
-        :seen_recipes => Hash.new,
-        :seen_attributes => Hash.new
-      }
-      # TODO: 5/20/2010 need this here as long as other objects try to access
-      # the cookbook collection via Node, otherwise get NoMethodError on nil.
-      @cookbook_collection = CookbookCollection.new
-    end
+      @attributes = Chef::Node::Attribute.new({}, {}, {}, {})
 
-    def couchdb_id=(value)
-      @couchdb_id = value
-      @index_id = value
+      @run_state = {}
     end
 
     # Used by DSL
@@ -192,24 +79,6 @@ class Chef
       Chef::REST.new(Chef::Config[:chef_server_url])
     end
 
-    # Find a recipe for this Chef::Node by fqdn.  Will search first for
-    # Chef::Config["node_path"]/fqdn.rb, then hostname.rb, then default.rb.
-    #
-    # Returns a new Chef::Node object.
-    #
-    # Raises an ArgumentError if it cannot find the node.
-    def find_file(fqdn)
-      host_parts = fqdn.split(".")
-      hostname = host_parts[0]
-
-      [fqdn, hostname, "default"].each { |fname|
-       node_file = File.join(Chef::Config[:node_path], "#{fname.to_s}.rb")
-       return self.from_file(node_file) if File.exists?(node_file)
-     }
-
-      raise ArgumentError, "Cannot find a node matching #{fqdn}, not even with default.rb!"
-    end
-
     # Set the name of this Node, or return the current name.
     def name(arg=nil)
       if arg != nil
@@ -233,91 +102,114 @@ class Chef
       )
     end
 
-    # Used by the DSL
-    def attribute
-      construct_attributes
+    def chef_environment=(environment)
+      chef_environment(environment)
     end
 
-    def construct_attributes
-      Chef::Node::Attribute.new(normal_attrs, default_attrs, override_attrs, automatic_attrs)
-    end
+    alias :environment :chef_environment
 
-    def attribute=(value)
-      self.normal_attrs = value
+    def attributes
+      @attributes
     end
 
+    alias :attribute :attributes
+    alias :construct_attributes :attributes
+
     # Return an attribute of this node.  Returns nil if the attribute is not found.
     def [](attrib)
-      construct_attributes[attrib]
+      attributes[attrib]
     end
 
-    # Set an attribute of this node
-    def []=(attrib, value)
-      construct_attributes[attrib] = value
-    end
-
-    def store(attrib, value)
-      self[attrib] = value
-    end
-
-    # Set a normal attribute of this node, but auto-vivifiy any Mashes that
+    # Set a normal attribute of this node, but auto-vivify any Mashes that
     # might be missing
     def normal
-      attrs = construct_attributes
-      attrs.set_type = :normal
-      attrs.auto_vivifiy_on_read = true
-      attrs
+      attributes.set_unless_value_present = false
+      attributes.normal
     end
 
     alias_method :set, :normal
 
-    # Set a normal attribute of this node, auto-vivifiying any mashes that are
+    # Set a normal attribute of this node, auto-vivifying any mashes that are
     # missing, but if the final value already exists, don't set it
     def normal_unless
-      attrs = construct_attributes
-      attrs.set_type = :normal
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
+      attributes.set_unless_value_present = true
+      attributes.normal
     end
     alias_method :set_unless, :normal_unless
 
-    # Set a default of this node, but auto-vivifiy any Mashes that might
+    # Set a default of this node, but auto-vivify any Mashes that might
     # be missing
     def default
-      attrs = construct_attributes
-      attrs.set_type = :default
-      attrs.auto_vivifiy_on_read = true
-      attrs
+      attributes.set_unless_value_present = false
+      attributes.default
     end
 
-    # Set a default attribute of this node, auto-vivifiying any mashes that are
+    # Set a force default attribute. Intermediate mashes will be created by
+    # auto-vivify if necessary.
+    def default!
+      attributes.set_unless_value_present = false
+      attributes.default!
+    end
+
+    # Set a default attribute of this node, auto-vivifying any mashes that are
     # missing, but if the final value already exists, don't set it
     def default_unless
-      attrs = construct_attributes
-      attrs.set_type = :default
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
+      attributes.set_unless_value_present = true
+      attributes.default
     end
 
-    # Set an override attribute of this node, but auto-vivifiy any Mashes that
+    # Set an override attribute of this node, but auto-vivify any Mashes that
     # might be missing
     def override
-      attrs = construct_attributes
-      attrs.set_type = :override
-      attrs.auto_vivifiy_on_read = true
-      attrs
+      attributes.set_unless_value_present = false
+      attributes.override
+    end
+
+    # Set a force override attribute. Intermediate mashes will be created by
+    # auto-vivify if needed.
+    def override!
+      attributes.set_unless_value_present = false
+      attributes.override!
     end
 
-    # Set an override attribute of this node, auto-vivifiying any mashes that
+    # Set an override attribute of this node, auto-vivifying any mashes that
     # are missing, but if the final value already exists, don't set it
     def override_unless
-      attrs = construct_attributes
-      attrs.set_type = :override
-      attrs.auto_vivifiy_on_read = true
-      attrs.set_unless_value_present = true
-      attrs
+      attributes.set_unless_value_present = true
+      attributes.override
+    end
+
+
+    def override_attrs
+     attributes.override
+    end
+
+    def override_attrs=(new_values)
+      attributes.override = new_values
+    end
+
+    def default_attrs
+      attributes.default
+    end
+
+    def default_attrs=(new_values)
+      attributes.default = new_values
+    end
+
+    def normal_attrs
+      attributes.normal
+    end
+
+    def normal_attrs=(new_values)
+      attributes.normal = new_values
+    end
+
+    def automatic_attrs
+      attributes.automatic
+    end
+
+    def automatic_attrs=(new_values)
+      attributes.automatic = new_values
     end
 
     # Return true if this Node has a given attribute, false if not.  Takes either a symbol or
@@ -326,36 +218,33 @@ class Chef
     # Only works on the top level. Preferred way is to use the normal [] style
     # lookup and call attribute?()
     def attribute?(attrib)
-      construct_attributes.attribute?(attrib)
+      attributes.attribute?(attrib)
     end
 
     # Yield each key of the top level to the block.
     def each(&block)
-      construct_attributes.each(&block)
+      attributes.each(&block)
     end
 
     # Iterates over each attribute, passing the attribute and value to the block.
     def each_attribute(&block)
-      construct_attributes.each_attribute(&block)
+      attributes.each_attribute(&block)
     end
 
-    # Encouraged to only get used for lookups - while you can do sets from here, it's not as explicit
-    # as using the normal/default/override interface.
+    # Only works for attribute fetches, setting is no longer supported
     def method_missing(symbol, *args)
-      attrs = construct_attributes
-      attrs.send(symbol, *args)
+      attributes.send(symbol, *args)
     end
 
     # Returns true if this Node expects a given recipe, false if not.
     #
     # First, the run list is consulted to see whether the recipe is
     # explicitly included. If it's not there, it looks in
-    # run_state[:seen_recipes], which is populated by include_recipe
-    # statements in the DSL (and thus would not be in the run list).
+    # `node[:recipes]`, which is populated when the run_list is expanded
     #
     # NOTE: It's used by cookbook authors
     def recipe?(recipe_name)
-      run_list.include?(recipe_name) || run_state[:seen_recipes].include?(recipe_name)
+      run_list.include?(recipe_name) || Array(self[:recipes]).include?(recipe_name)
     end
 
     # Returns true if this Node expects a given role, false if not.
@@ -379,26 +268,26 @@ class Chef
       Chef::Log.debug("Extracting run list from JSON attributes provided on command line")
       consume_attributes(json_cli_attrs)
 
-      @automatic_attrs = ohai_data
+      self.automatic_attrs = ohai_data
 
       platform, version = Chef::Platform.find_platform_and_version(self)
       Chef::Log.debug("Platform is #{platform} version #{version}")
-      @automatic_attrs[:platform] = platform
-      @automatic_attrs[:platform_version] = version
+      self.automatic[:platform] = platform
+      self.automatic[:platform_version] = version
     end
 
     # Consumes the combined run_list and other attributes in +attrs+
     def consume_attributes(attrs)
       normal_attrs_to_merge = consume_run_list(attrs)
       Chef::Log.debug("Applying attributes from json file")
-      @normal_attrs = Chef::Mixin::DeepMerge.horizontal_merge(@normal_attrs,normal_attrs_to_merge)
+      self.normal_attrs = Chef::Mixin::DeepMerge.merge(normal_attrs,normal_attrs_to_merge)
       self.tags # make sure they're defined
     end
 
     # Lazy initializer for tags attribute
     def tags
-      self.set[:tags] = [] unless attribute?(:tags)
-      self[:tags]
+      normal[:tags] = [] unless attribute?(:tags)
+      normal[:tags]
     end
 
     # Extracts the run list from +attrs+ and applies it. Returns the remaining attributes
@@ -417,8 +306,8 @@ class Chef
     # Clear defaults and overrides, so that any deleted attributes
     # between runs are still gone.
     def reset_defaults_and_overrides
-      @default_attrs = Mash.new
-      @override_attrs = Mash.new
+      self.default.clear
+      self.override.clear
     end
 
     # Expands the node's run list and sets the default and override
@@ -439,8 +328,10 @@ class Chef
 
       self.tags # make sure they're defined
 
-      @automatic_attrs[:recipes] = expansion.recipes
-      @automatic_attrs[:roles] = expansion.roles
+      automatic_attrs[:recipes] = expansion.recipes
+      automatic_attrs[:roles] = expansion.roles
+
+      apply_expansion_attributes(expansion)
 
       expansion
     end
@@ -448,13 +339,17 @@ class Chef
     # Apply the default and overrides attributes from the expansion
     # passed in, which came from roles.
     def apply_expansion_attributes(expansion)
-      load_chef_environment_object = (chef_environment == "_default" ? nil : Chef::Environment.load(chef_environment))
-      environment_default_attrs = load_chef_environment_object.nil? ? {} : load_chef_environment_object.default_attributes
-      default_before_roles = Chef::Mixin::DeepMerge.horizontal_merge(default_attrs, environment_default_attrs)
-      @default_attrs = Chef::Mixin::DeepMerge.horizontal_merge(default_before_roles, expansion.default_attrs)
-      environment_override_attrs = load_chef_environment_object.nil? ? {} : load_chef_environment_object.override_attributes
-      overrides_before_environments = Chef::Mixin::DeepMerge.horizontal_merge(override_attrs, expansion.override_attrs)
-      @override_attrs = Chef::Mixin::DeepMerge.horizontal_merge(overrides_before_environments, environment_override_attrs)
+      loaded_environment = if chef_environment == "_default"
+                             Chef::Environment.new.tap {|e| e.name("_default")}
+                           else
+                             Chef::Environment.load(chef_environment)
+                           end
+
+      attributes.env_default = loaded_environment.default_attributes
+      attributes.env_override = loaded_environment.override_attributes
+
+      attribute.role_default = expansion.default_attrs
+      attributes.role_override = expansion.override_attrs
     end
 
     # Transform the node to a Hash
@@ -478,36 +373,39 @@ class Chef
       display["chef_environment"] = chef_environment
       display["automatic"]        = automatic_attrs
       display["normal"]           = normal_attrs
-      display["default"]          = default_attrs
-      display["override"]         = override_attrs
+      display["default"]          = attributes.combined_default
+      display["override"]         = attributes.combined_override
       display["run_list"]         = run_list.run_list
       display
     end
 
     # Serialize this object as a hash
     def to_json(*a)
+      for_json.to_json(*a)
+    end
+
+    def for_json
       result = {
         "name" => name,
         "chef_environment" => chef_environment,
         'json_class' => self.class.name,
-        "automatic" => automatic_attrs,
-        "normal" => normal_attrs,
+        "automatic" => attributes.automatic,
+        "normal" => attributes.normal,
         "chef_type" => "node",
-        "default" => default_attrs,
-        "override" => override_attrs,
+        "default" => attributes.combined_default,
+        "override" => attributes.combined_override,
         #Render correctly for run_list items so malformed json does not result
         "run_list" => run_list.run_list.map { |item| item.to_s }
       }
-      result["_rev"] = couchdb_rev if couchdb_rev
-      result.to_json(*a)
+      result
     end
 
     def update_from!(o)
       run_list.reset!(o.run_list)
-      @automatic_attrs = o.automatic_attrs
-      @normal_attrs = o.normal_attrs
-      @override_attrs = o.override_attrs
-      @default_attrs = o.default_attrs
+      self.automatic_attrs = o.automatic_attrs
+      self.normal_attrs = o.normal_attrs
+      self.override_attrs = o.override_attrs
+      self.default_attrs = o.default_attrs
       chef_environment(o.chef_environment)
       self
     end
@@ -530,17 +428,9 @@ class Chef
       else
         o["recipes"].each { |r| node.recipes << r }
       end
-      node.couchdb_rev = o["_rev"] if o.has_key?("_rev")
-      node.couchdb_id = o["_id"] if o.has_key?("_id")
-      node.index_id = node.couchdb_id
       node
     end
 
-    def self.cdb_list_by_environment(environment, inflate=false, couchdb=nil)
-      rs = (couchdb || Chef::CouchDB.new).get_view("nodes", "by_environment", :include_docs => inflate, :startkey => environment, :endkey => environment)
-      inflate ? rs["rows"].collect {|r| r["doc"]} : rs["rows"].collect {|r| r["value"]}
-    end
-
     def self.list_by_environment(environment, inflate=false)
       if inflate
         response = Hash.new
@@ -551,14 +441,6 @@ class Chef
       end
     end
 
-    # List all the Chef::Node objects in the CouchDB.  If inflate is set to true, you will get
-    # the full list of all Nodes, fully inflated.
-    def self.cdb_list(inflate=false, couchdb=nil)
-      rs =(couchdb || Chef::CouchDB.new).list("nodes", inflate)
-      lookup = (inflate ? "value" : "key")
-      rs["rows"].collect { |r| r[lookup] }
-    end
-
     def self.list(inflate=false)
       if inflate
         response = Hash.new
@@ -571,19 +453,6 @@ class Chef
       end
     end
 
-    # Load a node by name from CouchDB
-    def self.cdb_load(name, couchdb=nil)
-      (couchdb || Chef::CouchDB.new).load("node", name)
-    end
-
-    def self.exists?(nodename, couchdb)
-      begin
-        self.cdb_load(nodename, couchdb)
-      rescue Chef::Exceptions::CouchDBNotFound
-        nil
-      end
-    end
-
     def self.find_or_create(node_name)
       load(node_name)
     rescue Net::HTTPServerException => e
@@ -595,7 +464,7 @@ class Chef
     def self.build(node_name)
       node = new
       node.name(node_name)
-      node.chef_environment(Chef::Config[:environment]) unless Chef::Config[:environment].nil? || Chef::Config[:environment].chomp.empty?
+      node.chef_environment(Chef::Config[:environment]) unless Chef::Config[:environment].nil? || Chef::Config[:environment].chop.empty?
       node
     end
 
@@ -604,21 +473,11 @@ class Chef
       Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("nodes/#{name}")
     end
 
-    # Remove this node from the CouchDB
-    def cdb_destroy
-      couchdb.delete("node", name, couchdb_rev)
-    end
-
     # Remove this node via the REST API
     def destroy
       chef_server_rest.delete_rest("nodes/#{name}")
     end
 
-    # Save this node to the CouchDB
-    def cdb_save
-      @couchdb_rev = couchdb.store("node", name, self)["rev"]
-    end
-
     # Save this node via the REST API
     def save
       # Try PUT. If the node doesn't yet exist, PUT will return 404,
@@ -642,41 +501,13 @@ class Chef
       self
     end
 
-    # Set up our CouchDB design document
-    def self.create_design_document(couchdb=nil)
-      (couchdb || Chef::CouchDB.new).create_design_document("nodes", DESIGN_DOCUMENT)
-    end
-
     def to_s
       "node[#{name}]"
     end
 
-    # Load all attribute files for all cookbooks associated with this
-    # node.
-    def load_attributes
-      cookbook_collection.values.each do |cookbook|
-        cookbook.segment_filenames(:attributes).each do |segment_filename|
-          Chef::Log.debug("Node #{name} loading cookbook #{cookbook.name}'s attribute file #{segment_filename}")
-          self.from_file(segment_filename)
-        end
-      end
+    def <=>(other_node)
+      self.name <=> other_node.name
     end
 
-    # Used by DSL.
-    # Loads the attribute file specified by the short name of the
-    # file, e.g., loads specified cookbook's
-    #   "attributes/mailservers.rb"
-    # if passed
-    #   "mailservers"
-    def load_attribute_by_short_filename(name, src_cookbook_name)
-      src_cookbook = cookbook_collection[src_cookbook_name]
-      raise Chef::Exceptions::CookbookNotFound, "could not find cookbook #{src_cookbook_name} while loading attribute #{name}" unless src_cookbook
-
-      attribute_filename = src_cookbook.attribute_filenames_by_short_filename[name]
-      raise Chef::Exceptions::AttributeNotFound, "could not find filename for attribute #{name} in cookbook #{src_cookbook_name}" unless attribute_filename
-
-      self.from_file(attribute_filename)
-      self
-    end
   end
 end