From cb0c4eebb0a7b2fadc5e0487e1c692007cb8b2e5 Mon Sep 17 00:00:00 2001 From: Luke Kanies Date: Tue, 11 Dec 2007 15:35:36 -0600 Subject: Renaming 'configuration' to 'catalog', fixing #954. --- bin/puppet | 10 +- bin/ralsh | 6 +- ext/module_puppet | 6 +- ext/puppet-test | 4 +- lib/puppet/dsl.rb | 4 +- lib/puppet/indirector/catalog/compiler.rb | 173 ++++++ lib/puppet/indirector/catalog/yaml.rb | 24 + lib/puppet/indirector/configuration/compiler.rb | 173 ------ lib/puppet/indirector/configuration/yaml.rb | 24 - lib/puppet/metatype/evaluation.rb | 2 +- lib/puppet/metatype/instances.rb | 6 +- lib/puppet/metatype/metaparams.rb | 10 +- lib/puppet/network/client/master.rb | 76 +-- lib/puppet/network/handler/resource.rb | 8 +- lib/puppet/node/catalog.rb | 480 +++++++++++++++ lib/puppet/node/configuration.rb | 480 --------------- lib/puppet/parser/ast/hostclass.rb | 2 +- lib/puppet/parser/compile.rb | 40 +- lib/puppet/parser/functions.rb | 2 +- lib/puppet/parser/interpreter.rb | 2 +- lib/puppet/resource_reference.rb | 6 +- lib/puppet/transaction.rb | 26 +- lib/puppet/transportable.rb | 14 +- lib/puppet/type.rb | 16 +- lib/puppet/type/component.rb | 2 +- lib/puppet/type/pfile.rb | 10 +- lib/puppet/util/settings.rb | 6 +- spec/unit/indirector/catalog/compiler.rb | 209 +++++++ spec/unit/indirector/catalog/yaml.rb | 25 + spec/unit/indirector/configuration/compiler.rb | 209 ------- spec/unit/indirector/configuration/yaml.rb | 25 - spec/unit/network/client/master.rb | 76 +-- spec/unit/network/http/mongrel.rb | 4 +- spec/unit/network/http/webrick.rb | 4 +- spec/unit/node/catalog.rb | 783 ++++++++++++++++++++++++ spec/unit/node/configuration.rb | 783 ------------------------ spec/unit/other/transaction.rb | 2 +- spec/unit/other/transbucket.rb | 18 +- spec/unit/parser/compile.rb | 22 +- spec/unit/parser/interpreter.rb | 6 +- spec/unit/ral/type.rb | 14 +- spec/unit/ral/types/package.rb | 32 +- spec/unit/resource_reference.rb | 10 +- spec/unit/util/settings.rb | 2 +- test/language/ast/hostclass.rb | 2 +- test/language/compile.rb | 6 +- test/language/functions.rb | 14 +- test/language/snippets.rb | 14 +- test/lib/puppettest/parsertesting.rb | 2 +- test/lib/puppettest/support/assertions.rb | 4 +- test/lib/puppettest/support/resources.rb | 4 +- test/lib/puppettest/support/utils.rb | 14 +- test/network/client/client.rb | 6 +- test/network/client/master.rb | 6 +- test/other/events.rb | 8 +- test/other/overrides.rb | 2 +- test/other/relationships.rb | 2 +- test/other/report.rb | 2 +- test/other/transactions.rb | 54 +- test/ral/manager/instances.rb | 4 +- test/ral/manager/type.rb | 30 +- test/ral/types/basic.rb | 2 +- test/ral/types/cron.rb | 4 +- test/ral/types/exec.rb | 10 +- test/ral/types/file.rb | 24 +- test/ral/types/file/target.rb | 4 +- test/ral/types/fileignoresource.rb | 6 +- test/ral/types/filesources.rb | 10 +- test/ral/types/group.rb | 4 +- test/ral/types/host.rb | 4 +- test/ral/types/parameter.rb | 6 +- test/ral/types/sshkey.rb | 4 +- test/ral/types/tidy.rb | 2 +- test/ral/types/user.rb | 18 +- 74 files changed, 2054 insertions(+), 2054 deletions(-) create mode 100644 lib/puppet/indirector/catalog/compiler.rb create mode 100644 lib/puppet/indirector/catalog/yaml.rb delete mode 100644 lib/puppet/indirector/configuration/compiler.rb delete mode 100644 lib/puppet/indirector/configuration/yaml.rb create mode 100644 lib/puppet/node/catalog.rb delete mode 100644 lib/puppet/node/configuration.rb create mode 100755 spec/unit/indirector/catalog/compiler.rb create mode 100755 spec/unit/indirector/catalog/yaml.rb delete mode 100755 spec/unit/indirector/configuration/compiler.rb delete mode 100755 spec/unit/indirector/configuration/yaml.rb create mode 100755 spec/unit/node/catalog.rb delete mode 100755 spec/unit/node/configuration.rb diff --git a/bin/puppet b/bin/puppet index 409c23259..13e99e2a6 100755 --- a/bin/puppet +++ b/bin/puppet @@ -195,14 +195,14 @@ if options[:loadclasses] end begin - # Compile our configuration - config = Puppet::Node::Configuration.find(node) + # Compile our catalog + catalog = Puppet::Node::Catalog.find(node) - # Translate it to a RAL configuration - config = config.to_ral + # Translate it to a RAL catalog + catalog = catalog.to_ral # And apply it - config.apply + catalog.apply rescue => detail if Puppet[:trace] puts detail.backtrace diff --git a/bin/ralsh b/bin/ralsh index 58c96c930..e43177d35 100755 --- a/bin/ralsh +++ b/bin/ralsh @@ -228,10 +228,10 @@ else params.each do |param, value| obj[param] = value end - config = Puppet::Node::Configuration.new - config.add_resource obj + catalog = Puppet::Node::Catalog.new + catalog.add_resource obj begin - config.apply + catalog.apply rescue => detail if Puppet[:trace] puts detail.backtrace diff --git a/ext/module_puppet b/ext/module_puppet index 08fc9beb2..6a3f33fe6 100755 --- a/ext/module_puppet +++ b/ext/module_puppet @@ -179,7 +179,7 @@ node.classes = classes begin # Compile our configuration - config = Puppet::Node::Configuration.find(node) + catalog = Puppet::Node::Catalog.find(node) rescue => detail if Puppet[:trace] puts detail.backtrace @@ -198,10 +198,10 @@ end begin # Translate it to a RAL configuration - config = config.to_ral + catalog = catalog.to_ral # And apply it - config.apply + catalog.apply rescue => detail Puppet.err detail exit(1) diff --git a/ext/puppet-test b/ext/puppet-test index b89156caa..362a43996 100755 --- a/ext/puppet-test +++ b/ext/puppet-test @@ -200,7 +200,7 @@ class Suite end end -Suite.new :configuration, "Configuration handling" do +Suite.new :catalog, "Catalog handling" do def prepare $args[:cache] = false # Create a config client and pull the config down @@ -227,7 +227,7 @@ Suite.new :configuration, "Configuration handling" do @facts = YAML.dump(@facts) end - newtest :compile, "Compiled configuration" do + newtest :compile, "Compiled catalog" do @client.driver.getconfig(@facts, "yaml") end diff --git a/lib/puppet/dsl.rb b/lib/puppet/dsl.rb index c1b86e06d..4fbce556c 100644 --- a/lib/puppet/dsl.rb +++ b/lib/puppet/dsl.rb @@ -67,8 +67,8 @@ module Puppet def apply bucket = export() - configuration = bucket.to_configuration - configuration.apply + catalog = bucket.to_catalog + catalog.apply end def export diff --git a/lib/puppet/indirector/catalog/compiler.rb b/lib/puppet/indirector/catalog/compiler.rb new file mode 100644 index 000000000..6d769b97d --- /dev/null +++ b/lib/puppet/indirector/catalog/compiler.rb @@ -0,0 +1,173 @@ +require 'puppet/node' +require 'puppet/node/catalog' +require 'puppet/indirector/code' +require 'puppet/parser/interpreter' +require 'yaml' + +class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code + desc "Puppet's catalog compilation interface, and its back-end is + Puppet's compiler" + + include Puppet::Util + + attr_accessor :code + + # Compile a node's catalog. + def find(key, client = nil, clientip = nil) + if key.is_a?(Puppet::Node) + node = key + else + node = find_node(key) + end + + if catalog = compile(node) + return catalog.to_transportable + else + # This shouldn't actually happen; we should either return + # a config or raise an exception. + return nil + end + end + + def initialize + set_server_facts + end + + # Create/return our interpreter. + def interpreter + unless defined?(@interpreter) and @interpreter + @interpreter = create_interpreter + end + @interpreter + end + + # Is our compiler part of a network, or are we just local? + def networked? + $0 =~ /puppetmasterd/ + end + + # Return the catalog version. Here we're returning the + # latest of the node, fact, or parse date. These are the + # three things that go into compiling a client catalog, + # so changes in any of them result in changes. + # LAK:FIXME Note that this only works when all three sources + # use timestamps; once one of them moves to using real versions, + # the comparison stops working. + def version(key) + if node = Puppet::Node.find_by_any_name(key) + return [Puppet::Node.version(key).to_f, Puppet::Node::Facts.version(key).to_f, interpreter.catalog_version(node).to_f].sort[-1] + else + # This is the standard for "got nothing for ya". + 0 + end + end + + private + + # Add any extra data necessary to the node. + def add_node_data(node) + # Merge in our server-side facts, so they can be used during compilation. + node.merge(@server_facts) + end + + # Compile the actual catalog. + def compile(node) + # Ask the interpreter to compile the catalog. + str = "Compiled catalog for %s" % node.name + if node.environment + str += " in environment %s" % node.environment + end + config = nil + + loglevel = networked? ? :notice : :none + + benchmark(loglevel, "Compiled catalog for %s" % node.name) do + begin + config = interpreter.compile(node) + rescue Puppet::Error => detail + Puppet.err(detail.to_s) if networked? + raise + end + end + + return config + end + + # Create our interpreter object. + def create_interpreter + return Puppet::Parser::Interpreter.new + end + + # Turn our host name into a node object. + def find_node(key) + # If we want to use the cert name as our key + # LAK:FIXME This needs to be figured out somehow, but it requires the routing. + #if Puppet[:node_name] == 'cert' and client + # key = client + #end + + # Note that this is reasonable, because either their node source should actually + # know about the node, or they should be using the ``null`` node source, which + # will always return data. + unless node = Puppet::Node.find_by_any_name(key) + raise Puppet::Error, "Could not find node '%s'" % key + end + + # Add any external data to the node. + add_node_data(node) + + node + end + + # Initialize our server fact hash; we add these to each client, and they + # won't change while we're running, so it's safe to cache the values. + def set_server_facts + @server_facts = {} + + # Add our server version to the fact list + @server_facts["serverversion"] = Puppet.version.to_s + + # And then add the server name and IP + {"servername" => "fqdn", + "serverip" => "ipaddress" + }.each do |var, fact| + if value = Facter.value(fact) + @server_facts[var] = value + else + Puppet.warning "Could not retrieve fact %s" % fact + end + end + + if @server_facts["servername"].nil? + host = Facter.value(:hostname) + if domain = Facter.value(:domain) + @server_facts["servername"] = [host, domain].join(".") + else + @server_facts["servername"] = host + end + end + end + + # Translate our catalog appropriately for sending back to a client. + # LAK:FIXME This method should probably be part of the protocol, but it + # shouldn't be here. + def translate(config) + unless networked? + config + else + CGI.escape(config.to_yaml(:UseBlock => true)) + end + end + + # Mark that the node has checked in. LAK:FIXME this needs to be moved into + # the Node class, or somewhere that's got abstract backends. + def update_node_check(node) + if Puppet.features.rails? and Puppet[:storeconfigs] + Puppet::Rails.connect + + host = Puppet::Rails::Host.find_or_create_by_name(node.name) + host.last_freshcheck = Time.now + host.save + end + end +end diff --git a/lib/puppet/indirector/catalog/yaml.rb b/lib/puppet/indirector/catalog/yaml.rb new file mode 100644 index 000000000..00241d852 --- /dev/null +++ b/lib/puppet/indirector/catalog/yaml.rb @@ -0,0 +1,24 @@ +require 'puppet/node/catalog' +require 'puppet/indirector/yaml' + +class Puppet::Node::Catalog::Yaml < Puppet::Indirector::Yaml + desc "Store catalogs as flat files, serialized using YAML." + + private + + # Override these, because yaml doesn't want to convert our self-referential + # objects. This is hackish, but eh. + def from_yaml(text) + if config = YAML.load(text) + # We can't yaml-dump classes. + #config.edgelist_class = Puppet::Relationship + return config + end + end + + def to_yaml(config) + # We can't yaml-dump classes. + #config.edgelist_class = nil + YAML.dump(config) + end +end diff --git a/lib/puppet/indirector/configuration/compiler.rb b/lib/puppet/indirector/configuration/compiler.rb deleted file mode 100644 index a0726a433..000000000 --- a/lib/puppet/indirector/configuration/compiler.rb +++ /dev/null @@ -1,173 +0,0 @@ -require 'puppet/node' -require 'puppet/node/configuration' -require 'puppet/indirector/code' -require 'puppet/parser/interpreter' -require 'yaml' - -class Puppet::Node::Configuration::Compiler < Puppet::Indirector::Code - desc "Puppet's configuration compilation interface, and its back-end is - Puppet's compiler" - - include Puppet::Util - - attr_accessor :code - - # Compile a node's configuration. - def find(key, client = nil, clientip = nil) - if key.is_a?(Puppet::Node) - node = key - else - node = find_node(key) - end - - if configuration = compile(node) - return configuration.to_transportable - else - # This shouldn't actually happen; we should either return - # a config or raise an exception. - return nil - end - end - - def initialize - set_server_facts - end - - # Create/return our interpreter. - def interpreter - unless defined?(@interpreter) and @interpreter - @interpreter = create_interpreter - end - @interpreter - end - - # Is our compiler part of a network, or are we just local? - def networked? - $0 =~ /puppetmasterd/ - end - - # Return the configuration version. Here we're returning the - # latest of the node, fact, or parse date. These are the - # three things that go into compiling a client configuration, - # so changes in any of them result in changes. - # LAK:FIXME Note that this only works when all three sources - # use timestamps; once one of them moves to using real versions, - # the comparison stops working. - def version(key) - if node = Puppet::Node.find_by_any_name(key) - return [Puppet::Node.version(key).to_f, Puppet::Node::Facts.version(key).to_f, interpreter.configuration_version(node).to_f].sort[-1] - else - # This is the standard for "got nothing for ya". - 0 - end - end - - private - - # Add any extra data necessary to the node. - def add_node_data(node) - # Merge in our server-side facts, so they can be used during compilation. - node.merge(@server_facts) - end - - # Compile the actual configuration. - def compile(node) - # Ask the interpreter to compile the configuration. - str = "Compiled configuration for %s" % node.name - if node.environment - str += " in environment %s" % node.environment - end - config = nil - - loglevel = networked? ? :notice : :none - - benchmark(loglevel, "Compiled configuration for %s" % node.name) do - begin - config = interpreter.compile(node) - rescue Puppet::Error => detail - Puppet.err(detail.to_s) if networked? - raise - end - end - - return config - end - - # Create our interpreter object. - def create_interpreter - return Puppet::Parser::Interpreter.new - end - - # Turn our host name into a node object. - def find_node(key) - # If we want to use the cert name as our key - # LAK:FIXME This needs to be figured out somehow, but it requires the routing. - #if Puppet[:node_name] == 'cert' and client - # key = client - #end - - # Note that this is reasonable, because either their node source should actually - # know about the node, or they should be using the ``null`` node source, which - # will always return data. - unless node = Puppet::Node.find_by_any_name(key) - raise Puppet::Error, "Could not find node '%s'" % key - end - - # Add any external data to the node. - add_node_data(node) - - node - end - - # Initialize our server fact hash; we add these to each client, and they - # won't change while we're running, so it's safe to cache the values. - def set_server_facts - @server_facts = {} - - # Add our server version to the fact list - @server_facts["serverversion"] = Puppet.version.to_s - - # And then add the server name and IP - {"servername" => "fqdn", - "serverip" => "ipaddress" - }.each do |var, fact| - if value = Facter.value(fact) - @server_facts[var] = value - else - Puppet.warning "Could not retrieve fact %s" % fact - end - end - - if @server_facts["servername"].nil? - host = Facter.value(:hostname) - if domain = Facter.value(:domain) - @server_facts["servername"] = [host, domain].join(".") - else - @server_facts["servername"] = host - end - end - end - - # Translate our configuration appropriately for sending back to a client. - # LAK:FIXME This method should probably be part of the protocol, but it - # shouldn't be here. - def translate(config) - unless networked? - config - else - CGI.escape(config.to_yaml(:UseBlock => true)) - end - end - - # Mark that the node has checked in. LAK:FIXME this needs to be moved into - # the Node class, or somewhere that's got abstract backends. - def update_node_check(node) - if Puppet.features.rails? and Puppet[:storeconfigs] - Puppet::Rails.connect - - host = Puppet::Rails::Host.find_or_create_by_name(node.name) - host.last_freshcheck = Time.now - host.save - end - end -end diff --git a/lib/puppet/indirector/configuration/yaml.rb b/lib/puppet/indirector/configuration/yaml.rb deleted file mode 100644 index 1330aaffa..000000000 --- a/lib/puppet/indirector/configuration/yaml.rb +++ /dev/null @@ -1,24 +0,0 @@ -require 'puppet/node/configuration' -require 'puppet/indirector/yaml' - -class Puppet::Node::Configuration::Yaml < Puppet::Indirector::Yaml - desc "Store configurations as flat files, serialized using YAML." - - private - - # Override these, because yaml doesn't want to convert our self-referential - # objects. This is hackish, but eh. - def from_yaml(text) - if config = YAML.load(text) - # We can't yaml-dump classes. - #config.edgelist_class = Puppet::Relationship - return config - end - end - - def to_yaml(config) - # We can't yaml-dump classes. - #config.edgelist_class = nil - YAML.dump(config) - end -end diff --git a/lib/puppet/metatype/evaluation.rb b/lib/puppet/metatype/evaluation.rb index 0451d50a7..b3b6570b2 100644 --- a/lib/puppet/metatype/evaluation.rb +++ b/lib/puppet/metatype/evaluation.rb @@ -32,7 +32,7 @@ class Puppet::Type # If we're in noop mode, we don't want to store the checked time, # because it will result in the resource not getting scheduled if - # someone were to run the configuration in non-noop mode. + # someone were to apply the catalog in non-noop mode. # We're going to go ahead and record that we checked if there were # no changes, since it's unlikely it will affect the scheduling. noop = noop? diff --git a/lib/puppet/metatype/instances.rb b/lib/puppet/metatype/instances.rb index f6773f0b3..3f44413f8 100644 --- a/lib/puppet/metatype/instances.rb +++ b/lib/puppet/metatype/instances.rb @@ -221,8 +221,8 @@ class Puppet::Type hash.delete :name end - if configuration = hash[:configuration] - hash.delete(:configuration) + if catalog = hash[:catalog] + hash.delete(:catalog) end raise(Puppet::Error, "You must specify a title for objects of type %s" % self.to_s) unless title @@ -236,7 +236,7 @@ class Puppet::Type # okay, now make a transobject out of hash begin trans = Puppet::TransObject.new(title, self.name.to_s) - trans.configuration = configuration if configuration + trans.catalog = catalog if catalog hash.each { |param, value| trans[param] = value } diff --git a/lib/puppet/metatype/metaparams.rb b/lib/puppet/metatype/metaparams.rb index 349a2c1bb..b35adae66 100644 --- a/lib/puppet/metatype/metaparams.rb +++ b/lib/puppet/metatype/metaparams.rb @@ -195,12 +195,12 @@ class Puppet::Type aliases = [aliases] end - raise(ArgumentError, "Cannot add aliases without a configuration") unless @resource.configuration + raise(ArgumentError, "Cannot add aliases without a catalog") unless @resource.catalog @resource.info "Adding aliases %s" % aliases.collect { |a| a.inspect }.join(", ") aliases.each do |other| - if obj = @resource.configuration.resource(@resource.class.name, other) + if obj = @resource.catalog.resource(@resource.class.name, other) unless obj.object_id == @resource.object_id self.fail("%s can not create alias %s: object already exists" % [@resource.title, other]) end @@ -210,8 +210,8 @@ class Puppet::Type # LAK:FIXME Old-school, add the alias to the class. @resource.class.alias(other, @resource) - # Newschool, add it to the configuration. - @resource.configuration.alias(@resource, other) + # Newschool, add it to the catalog. + @resource.catalog.alias(@resource, other) end end end @@ -256,7 +256,7 @@ class Puppet::Type def validate_relationship @value.each do |value| - unless @resource.configuration.resource(*value) + unless @resource.catalog.resource(*value) description = self.class.direction == :in ? "dependency" : "dependent" raise Puppet::Error, "Could not find #{description} %s[%s]" % [value[0].to_s.capitalize, value[1]] end diff --git a/lib/puppet/network/client/master.rb b/lib/puppet/network/client/master.rb index 740f01378..54b1dcaa4 100644 --- a/lib/puppet/network/client/master.rb +++ b/lib/puppet/network/client/master.rb @@ -7,7 +7,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client @@sync = Sync.new end - attr_accessor :configuration + attr_accessor :catalog attr_reader :compile_time class << self @@ -51,7 +51,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client # Cache the config def cache(text) - Puppet.info "Caching configuration at %s" % self.cachefile + Puppet.info "Caching catalog at %s" % self.cachefile confdir = ::File.dirname(Puppet[:localconfig]) ::File.open(self.cachefile + ".tmp", "w", 0660) { |f| f.print text @@ -67,10 +67,10 @@ class Puppet::Network::Client::Master < Puppet::Network::Client end def clear - @configuration.clear(true) if @configuration + @catalog.clear(true) if @catalog Puppet::Type.allclear mkdefault_objects - @configuration = nil + @catalog = nil end # Initialize and load storage @@ -93,7 +93,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client end end - # Check whether our configuration is up to date + # Check whether our catalog is up to date def fresh?(facts) if Puppet[:ignorecache] Puppet.notice "Ignoring cache" @@ -124,7 +124,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client lockfile.unlock(:anonymous => true) end - # Stop the daemon from making any configuration runs. + # Stop the daemon from making any catalog runs. def disable lockfile.lock(:anonymous => true) end @@ -144,15 +144,15 @@ class Puppet::Network::Client::Master < Puppet::Network::Client # Retrieve the plugins. getplugins() if Puppet[:pluginsync] - if (self.configuration or FileTest.exist?(self.cachefile)) and self.fresh?(facts) + if (self.catalog or FileTest.exist?(self.cachefile)) and self.fresh?(facts) Puppet.info "Configuration is up to date" return if use_cached_config end - Puppet.debug("Retrieving configuration") + Puppet.debug("Retrieving catalog") - # If we can't retrieve the configuration, just return, which will either - # fail, or use the in-memory configuration. + # If we can't retrieve the catalog, just return, which will either + # fail, or use the in-memory catalog. unless yaml_objects = get_actual_config(facts) use_cached_config(true) return @@ -162,7 +162,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client objects = YAML.load(yaml_objects) rescue => detail msg = "Configuration could not be translated from yaml" - msg += "; using cached configuration" if use_cached_config(true) + msg += "; using cached catalog" if use_cached_config(true) Puppet.warning msg return end @@ -170,26 +170,26 @@ class Puppet::Network::Client::Master < Puppet::Network::Client self.setclasses(objects.classes) # Clear all existing objects, so we can recreate our stack. - clear() if self.configuration + clear() if self.catalog - # Now convert the objects to a puppet configuration graph. + # Now convert the objects to a puppet catalog graph. begin - @configuration = objects.to_configuration + @catalog = objects.to_catalog rescue => detail clear() puts detail.backtrace if Puppet[:trace] msg = "Configuration could not be instantiated: %s" % detail - msg += "; using cached configuration" if use_cached_config(true) + msg += "; using cached catalog" if use_cached_config(true) Puppet.warning msg return end - if ! @configuration.from_cache + if ! @catalog.from_cache self.cache(yaml_objects) end # Keep the state database up to date. - @configuration.host_config = true + @catalog.host_config = true end # A simple proxy method, so it's easy to test. @@ -243,15 +243,15 @@ class Puppet::Network::Client::Master < Puppet::Network::Client end end - # The code that actually runs the configuration. - # This just passes any options on to the configuration, + # The code that actually runs the catalog. + # This just passes any options on to the catalog, # which accepts :tags and :ignoreschedules. def run(options = {}) got_lock = false splay Puppet::Util.sync(:puppetrun).synchronize(Sync::EX) do if !lockfile.lock - Puppet.notice "Lock file %s exists; skipping configuration run" % + Puppet.notice "Lock file %s exists; skipping catalog run" % lockfile.lockfile else got_lock = true @@ -261,14 +261,14 @@ class Puppet::Network::Client::Master < Puppet::Network::Client end rescue => detail puts detail.backtrace if Puppet[:trace] - Puppet.err "Could not retrieve configuration: %s" % detail + Puppet.err "Could not retrieve catalog: %s" % detail end - if self.configuration - @configuration.retrieval_duration = duration - Puppet.notice "Starting configuration run" unless @local - benchmark(:notice, "Finished configuration run") do - @configuration.apply(options) + if self.catalog + @catalog.retrieval_duration = duration + Puppet.notice "Starting catalog run" unless @local + benchmark(:notice, "Finished catalog run") do + @catalog.apply(options) end end end @@ -330,7 +330,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client if args[:ignore] hash[:ignore] = args[:ignore].split(/\s+/) end - downconfig = Puppet::Node::Configuration.new("downloading") + downconfig = Puppet::Node::Catalog.new("downloading") downconfig.add_resource Puppet::Type.type(:file).create(hash) Puppet.info "Retrieving #{args[:name]}s" @@ -489,7 +489,7 @@ class Puppet::Network::Client::Master < Puppet::Network::Client end end - # Actually retrieve the configuration, either from the server or from a + # Actually retrieve the catalog, either from the server or from a # local master. def get_actual_config(facts) begin @@ -508,18 +508,18 @@ class Puppet::Network::Client::Master < Puppet::Network::Client textfacts = CGI.escape(YAML.dump(facts)) - benchmark(:debug, "Retrieved configuration") do + benchmark(:debug, "Retrieved catalog") do # error handling for this is done in the network client begin textobjects = @driver.getconfig(textfacts, "yaml") begin textobjects = CGI.unescape(textobjects) rescue => detail - raise Puppet::Error, "Could not CGI.unescape configuration" + raise Puppet::Error, "Could not CGI.unescape catalog" end rescue => detail - Puppet.err "Could not retrieve configuration: %s" % detail + Puppet.err "Could not retrieve catalog: %s" % detail return nil end end @@ -562,23 +562,23 @@ class Puppet::Network::Client::Master < Puppet::Network::Client # Use our cached config, optionally specifying whether this is # necessary because of a failure. def use_cached_config(because_of_failure = false) - return true if self.configuration + return true if self.catalog if because_of_failure and ! Puppet[:usecacheonfailure] - @configuration = nil - Puppet.warning "Not using cache on failed configuration" + @catalog = nil + Puppet.warning "Not using cache on failed catalog" return false end return false unless oldtext = self.retrievecache begin - @configuration = YAML.load(oldtext).to_configuration - @configuration.from_cache = true - @configuration.host_config = true + @catalog = YAML.load(oldtext).to_catalog + @catalog.from_cache = true + @catalog.host_config = true rescue => detail puts detail.backtrace if Puppet[:trace] - Puppet.warning "Could not load cached configuration: %s" % detail + Puppet.warning "Could not load cached catalog: %s" % detail clear return false end diff --git a/lib/puppet/network/handler/resource.rb b/lib/puppet/network/handler/resource.rb index 0fcd694fb..f2a339751 100755 --- a/lib/puppet/network/handler/resource.rb +++ b/lib/puppet/network/handler/resource.rb @@ -39,14 +39,14 @@ class Puppet::Network::Handler end end - config = bucket.to_configuration + catalog = bucket.to_catalog - # And then apply the configuration. This way we're reusing all + # And then apply the catalog. This way we're reusing all # the code in there. It should probably just be separated out, though. - transaction = config.apply + transaction = catalog.apply # And then clean up - config.clear(true) + catalog.clear(true) # It'd be nice to return some kind of report, but... at this point # we have no such facility. diff --git a/lib/puppet/node/catalog.rb b/lib/puppet/node/catalog.rb new file mode 100644 index 000000000..a02d59ae9 --- /dev/null +++ b/lib/puppet/node/catalog.rb @@ -0,0 +1,480 @@ +require 'puppet/indirector' +require 'puppet/external/gratr/digraph' + +# This class models a node catalog. It is the thing +# meant to be passed from server to client, and it contains all +# of the information in the catalog, including the resources +# and the relationships between them. +class Puppet::Node::Catalog < Puppet::PGraph + extend Puppet::Indirector + indirects :catalog, :terminus_class => :compiler + + # The host name this is a catalog for. + attr_accessor :name + + # The catalog version. Used for testing whether a catalog + # is up to date. + attr_accessor :version + + # How long this catalog took to retrieve. Used for reporting stats. + attr_accessor :retrieval_duration + + # How we should extract the catalog for sending to the client. + attr_reader :extraction_format + + # We need the ability to set this externally, so we can yaml-dump the + # catalog. + attr_accessor :edgelist_class + + # Whether this is a host catalog, which behaves very differently. + # In particular, reports are sent, graphs are made, and state is + # stored in the state database. If this is set incorrectly, then you often + # end up in infinite loops, because catalogs are used to make things + # that the host catalog needs. + attr_accessor :host_config + + # Whether this graph is another catalog's relationship graph. + # We don't want to accidentally create a relationship graph for another + # relationship graph. + attr_accessor :is_relationship_graph + + # Whether this catalog was retrieved from the cache, which affects + # whether it is written back out again. + attr_accessor :from_cache + + # Add classes to our class list. + def add_class(*classes) + classes.each do |klass| + @classes << klass + end + + # Add the class names as tags, too. + tag(*classes) + end + + # Add one or more resources to our graph and to our resource table. + def add_resource(*resources) + resources.each do |resource| + unless resource.respond_to?(:ref) + raise ArgumentError, "Can only add objects that respond to :ref" + end + + ref = resource.ref + if @resource_table.include?(ref) + raise ArgumentError, "Resource %s is already defined" % ref + else + @resource_table[ref] = resource + end + resource.catalog = self unless is_relationship_graph + add_vertex!(resource) + end + end + + # Create an alias for a resource. + def alias(resource, name) + resource.ref =~ /^(.+)\[/ + + newref = "%s[%s]" % [$1 || resource.class.name, name] + raise(ArgumentError, "Cannot alias %s to %s; resource %s already exists" % [resource.ref, name, newref]) if @resource_table[newref] + @resource_table[newref] = resource + @aliases[resource.ref] << newref + end + + # Apply our catalog to the local host. Valid options + # are: + # :tags - set the tags that restrict what resources run + # during the transaction + # :ignoreschedules - tell the transaction to ignore schedules + # when determining the resources to run + def apply(options = {}) + @applying = true + + Puppet::Util::Storage.load if host_config? + transaction = Puppet::Transaction.new(self) + + transaction.tags = options[:tags] if options[:tags] + transaction.ignoreschedules = true if options[:ignoreschedules] + + transaction.addtimes :config_retrieval => @retrieval_duration + + + begin + transaction.evaluate + rescue Puppet::Error => detail + Puppet.err "Could not apply complete catalog: %s" % detail + rescue => detail + puts detail.backtrace if Puppet[:trace] + Puppet.err "Got an uncaught exception of type %s: %s" % [detail.class, detail] + ensure + # Don't try to store state unless we're a host config + # too recursive. + Puppet::Util::Storage.store if host_config? + end + + yield transaction if block_given? + + transaction.send_report if host_config and (Puppet[:report] or Puppet[:summarize]) + + return transaction + ensure + @applying = false + cleanup() + transaction.cleanup if defined? transaction and transaction + end + + # Are we in the middle of applying the catalog? + def applying? + @applying + end + + def clear(remove_resources = true) + super() + # We have to do this so that the resources clean themselves up. + @resource_table.values.each { |resource| resource.remove } if remove_resources + @resource_table.clear + + if defined?(@relationship_graph) and @relationship_graph + @relationship_graph.clear(false) + @relationship_graph = nil + end + end + + def classes + @classes.dup + end + + # Create an implicit resource, meaning that it will lose out + # to any explicitly defined resources. This method often returns + # nil. + # The quirk of this method is that it's not possible to create + # an implicit resource before an explicit resource of the same name, + # because all explicit resources are created before any generate() + # methods are called on the individual resources. Thus, this + # method can safely just check if an explicit resource already exists + # and toss this implicit resource if so. + def create_implicit_resource(type, options) + unless options.include?(:implicit) + options[:implicit] = true + end + + # This will return nil if an equivalent explicit resource already exists. + # When resource classes no longer retain references to resource instances, + # this will need to be modified to catch that conflict and discard + # implicit resources. + if resource = create_resource(type, options) + resource.implicit = true + + return resource + else + return nil + end + end + + # Create a new resource and register it in the catalog. + def create_resource(type, options) + unless klass = Puppet::Type.type(type) + raise ArgumentError, "Unknown resource type %s" % type + end + return unless resource = klass.create(options) + + @transient_resources << resource if applying? + add_resource(resource) + if @relationship_graph + @relationship_graph.add_resource(resource) unless @relationship_graph.resource(resource.ref) + end + resource + end + + # Make sure we support the requested extraction format. + def extraction_format=(value) + unless respond_to?("extract_to_%s" % value) + raise ArgumentError, "Invalid extraction format %s" % value + end + @extraction_format = value + end + + # Turn our catalog graph into whatever the client is expecting. + def extract + send("extract_to_%s" % extraction_format) + end + + # Create the traditional TransBuckets and TransObjects from our catalog + # graph. This will hopefully be deprecated soon. + def extract_to_transportable + top = nil + current = nil + buckets = {} + + unless main = vertices.find { |res| res.type == "Class" and res.title == :main } + raise Puppet::DevError, "Could not find 'main' class; cannot generate catalog" + end + + # Create a proc for examining edges, which we'll use to build our tree + # of TransBuckets and TransObjects. + bucket = nil + edges = proc do |edge| + # The sources are always non-builtins. + source, target = edge.source, edge.target + unless tmp = buckets[source.to_s] + if tmp = buckets[source.to_s] = source.to_trans + bucket = tmp + else + # This is because virtual resources return nil. If a virtual + # container resource contains realized resources, we still need to get + # to them. So, we keep a reference to the last valid bucket + # we returned and use that if the container resource is virtual. + end + end + bucket = tmp || bucket + if child = target.to_trans + unless bucket + raise "No bucket created for %s" % source + end + bucket.push child + + # It's important that we keep a reference to any TransBuckets we've created, so + # we don't create multiple buckets for children. + unless target.builtin? + buckets[target.to_s] = child + end + end + end + dfs(:start => main, :examine_edge => edges) + + unless main + raise Puppet::DevError, "Could not find 'main' class; cannot generate catalog" + end + + # Retrieve the bucket for the top-level scope and set the appropriate metadata. + unless result = buckets[main.to_s] + # This only happens when the catalog is entirely empty. + result = buckets[main.to_s] = main.to_trans + end + + result.classes = classes + + # Clear the cache to encourage the GC + buckets.clear + return result + end + + # Make sure all of our resources are "finished". + def finalize + @resource_table.values.each { |resource| resource.finish } + + write_graph(:resources) + end + + def host_config? + host_config || false + end + + def initialize(name = nil) + super() + @name = name if name + @extraction_format ||= :transportable + @tags = [] + @classes = [] + @resource_table = {} + @transient_resources = [] + @applying = false + @relationship_graph = nil + + @aliases = Hash.new { |hash, key| hash[key] = [] } + + if block_given? + yield(self) + finalize() + end + end + + # Create a graph of all of the relationships in our catalog. + def relationship_graph + raise(Puppet::DevError, "Tried get a relationship graph for a relationship graph") if self.is_relationship_graph + + unless defined? @relationship_graph and @relationship_graph + # It's important that we assign the graph immediately, because + # the debug messages below use the relationships in the + # relationship graph to determine the path to the resources + # spitting out the messages. If this is not set, + # then we get into an infinite loop. + @relationship_graph = Puppet::Node::Catalog.new + @relationship_graph.host_config = host_config? + @relationship_graph.is_relationship_graph = true + + # First create the dependency graph + self.vertices.each do |vertex| + @relationship_graph.add_vertex! vertex + vertex.builddepends.each do |edge| + @relationship_graph.add_edge!(edge) + end + end + + # Lastly, add in any autorequires + @relationship_graph.vertices.each do |vertex| + vertex.autorequire.each do |edge| + unless @relationship_graph.edge?(edge.source, edge.target) # don't let automatic relationships conflict with manual ones. + unless @relationship_graph.edge?(edge.target, edge.source) + vertex.debug "Autorequiring %s" % [edge.source] + @relationship_graph.add_edge!(edge) + else + vertex.debug "Skipping automatic relationship with %s" % (edge.source == vertex ? edge.target : edge.source) + end + end + end + end + + @relationship_graph.write_graph(:relationships) + + # Then splice in the container information + @relationship_graph.splice!(self, Puppet::Type::Component) + + @relationship_graph.write_graph(:expanded_relationships) + end + @relationship_graph + end + + # Remove the resource from our catalog. Notice that we also call + # 'remove' on the resource, at least until resource classes no longer maintain + # references to the resource instances. + def remove_resource(*resources) + resources.each do |resource| + @resource_table.delete(resource.ref) + @aliases[resource.ref].each { |res_alias| @resource_table.delete(res_alias) } + @aliases[resource.ref].clear + remove_vertex!(resource) if vertex?(resource) + @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource) + resource.remove + end + end + + # Look a resource up by its reference (e.g., File[/etc/passwd]). + def resource(type, title = nil) + # Always create a resource reference, so that it always canonizes how we + # are referring to them. + if title + ref = Puppet::ResourceReference.new(type, title).to_s + else + # If they didn't provide a title, then we expect the first + # argument to be of the form 'Class[name]', which our + # Reference class canonizes for us. + ref = Puppet::ResourceReference.new(nil, type).to_s + end + if resource = @resource_table[ref] + return resource + elsif defined?(@relationship_graph) and @relationship_graph + @relationship_graph.resource(ref) + end + end + + # Add a tag. + def tag(*names) + names.each do |name| + name = name.to_s + @tags << name unless @tags.include?(name) + if name.include?("::") + name.split("::").each do |sub| + @tags << sub unless @tags.include?(sub) + end + end + end + nil + end + + # Return the list of tags. + def tags + @tags.dup + end + + # Convert our catalog into a RAL catalog. + def to_ral + to_catalog :to_type + end + + # Turn our parser catalog into a transportable catalog. + def to_transportable + to_catalog :to_transobject + end + + # Produce the graph files if requested. + def write_graph(name) + # We only want to graph the main host catalog. + return unless host_config? + + return unless Puppet[:graph] + + Puppet.settings.use(:graphing) + + file = File.join(Puppet[:graphdir], "%s.dot" % name.to_s) + File.open(file, "w") { |f| + f.puts to_dot("name" => name.to_s.capitalize) + } + end + + # LAK:NOTE We cannot yaml-dump the class in the edgelist_class, because classes cannot be + # dumped by default, nor does yaml-dumping # the edge-labels work at this point (I don't + # know why). + # Neither of these matters right now, but I suppose it could at some point. + # We also have to have the vertex_dict dumped after the resource table, because yaml can't + # seem to handle the output of yaml-dumping the vertex_dict. + def to_yaml_properties + props = instance_variables.reject { |v| %w{@edgelist_class @edge_labels @vertex_dict}.include?(v) } + props << "@vertex_dict" + props + end + + private + + def cleanup + unless @transient_resources.empty? + remove_resource(*@transient_resources) + @transient_resources.clear + @relationship_graph = nil + end + end + + # An abstracted method for converting one catalog into another type of catalog. + # This pretty much just converts all of the resources from one class to another, using + # a conversion method. + def to_catalog(convert) + result = self.class.new(self.name) + + map = {} + vertices.each do |resource| + next if resource.respond_to?(:virtual?) and resource.virtual? + + newres = resource.send(convert) + + # We can't guarantee that resources don't munge their names + # (like files do with trailing slashes), so we have to keep track + # of what a resource got converted to. + map[resource.ref] = newres + + result.add_resource newres + end + + message = convert.to_s.gsub "_", " " + edges.each do |edge| + # Skip edges between virtual resources. + next if edge.source.respond_to?(:virtual?) and edge.source.virtual? + next if edge.target.respond_to?(:virtual?) and edge.target.virtual? + + unless source = map[edge.source.ref] + raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.source.ref, message] + end + + unless target = map[edge.target.ref] + raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.target.ref, message] + end + + result.add_edge!(source, target, edge.label) + end + + map.clear + + result.add_class *self.classes + result.tag(*self.tags) + + return result + end +end diff --git a/lib/puppet/node/configuration.rb b/lib/puppet/node/configuration.rb deleted file mode 100644 index 5da539e5c..000000000 --- a/lib/puppet/node/configuration.rb +++ /dev/null @@ -1,480 +0,0 @@ -require 'puppet/indirector' -require 'puppet/external/gratr/digraph' - -# This class models a node configuration. It is the thing -# meant to be passed from server to client, and it contains all -# of the information in the configuration, including the resources -# and the relationships between them. -class Puppet::Node::Configuration < Puppet::PGraph - extend Puppet::Indirector - indirects :configuration, :terminus_class => :compiler - - # The host name this is a configuration for. - attr_accessor :name - - # The configuration version. Used for testing whether a configuration - # is up to date. - attr_accessor :version - - # How long this configuration took to retrieve. Used for reporting stats. - attr_accessor :retrieval_duration - - # How we should extract the configuration for sending to the client. - attr_reader :extraction_format - - # We need the ability to set this externally, so we can yaml-dump the - # configuration. - attr_accessor :edgelist_class - - # Whether this is a host configuration, which behaves very differently. - # In particular, reports are sent, graphs are made, and state is - # stored in the state database. If this is set incorrectly, then you often - # end up in infinite loops, because configurations are used to make things - # that the host configuration needs. - attr_accessor :host_config - - # Whether this graph is another configuration's relationship graph. - # We don't want to accidentally create a relationship graph for another - # relationship graph. - attr_accessor :is_relationship_graph - - # Whether this configuration was retrieved from the cache, which affects - # whether it is written back out again. - attr_accessor :from_cache - - # Add classes to our class list. - def add_class(*classes) - classes.each do |klass| - @classes << klass - end - - # Add the class names as tags, too. - tag(*classes) - end - - # Add one or more resources to our graph and to our resource table. - def add_resource(*resources) - resources.each do |resource| - unless resource.respond_to?(:ref) - raise ArgumentError, "Can only add objects that respond to :ref" - end - - ref = resource.ref - if @resource_table.include?(ref) - raise ArgumentError, "Resource %s is already defined" % ref - else - @resource_table[ref] = resource - end - resource.configuration = self unless is_relationship_graph - add_vertex!(resource) - end - end - - # Create an alias for a resource. - def alias(resource, name) - resource.ref =~ /^(.+)\[/ - - newref = "%s[%s]" % [$1 || resource.class.name, name] - raise(ArgumentError, "Cannot alias %s to %s; resource %s already exists" % [resource.ref, name, newref]) if @resource_table[newref] - @resource_table[newref] = resource - @aliases[resource.ref] << newref - end - - # Apply our configuration to the local host. Valid options - # are: - # :tags - set the tags that restrict what resources run - # during the transaction - # :ignoreschedules - tell the transaction to ignore schedules - # when determining the resources to run - def apply(options = {}) - @applying = true - - Puppet::Util::Storage.load if host_config? - transaction = Puppet::Transaction.new(self) - - transaction.tags = options[:tags] if options[:tags] - transaction.ignoreschedules = true if options[:ignoreschedules] - - transaction.addtimes :config_retrieval => @retrieval_duration - - - begin - transaction.evaluate - rescue Puppet::Error => detail - Puppet.err "Could not apply complete configuration: %s" % detail - rescue => detail - puts detail.backtrace if Puppet[:trace] - Puppet.err "Got an uncaught exception of type %s: %s" % [detail.class, detail] - ensure - # Don't try to store state unless we're a host config - # too recursive. - Puppet::Util::Storage.store if host_config? - end - - yield transaction if block_given? - - transaction.send_report if host_config and (Puppet[:report] or Puppet[:summarize]) - - return transaction - ensure - @applying = false - cleanup() - transaction.cleanup if defined? transaction and transaction - end - - # Are we in the middle of applying the configuration? - def applying? - @applying - end - - def clear(remove_resources = true) - super() - # We have to do this so that the resources clean themselves up. - @resource_table.values.each { |resource| resource.remove } if remove_resources - @resource_table.clear - - if defined?(@relationship_graph) and @relationship_graph - @relationship_graph.clear(false) - @relationship_graph = nil - end - end - - def classes - @classes.dup - end - - # Create an implicit resource, meaning that it will lose out - # to any explicitly defined resources. This method often returns - # nil. - # The quirk of this method is that it's not possible to create - # an implicit resource before an explicit resource of the same name, - # because all explicit resources are created before any generate() - # methods are called on the individual resources. Thus, this - # method can safely just check if an explicit resource already exists - # and toss this implicit resource if so. - def create_implicit_resource(type, options) - unless options.include?(:implicit) - options[:implicit] = true - end - - # This will return nil if an equivalent explicit resource already exists. - # When resource classes no longer retain references to resource instances, - # this will need to be modified to catch that conflict and discard - # implicit resources. - if resource = create_resource(type, options) - resource.implicit = true - - return resource - else - return nil - end - end - - # Create a new resource and register it in the configuration. - def create_resource(type, options) - unless klass = Puppet::Type.type(type) - raise ArgumentError, "Unknown resource type %s" % type - end - return unless resource = klass.create(options) - - @transient_resources << resource if applying? - add_resource(resource) - if @relationship_graph - @relationship_graph.add_resource(resource) unless @relationship_graph.resource(resource.ref) - end - resource - end - - # Make sure we support the requested extraction format. - def extraction_format=(value) - unless respond_to?("extract_to_%s" % value) - raise ArgumentError, "Invalid extraction format %s" % value - end - @extraction_format = value - end - - # Turn our configuration graph into whatever the client is expecting. - def extract - send("extract_to_%s" % extraction_format) - end - - # Create the traditional TransBuckets and TransObjects from our configuration - # graph. This will hopefully be deprecated soon. - def extract_to_transportable - top = nil - current = nil - buckets = {} - - unless main = vertices.find { |res| res.type == "Class" and res.title == :main } - raise Puppet::DevError, "Could not find 'main' class; cannot generate configuration" - end - - # Create a proc for examining edges, which we'll use to build our tree - # of TransBuckets and TransObjects. - bucket = nil - edges = proc do |edge| - # The sources are always non-builtins. - source, target = edge.source, edge.target - unless tmp = buckets[source.to_s] - if tmp = buckets[source.to_s] = source.to_trans - bucket = tmp - else - # This is because virtual resources return nil. If a virtual - # container resource contains realized resources, we still need to get - # to them. So, we keep a reference to the last valid bucket - # we returned and use that if the container resource is virtual. - end - end - bucket = tmp || bucket - if child = target.to_trans - unless bucket - raise "No bucket created for %s" % source - end - bucket.push child - - # It's important that we keep a reference to any TransBuckets we've created, so - # we don't create multiple buckets for children. - unless target.builtin? - buckets[target.to_s] = child - end - end - end - dfs(:start => main, :examine_edge => edges) - - unless main - raise Puppet::DevError, "Could not find 'main' class; cannot generate configuration" - end - - # Retrieve the bucket for the top-level scope and set the appropriate metadata. - unless result = buckets[main.to_s] - # This only happens when the configuration is entirely empty. - result = buckets[main.to_s] = main.to_trans - end - - result.classes = classes - - # Clear the cache to encourage the GC - buckets.clear - return result - end - - # Make sure all of our resources are "finished". - def finalize - @resource_table.values.each { |resource| resource.finish } - - write_graph(:resources) - end - - def host_config? - host_config || false - end - - def initialize(name = nil) - super() - @name = name if name - @extraction_format ||= :transportable - @tags = [] - @classes = [] - @resource_table = {} - @transient_resources = [] - @applying = false - @relationship_graph = nil - - @aliases = Hash.new { |hash, key| hash[key] = [] } - - if block_given? - yield(self) - finalize() - end - end - - # Create a graph of all of the relationships in our configuration. - def relationship_graph - raise(Puppet::DevError, "Tried get a relationship graph for a relationship graph") if self.is_relationship_graph - - unless defined? @relationship_graph and @relationship_graph - # It's important that we assign the graph immediately, because - # the debug messages below use the relationships in the - # relationship graph to determine the path to the resources - # spitting out the messages. If this is not set, - # then we get into an infinite loop. - @relationship_graph = Puppet::Node::Configuration.new - @relationship_graph.host_config = host_config? - @relationship_graph.is_relationship_graph = true - - # First create the dependency graph - self.vertices.each do |vertex| - @relationship_graph.add_vertex! vertex - vertex.builddepends.each do |edge| - @relationship_graph.add_edge!(edge) - end - end - - # Lastly, add in any autorequires - @relationship_graph.vertices.each do |vertex| - vertex.autorequire.each do |edge| - unless @relationship_graph.edge?(edge.source, edge.target) # don't let automatic relationships conflict with manual ones. - unless @relationship_graph.edge?(edge.target, edge.source) - vertex.debug "Autorequiring %s" % [edge.source] - @relationship_graph.add_edge!(edge) - else - vertex.debug "Skipping automatic relationship with %s" % (edge.source == vertex ? edge.target : edge.source) - end - end - end - end - - @relationship_graph.write_graph(:relationships) - - # Then splice in the container information - @relationship_graph.splice!(self, Puppet::Type::Component) - - @relationship_graph.write_graph(:expanded_relationships) - end - @relationship_graph - end - - # Remove the resource from our configuration. Notice that we also call - # 'remove' on the resource, at least until resource classes no longer maintain - # references to the resource instances. - def remove_resource(*resources) - resources.each do |resource| - @resource_table.delete(resource.ref) - @aliases[resource.ref].each { |res_alias| @resource_table.delete(res_alias) } - @aliases[resource.ref].clear - remove_vertex!(resource) if vertex?(resource) - @relationship_graph.remove_vertex!(resource) if @relationship_graph and @relationship_graph.vertex?(resource) - resource.remove - end - end - - # Look a resource up by its reference (e.g., File[/etc/passwd]). - def resource(type, title = nil) - # Always create a resource reference, so that it always canonizes how we - # are referring to them. - if title - ref = Puppet::ResourceReference.new(type, title).to_s - else - # If they didn't provide a title, then we expect the first - # argument to be of the form 'Class[name]', which our - # Reference class canonizes for us. - ref = Puppet::ResourceReference.new(nil, type).to_s - end - if resource = @resource_table[ref] - return resource - elsif defined?(@relationship_graph) and @relationship_graph - @relationship_graph.resource(ref) - end - end - - # Add a tag. - def tag(*names) - names.each do |name| - name = name.to_s - @tags << name unless @tags.include?(name) - if name.include?("::") - name.split("::").each do |sub| - @tags << sub unless @tags.include?(sub) - end - end - end - nil - end - - # Return the list of tags. - def tags - @tags.dup - end - - # Convert our configuration into a RAL configuration. - def to_ral - to_configuration :to_type - end - - # Turn our parser configuration into a transportable configuration. - def to_transportable - to_configuration :to_transobject - end - - # Produce the graph files if requested. - def write_graph(name) - # We only want to graph the main host configuration. - return unless host_config? - - return unless Puppet[:graph] - - Puppet.settings.use(:graphing) - - file = File.join(Puppet[:graphdir], "%s.dot" % name.to_s) - File.open(file, "w") { |f| - f.puts to_dot("name" => name.to_s.capitalize) - } - end - - # LAK:NOTE We cannot yaml-dump the class in the edgelist_class, because classes cannot be - # dumped by default, nor does yaml-dumping # the edge-labels work at this point (I don't - # know why). - # Neither of these matters right now, but I suppose it could at some point. - # We also have to have the vertex_dict dumped after the resource table, because yaml can't - # seem to handle the output of yaml-dumping the vertex_dict. - def to_yaml_properties - props = instance_variables.reject { |v| %w{@edgelist_class @edge_labels @vertex_dict}.include?(v) } - props << "@vertex_dict" - props - end - - private - - def cleanup - unless @transient_resources.empty? - remove_resource(*@transient_resources) - @transient_resources.clear - @relationship_graph = nil - end - end - - # An abstracted method for converting one configuration into another type of configuration. - # This pretty much just converts all of the resources from one class to another, using - # a conversion method. - def to_configuration(convert) - result = self.class.new(self.name) - - map = {} - vertices.each do |resource| - next if resource.respond_to?(:virtual?) and resource.virtual? - - newres = resource.send(convert) - - # We can't guarantee that resources don't munge their names - # (like files do with trailing slashes), so we have to keep track - # of what a resource got converted to. - map[resource.ref] = newres - - result.add_resource newres - end - - message = convert.to_s.gsub "_", " " - edges.each do |edge| - # Skip edges between virtual resources. - next if edge.source.respond_to?(:virtual?) and edge.source.virtual? - next if edge.target.respond_to?(:virtual?) and edge.target.virtual? - - unless source = map[edge.source.ref] - raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.source.ref, message] - end - - unless target = map[edge.target.ref] - raise Puppet::DevError, "Could not find resource %s when converting %s resources" % [edge.target.ref, message] - end - - result.add_edge!(source, target, edge.label) - end - - map.clear - - result.add_class *self.classes - result.tag(*self.tags) - - return result - end -end diff --git a/lib/puppet/parser/ast/hostclass.rb b/lib/puppet/parser/ast/hostclass.rb index d4904bebf..63900d0e3 100644 --- a/lib/puppet/parser/ast/hostclass.rb +++ b/lib/puppet/parser/ast/hostclass.rb @@ -30,7 +30,7 @@ class Puppet::Parser::AST return nil end - scope.compile.configuration.tag(self.classname) + scope.compile.catalog.tag(self.classname) pnames = nil if pklass = self.parentobj diff --git a/lib/puppet/parser/compile.rb b/lib/puppet/parser/compile.rb index 93ba180a7..fdd0cbcf2 100644 --- a/lib/puppet/parser/compile.rb +++ b/lib/puppet/parser/compile.rb @@ -6,15 +6,15 @@ require 'puppet/external/gratr/import' require 'puppet/external/gratr/dot' require 'puppet/node' -require 'puppet/node/configuration' +require 'puppet/node/catalog' require 'puppet/util/errors' # Maintain a graph of scopes, along with a bunch of data -# about the individual configuration we're compiling. +# about the individual catalog we're compiling. class Puppet::Parser::Compile include Puppet::Util include Puppet::Util::Errors - attr_reader :parser, :node, :facts, :collections, :configuration, :node_scope + attr_reader :parser, :node, :facts, :collections, :catalog, :node_scope # Add a collection to the global list. def add_collection(coll) @@ -37,7 +37,7 @@ class Puppet::Parser::Compile end end @class_scopes[name] = scope - @configuration.add_class(name) unless name == "" + @catalog.add_class(name) unless name == "" end # Return the scope associated with a class. This is just here so @@ -55,11 +55,11 @@ class Puppet::Parser::Compile # Return a list of all of the defined classes. def classlist - return @configuration.classes + return @catalog.classes end - # Compile our configuration. This mostly revolves around finding and evaluating classes. - # This is the main entry into our configuration. + # Compile our catalog. This mostly revolves around finding and evaluating classes. + # This is the main entry into our catalog. def compile # Set the client's parameters into the top scope. set_node_parameters() @@ -80,7 +80,7 @@ class Puppet::Parser::Compile store() end - return @configuration + return @catalog end # LAK:FIXME There are no tests for this. @@ -111,7 +111,7 @@ class Puppet::Parser::Compile end # Evaluate each specified class in turn. If there are any classes we can't - # find, just tag the configuration and move on. This method really just + # find, just tag the catalog and move on. This method really just # creates resource objects that point back to the classes, and then the # resources are themselves evaluated later in the process. def evaluate_classes(classes, scope, lazy_evaluate = true) @@ -130,11 +130,11 @@ class Puppet::Parser::Compile # If they've disabled lazy evaluation (which the :include function does), # then evaluate our resource immediately. resource.evaluate unless lazy_evaluate - @configuration.tag(klass.classname) + @catalog.tag(klass.classname) found << name else Puppet.info "Could not find class %s for %s" % [name, node.name] - @configuration.tag(name) + @catalog.tag(name) end end found @@ -224,7 +224,7 @@ class Puppet::Parser::Compile # And in the resource graph. At some point, this might supercede # the global resource table, but the table is a lot faster # so it makes sense to maintain for now. - @configuration.add_edge!(scope.resource, resource) + @catalog.add_edge!(scope.resource, resource) end # The top scope is usually the top-level scope, but if we're using AST nodes, @@ -253,7 +253,7 @@ class Puppet::Parser::Compile # of resources. resource = Puppet::Parser::Resource.new(:type => "node", :title => astnode.classname, :scope => topscope, :source => topscope.source) store_resource(topscope, resource) - @configuration.tag(astnode.classname) + @catalog.tag(astnode.classname) resource.evaluate @@ -311,7 +311,7 @@ class Puppet::Parser::Compile done = false if evaluate_definitions break if done if count > 1000 - raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host configuration" + raise Puppet::ParseError, "Somehow looped more than 1000 times while evaluating host catalog" end end end @@ -323,14 +323,14 @@ class Puppet::Parser::Compile @main_resource = Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => @topscope, :source => @main) @topscope.resource = @main_resource - @configuration.add_vertex!(@main_resource) + @catalog.add_vertex!(@main_resource) @resource_table["Class[main]"] = @main_resource @main_resource.evaluate end - # Make sure the entire configuration is evaluated. + # Make sure the entire catalog is evaluated. def fail_on_unevaluated fail_on_unevaluated_overrides fail_on_unevaluated_resource_collections @@ -420,8 +420,8 @@ class Puppet::Parser::Compile @scope_graph = GRATR::Digraph.new # For maintaining the relationship between scopes and their resources. - @configuration = Puppet::Node::Configuration.new(@node.name) - @configuration.version = @parser.version + @catalog = Puppet::Node::Catalog.new(@node.name) + @catalog.version = @parser.version end # Set the node's parameters into the top-scope as variables. @@ -431,7 +431,7 @@ class Puppet::Parser::Compile end end - # Store the configuration into the database. + # Store the catalog into the database. def store unless Puppet.features.rails? raise Puppet::Error, @@ -451,7 +451,7 @@ class Puppet::Parser::Compile def store_to_active_record(node, resources) begin # We store all of the objects, even the collectable ones - benchmark(:info, "Stored configuration for #{node.name}") do + benchmark(:info, "Stored catalog for #{node.name}") do Puppet::Rails::Host.transaction do Puppet::Rails::Host.store(node, resources) end diff --git a/lib/puppet/parser/functions.rb b/lib/puppet/parser/functions.rb index a0e8da86f..34b38b809 100644 --- a/lib/puppet/parser/functions.rb +++ b/lib/puppet/parser/functions.rb @@ -146,7 +146,7 @@ module Functions tells you whether the current container is tagged with the specified tags. The tags are ANDed, so that all of the specified tags must be included for the function to return true.") do |vals| - configtags = compile.configuration.tags + configtags = compile.catalog.tags resourcetags = resource.tags retval = true diff --git a/lib/puppet/parser/interpreter.rb b/lib/puppet/parser/interpreter.rb index 87513cb18..e29e19944 100644 --- a/lib/puppet/parser/interpreter.rb +++ b/lib/puppet/parser/interpreter.rb @@ -9,7 +9,7 @@ require 'puppet/parser/scope' # The interpreter is a very simple entry-point class that # manages the existence of the parser (e.g., replacing it # when files are reparsed). You can feed it a node and -# get the node's configuration back. +# get the node's catalog back. class Puppet::Parser::Interpreter include Puppet::Util diff --git a/lib/puppet/resource_reference.rb b/lib/puppet/resource_reference.rb index 479de6127..3e92662b2 100644 --- a/lib/puppet/resource_reference.rb +++ b/lib/puppet/resource_reference.rb @@ -8,7 +8,7 @@ require 'puppet' # resources. class Puppet::ResourceReference attr_reader :type - attr_accessor :title, :configuration + attr_accessor :title, :catalog def initialize(type, title) # This will set @type if it looks like a resource reference. @@ -22,8 +22,8 @@ class Puppet::ResourceReference # Find our resource. def resolve - if configuration - return configuration.resource(to_s) + if catalog + return catalog.resource(to_s) end # If it's builtin, then just ask for it directly from the type. if t = builtin_type diff --git a/lib/puppet/transaction.rb b/lib/puppet/transaction.rb index ef53889cf..6a4981298 100644 --- a/lib/puppet/transaction.rb +++ b/lib/puppet/transaction.rb @@ -6,7 +6,7 @@ require 'puppet/propertychange' module Puppet class Transaction - attr_accessor :component, :configuration, :ignoreschedules + attr_accessor :component, :catalog, :ignoreschedules attr_accessor :sorted_resources, :configurator # The report, once generated. @@ -311,7 +311,7 @@ class Transaction ret = eval_resource(resource) end - if Puppet[:evaltrace] and @configuration.host_config? + if Puppet[:evaltrace] and @catalog.host_config? resource.info "Evaluated in %0.2f seconds" % seconds end ret @@ -358,7 +358,7 @@ class Transaction # Collect any dynamically generated resources. def generate - list = @configuration.vertices + list = @catalog.vertices # Store a list of all generated resources, so that we can clean them up # after the transaction closes. @@ -380,8 +380,8 @@ class Transaction end made.uniq! made.each do |res| - @configuration.add_resource(res) - res.configuration = configuration + @catalog.add_resource(res) + res.catalog = catalog newlist << res @generated << res res.finish @@ -424,22 +424,22 @@ class Transaction # Should we ignore tags? def ignore_tags? - ! @configuration.host_config? + ! @catalog.host_config? end # this should only be called by a Puppet::Type::Component resource now # and it should only receive an array def initialize(resources) - if resources.is_a?(Puppet::Node::Configuration) - @configuration = resources + if resources.is_a?(Puppet::Node::Catalog) + @catalog = resources elsif resources.is_a?(Puppet::PGraph) - raise "Transactions should get configurations now, not PGraph" + raise "Transactions should get catalogs now, not PGraph" else - raise "Transactions require configurations" + raise "Transactions require catalogs" end @resourcemetrics = { - :total => @configuration.vertices.length, + :total => @catalog.vertices.length, :out_of_sync => 0, # The number of resources that had changes :applied => 0, # The number of resources fixed :skipped => 0, # The number of resources skipped @@ -478,7 +478,7 @@ class Transaction # types, just providers. def prefetch prefetchers = {} - @configuration.vertices.each do |resource| + @catalog.vertices.each do |resource| if provider = resource.provider and provider.class.respond_to?(:prefetch) prefetchers[provider.class] ||= {} prefetchers[provider.class][resource.title] = resource @@ -511,7 +511,7 @@ class Transaction end def relationship_graph - configuration.relationship_graph + catalog.relationship_graph end # Send off the transaction report. diff --git a/lib/puppet/transportable.rb b/lib/puppet/transportable.rb index 6f5b2761c..c1d68a881 100644 --- a/lib/puppet/transportable.rb +++ b/lib/puppet/transportable.rb @@ -9,7 +9,7 @@ module Puppet # YAML. class TransObject include Enumerable - attr_accessor :type, :name, :file, :line, :configuration + attr_accessor :type, :name, :file, :line, :catalog attr_writer :tags @@ -99,7 +99,7 @@ module Puppet class TransBucket include Enumerable - attr_accessor :name, :type, :file, :line, :classes, :keyword, :top, :configuration + attr_accessor :name, :type, :file, :line, :classes, :keyword, :top, :catalog %w{delete shift include? length empty? << []}.each { |method| define_method(method) do |*args| @@ -179,16 +179,16 @@ module Puppet end # Create a resource graph from our structure. - def to_configuration - configuration = Puppet::Node::Configuration.new(Facter.value("hostname")) do |config| + def to_catalog + catalog = Puppet::Node::Catalog.new(Facter.value("hostname")) do |config| delver = proc do |obj| - obj.configuration = config + obj.catalog = config unless container = config.resource(obj.to_ref) container = obj.to_type config.add_resource container end obj.each do |child| - child.configuration = config + child.catalog = config unless resource = config.resource(child.to_ref) next unless resource = child.to_type config.add_resource resource @@ -203,7 +203,7 @@ module Puppet delver.call(self) end - return configuration + return catalog end def to_ref diff --git a/lib/puppet/type.rb b/lib/puppet/type.rb index 31ffe3bfb..def9e44e4 100644 --- a/lib/puppet/type.rb +++ b/lib/puppet/type.rb @@ -118,8 +118,8 @@ class Type #@validate = block end - # The configuration that this resource is stored in. - attr_accessor :configuration + # The catalog that this resource is stored in. + attr_accessor :catalog # create a log at specified level def log(msg) @@ -186,7 +186,7 @@ class Type self.title = hash.name #self[:name] = hash[:name] - [:file, :line, :tags, :configuration].each { |getter| + [:file, :line, :tags, :catalog].each { |getter| if hash.respond_to?(getter) setter = getter.to_s + "=" if val = hash.send(getter) @@ -289,7 +289,7 @@ class Type self.schedule # Make sure all of our relationships are valid. Again, must be done - # when the entire configuration is instantiated. + # when the entire catalog is instantiated. self.class.relationship_params.collect do |klass| if param = @parameters[klass.name] param.validate_relationship @@ -323,16 +323,16 @@ class Type return self[:name] end - # Look up our parent in the configuration, if we have one. + # Look up our parent in the catalog, if we have one. def parent - return nil unless configuration + return nil unless catalog unless defined?(@parent) # This is kinda weird. if implicit? - parents = configuration.relationship_graph.adjacent(self, :direction => :in) + parents = catalog.relationship_graph.adjacent(self, :direction => :in) else - parents = configuration.adjacent(self, :direction => :in) + parents = catalog.adjacent(self, :direction => :in) end if parents # We should never have more than one parent, so let's just ignore diff --git a/lib/puppet/type/component.rb b/lib/puppet/type/component.rb index 6dc90596d..356205089 100644 --- a/lib/puppet/type/component.rb +++ b/lib/puppet/type/component.rb @@ -140,7 +140,7 @@ Puppet::Type.newtype(:component) do end def refresh - configuration.adjacent(self).each do |child| + catalog.adjacent(self).each do |child| if child.respond_to?(:refresh) child.refresh child.log "triggering %s" % :refresh diff --git a/lib/puppet/type/pfile.rb b/lib/puppet/type/pfile.rb index 73c60bd14..bccdaa265 100644 --- a/lib/puppet/type/pfile.rb +++ b/lib/puppet/type/pfile.rb @@ -574,7 +574,7 @@ module Puppet # Create a new file or directory object as a child to the current # object. def newchild(path, local, hash = {}) - raise(Puppet::DevError, "File recursion cannot happen without a configuration") unless configuration + raise(Puppet::DevError, "File recursion cannot happen without a catalog") unless catalog # make local copy of arguments args = symbolize_options(@arghash) @@ -615,7 +615,7 @@ module Puppet # before 'sourcerecurse'. I could push the override stuff into # a separate method or something, but the work is the same other # than this last bit, so it doesn't really make sense. - if child = configuration.resource(:file, path) + if child = catalog.resource(:file, path) unless child.parent.object_id == self.object_id self.debug "Not managing more explicit file %s" % path @@ -643,7 +643,7 @@ module Puppet begin # This method is used by subclasses of :file, so use the class name rather than hard-coding # :file. - return nil unless child = configuration.create_implicit_resource(self.class.name, args) + return nil unless child = catalog.create_implicit_resource(self.class.name, args) rescue => detail puts detail.backtrace self.notice "Cannot manage: %s" % [detail] @@ -653,7 +653,7 @@ module Puppet # LAK:FIXME This shouldn't be necessary, but as long as we're # modeling the relationship graph specifically, it is. - configuration.relationship_graph.add_edge! self, child + catalog.relationship_graph.add_edge! self, child return child end @@ -663,7 +663,7 @@ module Puppet # time. def pathbuilder # We specifically need to call the method here, so it looks - # up our parent in the configuration graph. + # up our parent in the catalog graph. if parent = parent() # We only need to behave specially when our parent is also # a file diff --git a/lib/puppet/util/settings.rb b/lib/puppet/util/settings.rb index 7b446e736..b672d9564 100644 --- a/lib/puppet/util/settings.rb +++ b/lib/puppet/util/settings.rb @@ -75,7 +75,7 @@ class Puppet::Util::Settings def apply trans = self.to_transportable begin - config = trans.to_configuration + config = trans.to_catalog config.store_state = false config.apply config.clear @@ -590,7 +590,7 @@ class Puppet::Util::Settings # Convert our list of objects into a component that can be applied. def to_configuration transport = self.to_transportable - return transport.to_configuration + return transport.to_catalog end # Convert our list of config elements into a configuration file. @@ -676,7 +676,7 @@ Generated on #{Time.now}. bucket = to_transportable(*sections) - config = bucket.to_configuration + config = bucket.to_catalog config.host_config = false config.apply do |transaction| if failures = transaction.any_failed? diff --git a/spec/unit/indirector/catalog/compiler.rb b/spec/unit/indirector/catalog/compiler.rb new file mode 100755 index 000000000..77638a410 --- /dev/null +++ b/spec/unit/indirector/catalog/compiler.rb @@ -0,0 +1,209 @@ +#!/usr/bin/env ruby +# +# Created by Luke Kanies on 2007-9-23. +# Copyright (c) 2007. All rights reserved. + +require File.dirname(__FILE__) + '/../../../spec_helper' + +require 'puppet/indirector/catalog/compiler' + +describe Puppet::Node::Catalog::Compiler do + before do + Puppet.expects(:version).returns(1) + Facter.expects(:value).with('fqdn').returns("my.server.com") + Facter.expects(:value).with('ipaddress').returns("my.ip.address") + end + + it "should gather data about itself" do + Puppet::Node::Catalog::Compiler.new + end + + it "should cache the server metadata and reuse it" do + compiler = Puppet::Node::Catalog::Compiler.new + node1 = stub 'node1', :merge => nil + node2 = stub 'node2', :merge => nil + compiler.stubs(:compile) + Puppet::Node.stubs(:find_by_any_name).with('node1').returns(node1) + Puppet::Node.stubs(:find_by_any_name).with('node2').returns(node2) + + compiler.find('node1') + compiler.find('node2') + end + + it "should provide a method for determining if the catalog is networked" do + compiler = Puppet::Node::Catalog::Compiler.new + compiler.should respond_to(:networked?) + end +end + +describe Puppet::Node::Catalog::Compiler, " when creating the interpreter" do + before do + # This gets pretty annoying on a plane where we have no IP address + Facter.stubs(:value).returns("whatever") + @compiler = Puppet::Node::Catalog::Compiler.new + end + + it "should not create the interpreter until it is asked for the first time" do + interp = mock 'interp' + Puppet::Parser::Interpreter.expects(:new).with().returns(interp) + @compiler.interpreter.should equal(interp) + end + + it "should use the same interpreter for all compiles" do + interp = mock 'interp' + Puppet::Parser::Interpreter.expects(:new).with().returns(interp) + @compiler.interpreter.should equal(interp) + @compiler.interpreter.should equal(interp) + end +end + +describe Puppet::Node::Catalog::Compiler, " when finding nodes" do + before do + Facter.stubs(:value).returns("whatever") + @compiler = Puppet::Node::Catalog::Compiler.new + @name = "me" + @node = mock 'node' + @compiler.stubs(:compile) + end + + it "should look node information up via the Node class with the provided key" do + @node.stubs :merge + Puppet::Node.expects(:find_by_any_name).with(@name).returns(@node) + @compiler.find(@name) + end + + it "should fail if it cannot find the node" do + @node.stubs :merge + Puppet::Node.expects(:find_by_any_name).with(@name).returns(nil) + proc { @compiler.find(@name) }.should raise_error(Puppet::Error) + end +end + +describe Puppet::Node::Catalog::Compiler, " after finding nodes" do + before do + Puppet.expects(:version).returns(1) + Puppet.settings.stubs(:value).with(:node_name).returns("cert") + Facter.expects(:value).with('fqdn').returns("my.server.com") + Facter.expects(:value).with('ipaddress').returns("my.ip.address") + @compiler = Puppet::Node::Catalog::Compiler.new + @name = "me" + @node = mock 'node' + @compiler.stubs(:compile) + Puppet::Node.stubs(:find_by_any_name).with(@name).returns(@node) + end + + it "should add the server's Puppet version to the node's parameters as 'serverversion'" do + @node.expects(:merge).with { |args| args["serverversion"] == "1" } + @compiler.find(@name) + end + + it "should add the server's fqdn to the node's parameters as 'servername'" do + @node.expects(:merge).with { |args| args["servername"] == "my.server.com" } + @compiler.find(@name) + end + + it "should add the server's IP address to the node's parameters as 'serverip'" do + @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" } + @compiler.find(@name) + end + + # LAK:TODO This is going to be difficult, because this whole process is so + # far removed from the actual connection that the certificate information + # will be quite hard to come by, dum by, gum by. + it "should search for the name using the client certificate's DN if the :node_name setting is set to 'cert'" do + pending "Probably will end up in the REST work" + end +end + +describe Puppet::Node::Catalog::Compiler, " when creating catalogs" do + before do + Facter.stubs(:value).returns("whatever") + env = stub 'environment', :name => "yay" + Puppet::Node::Environment.stubs(:new).returns(env) + + @compiler = Puppet::Node::Catalog::Compiler.new + @name = "me" + @node = Puppet::Node.new @name + @node.stubs(:merge) + Puppet::Node.stubs(:find_by_any_name).with(@name).returns(@node) + end + + it "should directly use provided nodes" do + Puppet::Node.expects(:find_by_any_name).never + @compiler.interpreter.expects(:compile).with(@node) + @compiler.find(@node) + end + + it "should pass the found node to the interpreter for compiling" do + config = mock 'config' + @compiler.interpreter.expects(:compile).with(@node) + @compiler.find(@name) + end + + it "should return the results of compiling as the catalog" do + config = mock 'config' + result = mock 'result', :to_transportable => :catalog + + @compiler.interpreter.expects(:compile).with(@node).returns(result) + @compiler.find(@name).should == :catalog + end + + it "should benchmark the compile process" do + @compiler.stubs(:networked?).returns(true) + @compiler.expects(:benchmark).with do |level, message| + level == :notice and message =~ /^Compiled catalog/ + end + @compiler.interpreter.stubs(:compile).with(@node) + @compiler.find(@name) + end +end + +describe Puppet::Node::Catalog::Compiler, " when determining a client's available catalog version" do + before do + Puppet::Node::Facts.stubs(:find).returns(nil) + Facter.stubs(:value).returns("whatever") + @catalog = Puppet::Node::Catalog::Compiler.new + @name = "johnny" + end + + it "should provide a mechanism for providing the version of a given client's catalog" do + @catalog.should respond_to(:version) + end + + it "should use the client's Facts version as the available catalog version if it is the most recent" do + Puppet::Node::Facts.expects(:version).with(@name).returns(5) + Puppet::Node.expects(:version).with(@name).returns(3) + @catalog.interpreter.stubs(:catalog_version).returns(4) + + @catalog.version(@name).should == 5 + end + + it "should use the client's Node version as the available catalog version if it is the most recent" do + Puppet::Node::Facts.expects(:version).with(@name).returns(3) + Puppet::Node.expects(:version).with(@name).returns(5) + @catalog.interpreter.stubs(:catalog_version).returns(4) + + @catalog.version(@name).should == 5 + end + + it "should use the last parse date as the available catalog version if it is the most recent" do + Puppet::Node::Facts.expects(:version).with(@name).returns(3) + Puppet::Node.expects(:version).with(@name).returns(4) + @catalog.interpreter.stubs(:catalog_version).returns(5) + + @catalog.version(@name).should == 5 + end + + it "should return a version of 0 if no information on the node can be found" do + Puppet::Node.stubs(:find_by_any_name).returns(nil) + @catalog.version(@name).should == 0 + end + + it "should indicate when an update is available even if an input has clock skew" do + pending "Unclear how to implement this" + end + + it "should not indicate an available update when apparent updates are a result of clock skew" do + pending "Unclear how to implement this" + end +end diff --git a/spec/unit/indirector/catalog/yaml.rb b/spec/unit/indirector/catalog/yaml.rb new file mode 100755 index 000000000..717fb816c --- /dev/null +++ b/spec/unit/indirector/catalog/yaml.rb @@ -0,0 +1,25 @@ +#!/usr/bin/env ruby + +require File.dirname(__FILE__) + '/../../../spec_helper' + +require 'puppet/node/catalog' +require 'puppet/indirector/catalog/yaml' + +describe Puppet::Node::Catalog::Yaml do + it "should be a subclass of the Yaml terminus" do + Puppet::Node::Catalog::Yaml.superclass.should equal(Puppet::Indirector::Yaml) + end + + it "should have documentation" do + Puppet::Node::Catalog::Yaml.doc.should_not be_nil + end + + it "should be registered with the catalog store indirection" do + indirection = Puppet::Indirector::Indirection.instance(:catalog) + Puppet::Node::Catalog::Yaml.indirection.should equal(indirection) + end + + it "should have its name set to :yaml" do + Puppet::Node::Catalog::Yaml.name.should == :yaml + end +end diff --git a/spec/unit/indirector/configuration/compiler.rb b/spec/unit/indirector/configuration/compiler.rb deleted file mode 100755 index d949a28a5..000000000 --- a/spec/unit/indirector/configuration/compiler.rb +++ /dev/null @@ -1,209 +0,0 @@ -#!/usr/bin/env ruby -# -# Created by Luke Kanies on 2007-9-23. -# Copyright (c) 2007. All rights reserved. - -require File.dirname(__FILE__) + '/../../../spec_helper' - -require 'puppet/indirector/configuration/compiler' - -describe Puppet::Node::Configuration::Compiler do - before do - Puppet.expects(:version).returns(1) - Facter.expects(:value).with('fqdn').returns("my.server.com") - Facter.expects(:value).with('ipaddress').returns("my.ip.address") - end - - it "should gather data about itself" do - Puppet::Node::Configuration::Compiler.new - end - - it "should cache the server metadata and reuse it" do - compiler = Puppet::Node::Configuration::Compiler.new - node1 = stub 'node1', :merge => nil - node2 = stub 'node2', :merge => nil - compiler.stubs(:compile) - Puppet::Node.stubs(:find_by_any_name).with('node1').returns(node1) - Puppet::Node.stubs(:find_by_any_name).with('node2').returns(node2) - - compiler.find('node1') - compiler.find('node2') - end - - it "should provide a method for determining if the configuration is networked" do - compiler = Puppet::Node::Configuration::Compiler.new - compiler.should respond_to(:networked?) - end -end - -describe Puppet::Node::Configuration::Compiler, " when creating the interpreter" do - before do - # This gets pretty annoying on a plane where we have no IP address - Facter.stubs(:value).returns("whatever") - @compiler = Puppet::Node::Configuration::Compiler.new - end - - it "should not create the interpreter until it is asked for the first time" do - interp = mock 'interp' - Puppet::Parser::Interpreter.expects(:new).with().returns(interp) - @compiler.interpreter.should equal(interp) - end - - it "should use the same interpreter for all compiles" do - interp = mock 'interp' - Puppet::Parser::Interpreter.expects(:new).with().returns(interp) - @compiler.interpreter.should equal(interp) - @compiler.interpreter.should equal(interp) - end -end - -describe Puppet::Node::Configuration::Compiler, " when finding nodes" do - before do - Facter.stubs(:value).returns("whatever") - @compiler = Puppet::Node::Configuration::Compiler.new - @name = "me" - @node = mock 'node' - @compiler.stubs(:compile) - end - - it "should look node information up via the Node class with the provided key" do - @node.stubs :merge - Puppet::Node.expects(:find_by_any_name).with(@name).returns(@node) - @compiler.find(@name) - end - - it "should fail if it cannot find the node" do - @node.stubs :merge - Puppet::Node.expects(:find_by_any_name).with(@name).returns(nil) - proc { @compiler.find(@name) }.should raise_error(Puppet::Error) - end -end - -describe Puppet::Node::Configuration::Compiler, " after finding nodes" do - before do - Puppet.expects(:version).returns(1) - Puppet.settings.stubs(:value).with(:node_name).returns("cert") - Facter.expects(:value).with('fqdn').returns("my.server.com") - Facter.expects(:value).with('ipaddress').returns("my.ip.address") - @compiler = Puppet::Node::Configuration::Compiler.new - @name = "me" - @node = mock 'node' - @compiler.stubs(:compile) - Puppet::Node.stubs(:find_by_any_name).with(@name).returns(@node) - end - - it "should add the server's Puppet version to the node's parameters as 'serverversion'" do - @node.expects(:merge).with { |args| args["serverversion"] == "1" } - @compiler.find(@name) - end - - it "should add the server's fqdn to the node's parameters as 'servername'" do - @node.expects(:merge).with { |args| args["servername"] == "my.server.com" } - @compiler.find(@name) - end - - it "should add the server's IP address to the node's parameters as 'serverip'" do - @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" } - @compiler.find(@name) - end - - # LAK:TODO This is going to be difficult, because this whole process is so - # far removed from the actual connection that the certificate information - # will be quite hard to come by, dum by, gum by. - it "should search for the name using the client certificate's DN if the :node_name setting is set to 'cert'" do - pending "Probably will end up in the REST work" - end -end - -describe Puppet::Node::Configuration::Compiler, " when creating configurations" do - before do - Facter.stubs(:value).returns("whatever") - env = stub 'environment', :name => "yay" - Puppet::Node::Environment.stubs(:new).returns(env) - - @compiler = Puppet::Node::Configuration::Compiler.new - @name = "me" - @node = Puppet::Node.new @name - @node.stubs(:merge) - Puppet::Node.stubs(:find_by_any_name).with(@name).returns(@node) - end - - it "should directly use provided nodes" do - Puppet::Node.expects(:find_by_any_name).never - @compiler.interpreter.expects(:compile).with(@node) - @compiler.find(@node) - end - - it "should pass the found node to the interpreter for compiling" do - config = mock 'config' - @compiler.interpreter.expects(:compile).with(@node) - @compiler.find(@name) - end - - it "should return the results of compiling as the configuration" do - config = mock 'config' - result = mock 'result', :to_transportable => :configuration - - @compiler.interpreter.expects(:compile).with(@node).returns(result) - @compiler.find(@name).should == :configuration - end - - it "should benchmark the compile process" do - @compiler.stubs(:networked?).returns(true) - @compiler.expects(:benchmark).with do |level, message| - level == :notice and message =~ /^Compiled configuration/ - end - @compiler.interpreter.stubs(:compile).with(@node) - @compiler.find(@name) - end -end - -describe Puppet::Node::Configuration::Compiler, " when determining a client's available configuration version" do - before do - Puppet::Node::Facts.stubs(:find).returns(nil) - Facter.stubs(:value).returns("whatever") - @configuration = Puppet::Node::Configuration::Compiler.new - @name = "johnny" - end - - it "should provide a mechanism for providing the version of a given client's configuration" do - @configuration.should respond_to(:version) - end - - it "should use the client's Facts version as the available configuration version if it is the most recent" do - Puppet::Node::Facts.expects(:version).with(@name).returns(5) - Puppet::Node.expects(:version).with(@name).returns(3) - @configuration.interpreter.stubs(:configuration_version).returns(4) - - @configuration.version(@name).should == 5 - end - - it "should use the client's Node version as the available configuration version if it is the most recent" do - Puppet::Node::Facts.expects(:version).with(@name).returns(3) - Puppet::Node.expects(:version).with(@name).returns(5) - @configuration.interpreter.stubs(:configuration_version).returns(4) - - @configuration.version(@name).should == 5 - end - - it "should use the last parse date as the available configuration version if it is the most recent" do - Puppet::Node::Facts.expects(:version).with(@name).returns(3) - Puppet::Node.expects(:version).with(@name).returns(4) - @configuration.interpreter.stubs(:configuration_version).returns(5) - - @configuration.version(@name).should == 5 - end - - it "should return a version of 0 if no information on the node can be found" do - Puppet::Node.stubs(:find_by_any_name).returns(nil) - @configuration.version(@name).should == 0 - end - - it "should indicate when an update is available even if an input has clock skew" do - pending "Unclear how to implement this" - end - - it "should not indicate an available update when apparent updates are a result of clock skew" do - pending "Unclear how to implement this" - end -end diff --git a/spec/unit/indirector/configuration/yaml.rb b/spec/unit/indirector/configuration/yaml.rb deleted file mode 100755 index b9f3f40d1..000000000 --- a/spec/unit/indirector/configuration/yaml.rb +++ /dev/null @@ -1,25 +0,0 @@ -#!/usr/bin/env ruby - -require File.dirname(__FILE__) + '/../../../spec_helper' - -require 'puppet/node/configuration' -require 'puppet/indirector/configuration/yaml' - -describe Puppet::Node::Configuration::Yaml do - it "should be a subclass of the Yaml terminus" do - Puppet::Node::Configuration::Yaml.superclass.should equal(Puppet::Indirector::Yaml) - end - - it "should have documentation" do - Puppet::Node::Configuration::Yaml.doc.should_not be_nil - end - - it "should be registered with the configuration store indirection" do - indirection = Puppet::Indirector::Indirection.instance(:configuration) - Puppet::Node::Configuration::Yaml.indirection.should equal(indirection) - end - - it "should have its name set to :yaml" do - Puppet::Node::Configuration::Yaml.name.should == :yaml - end -end diff --git a/spec/unit/network/client/master.rb b/spec/unit/network/client/master.rb index dca923994..7bf755d88 100755 --- a/spec/unit/network/client/master.rb +++ b/spec/unit/network/client/master.rb @@ -6,7 +6,7 @@ require File.dirname(__FILE__) + '/../../../spec_helper' require 'puppet/network/client/master' -describe Puppet::Network::Client::Master, " when retrieving the configuration" do +describe Puppet::Network::Client::Master, " when retrieving the catalog" do before do @master = mock 'master' @client = Puppet::Network::Client.master.new( @@ -22,7 +22,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.getconfig end - it "should collect facts to use for configuration retrieval" do + it "should collect facts to use for catalog retrieval" do @client.stubs(:dostorage) @client.class.expects(:facts).returns(@facts) @master.stubs(:getconfig).returns(nil) @@ -36,7 +36,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d proc { @client.getconfig }.should raise_error(Puppet::Network::ClientError) end - it "should use the cached configuration if it is up to date" do + it "should use the cached catalog if it is up to date" do file = "/path/to/cachefile" @client.stubs(:cachefile).returns(file) FileTest.expects(:exist?).with(file).returns(true) @@ -48,7 +48,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.getconfig end - it "should log that the configuration does not need a recompile" do + it "should log that the catalog does not need a recompile" do file = "/path/to/cachefile" @client.stubs(:cachefile).returns(file) FileTest.stubs(:exist?).with(file).returns(true) @@ -75,7 +75,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.getconfig end - it "should use the cached configuration if no configuration could be retrieved" do + it "should use the cached catalog if no catalog could be retrieved" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).raises(ArgumentError.new("whev")) @@ -83,7 +83,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.getconfig end - it "should load the retrieved configuration using YAML" do + it "should load the retrieved catalog using YAML" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).returns("myconfig") @@ -94,14 +94,14 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.stubs(:setclasses) config.stubs(:classes) - config.stubs(:to_configuration).returns(config) + config.stubs(:to_catalog).returns(config) config.stubs(:host_config=) config.stubs(:from_cache).returns(true) @client.getconfig end - it "should use the cached configuration if the retrieved configuration cannot be converted from YAML" do + it "should use the cached catalog if the retrieved catalog cannot be converted from YAML" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).returns("myconfig") @@ -113,7 +113,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.getconfig end - it "should set the classes.txt file with the classes listed in the retrieved configuration" do + it "should set the classes.txt file with the classes listed in the retrieved catalog" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).returns("myconfig") @@ -124,14 +124,14 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d config.expects(:classes).returns(:myclasses) @client.expects(:setclasses).with(:myclasses) - config.stubs(:to_configuration).returns(config) + config.stubs(:to_catalog).returns(config) config.stubs(:host_config=) config.stubs(:from_cache).returns(true) @client.getconfig end - it "should convert the retrieved configuration to a RAL configuration" do + it "should convert the retrieved catalog to a RAL catalog" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).returns("myconfig") @@ -144,7 +144,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d config = mock 'config' yamlconfig.stubs(:classes) - yamlconfig.expects(:to_configuration).returns(config) + yamlconfig.expects(:to_catalog).returns(config) config.stubs(:host_config=) config.stubs(:from_cache).returns(true) @@ -152,7 +152,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.getconfig end - it "should use the cached configuration if the retrieved configuration cannot be converted to a RAL configuration" do + it "should use the cached catalog if the retrieved catalog cannot be converted to a RAL catalog" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).returns("myconfig") @@ -165,14 +165,14 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d config = mock 'config' yamlconfig.stubs(:classes) - yamlconfig.expects(:to_configuration).raises(ArgumentError) + yamlconfig.expects(:to_catalog).raises(ArgumentError) @client.expects(:use_cached_config).with(true) @client.getconfig end - it "should clear the failed configuration if using the cached configuration after failing to instantiate the retrieved configuration" do + it "should clear the failed catalog if using the cached catalog after failing to instantiate the retrieved catalog" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).returns("myconfig") @@ -185,7 +185,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d config = mock 'config' yamlconfig.stubs(:classes) - yamlconfig.stubs(:to_configuration).raises(ArgumentError) + yamlconfig.stubs(:to_catalog).raises(ArgumentError) @client.stubs(:use_cached_config).with(true) @@ -194,7 +194,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.getconfig end - it "should cache the retrieved yaml configuration if it is not from the cache and is valid" do + it "should cache the retrieved yaml catalog if it is not from the cache and is valid" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).returns("myconfig") @@ -207,7 +207,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d config = mock 'config' yamlconfig.stubs(:classes) - yamlconfig.expects(:to_configuration).returns(config) + yamlconfig.expects(:to_catalog).returns(config) config.stubs(:host_config=) @@ -218,7 +218,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d @client.getconfig end - it "should mark the configuration as a host configuration" do + it "should mark the catalog as a host catalog" do @client.stubs(:dostorage) @client.class.stubs(:facts).returns(@facts) @master.stubs(:getconfig).returns("myconfig") @@ -231,7 +231,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d config = mock 'config' yamlconfig.stubs(:classes) - yamlconfig.expects(:to_configuration).returns(config) + yamlconfig.expects(:to_catalog).returns(config) config.stubs(:from_cache).returns(true) @@ -241,7 +241,7 @@ describe Puppet::Network::Client::Master, " when retrieving the configuration" d end end -describe Puppet::Network::Client::Master, " when using the cached configuration" do +describe Puppet::Network::Client::Master, " when using the cached catalog" do before do @master = mock 'master' @client = Puppet::Network::Client.master.new( @@ -250,8 +250,8 @@ describe Puppet::Network::Client::Master, " when using the cached configuration" @facts = {"one" => "two", "three" => "four"} end - it "should return do nothing and true if there is already an in-memory configuration" do - @client.configuration = :whatever + it "should return do nothing and true if there is already an in-memory catalog" do + @client.catalog = :whatever Puppet::Network::Client::Master.publicize_methods :use_cached_config do @client.use_cached_config.should be_true end @@ -264,14 +264,14 @@ describe Puppet::Network::Client::Master, " when using the cached configuration" end end - it "should return false if no cached configuration can be found" do + it "should return false if no cached catalog can be found" do @client.expects(:retrievecache).returns(nil) Puppet::Network::Client::Master.publicize_methods :use_cached_config do @client.use_cached_config().should be_false end end - it "should return false if the cached configuration cannot be instantiated" do + it "should return false if the cached catalog cannot be instantiated" do YAML.expects(:load).raises(ArgumentError) @client.expects(:retrievecache).returns("whatever") Puppet::Network::Client::Master.publicize_methods :use_cached_config do @@ -279,7 +279,7 @@ describe Puppet::Network::Client::Master, " when using the cached configuration" end end - it "should warn if the cached configuration cannot be instantiated" do + it "should warn if the cached catalog cannot be instantiated" do YAML.stubs(:load).raises(ArgumentError) @client.stubs(:retrievecache).returns("whatever") Puppet.expects(:warning).with { |m| m.include?("Could not load cache") } @@ -288,7 +288,7 @@ describe Puppet::Network::Client::Master, " when using the cached configuration" end end - it "should clear the client if the cached configuration cannot be instantiated" do + it "should clear the client if the cached catalog cannot be instantiated" do YAML.stubs(:load).raises(ArgumentError) @client.stubs(:retrievecache).returns("whatever") @client.expects(:clear) @@ -297,14 +297,14 @@ describe Puppet::Network::Client::Master, " when using the cached configuration" end end - it "should return true if the cached configuration can be instantiated" do + it "should return true if the cached catalog can be instantiated" do config = mock 'config' YAML.stubs(:load).returns(config) ral_config = mock 'ral config' ral_config.stubs(:from_cache=) ral_config.stubs(:host_config=) - config.expects(:to_configuration).returns(ral_config) + config.expects(:to_catalog).returns(ral_config) @client.stubs(:retrievecache).returns("whatever") Puppet::Network::Client::Master.publicize_methods :use_cached_config do @@ -312,54 +312,54 @@ describe Puppet::Network::Client::Master, " when using the cached configuration" end end - it "should set the configuration instance variable if the cached configuration can be instantiated" do + it "should set the catalog instance variable if the cached catalog can be instantiated" do config = mock 'config' YAML.stubs(:load).returns(config) ral_config = mock 'ral config' ral_config.stubs(:from_cache=) ral_config.stubs(:host_config=) - config.expects(:to_configuration).returns(ral_config) + config.expects(:to_catalog).returns(ral_config) @client.stubs(:retrievecache).returns("whatever") Puppet::Network::Client::Master.publicize_methods :use_cached_config do @client.use_cached_config() end - @client.configuration.should equal(ral_config) + @client.catalog.should equal(ral_config) end - it "should mark the configuration as a host_config if valid" do + it "should mark the catalog as a host_config if valid" do config = mock 'config' YAML.stubs(:load).returns(config) ral_config = mock 'ral config' ral_config.stubs(:from_cache=) ral_config.expects(:host_config=).with(true) - config.expects(:to_configuration).returns(ral_config) + config.expects(:to_catalog).returns(ral_config) @client.stubs(:retrievecache).returns("whatever") Puppet::Network::Client::Master.publicize_methods :use_cached_config do @client.use_cached_config() end - @client.configuration.should equal(ral_config) + @client.catalog.should equal(ral_config) end - it "should mark the configuration as from the cache if valid" do + it "should mark the catalog as from the cache if valid" do config = mock 'config' YAML.stubs(:load).returns(config) ral_config = mock 'ral config' ral_config.expects(:from_cache=).with(true) ral_config.stubs(:host_config=) - config.expects(:to_configuration).returns(ral_config) + config.expects(:to_catalog).returns(ral_config) @client.stubs(:retrievecache).returns("whatever") Puppet::Network::Client::Master.publicize_methods :use_cached_config do @client.use_cached_config() end - @client.configuration.should equal(ral_config) + @client.catalog.should equal(ral_config) end end diff --git a/spec/unit/network/http/mongrel.rb b/spec/unit/network/http/mongrel.rb index b6ad07567..a39e7354a 100644 --- a/spec/unit/network/http/mongrel.rb +++ b/spec/unit/network/http/mongrel.rb @@ -23,7 +23,7 @@ describe Puppet::Network::HTTP::Mongrel, "when turning on listening" do @mock_mongrel.stubs(:run) @mock_mongrel.stubs(:register) Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel) - @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :configuration ], :protocols => [ :rest, :xmlrpc ] } + @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest, :xmlrpc ] } end it "should fail if already listening" do @@ -102,7 +102,7 @@ describe Puppet::Network::HTTP::Mongrel, "when turning off listening" do @mock_mongrel.stubs(:register) Mongrel::HttpServer.stubs(:new).returns(@mock_mongrel) @server = Puppet::Network::HTTP::Mongrel.new - @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :configuration ], :protocols => [ :rest, :xmlrpc ] } + @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest, :xmlrpc ] } end it "should fail unless listening" do diff --git a/spec/unit/network/http/webrick.rb b/spec/unit/network/http/webrick.rb index 3ed223e7e..0689b1b6b 100644 --- a/spec/unit/network/http/webrick.rb +++ b/spec/unit/network/http/webrick.rb @@ -18,7 +18,7 @@ describe Puppet::Network::HTTP::WEBrick, "when turning on listening" do [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)} WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick) @server = Puppet::Network::HTTP::WEBrick.new - @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :configuration ], :protocols => [ :rest, :xmlrpc ] } + @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest, :xmlrpc ] } end it "should fail if already listening" do @@ -94,7 +94,7 @@ describe Puppet::Network::HTTP::WEBrick, "when turning off listening" do [:mount, :start, :shutdown].each {|meth| @mock_webrick.stubs(meth)} WEBrick::HTTPServer.stubs(:new).returns(@mock_webrick) @server = Puppet::Network::HTTP::WEBrick.new - @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :configuration ], :protocols => [ :rest, :xmlrpc ] } + @listen_params = { :address => "127.0.0.1", :port => 31337, :handlers => [ :node, :catalog ], :protocols => [ :rest, :xmlrpc ] } end it "should fail unless listening" do diff --git a/spec/unit/node/catalog.rb b/spec/unit/node/catalog.rb new file mode 100755 index 000000000..a94ace68f --- /dev/null +++ b/spec/unit/node/catalog.rb @@ -0,0 +1,783 @@ +#!/usr/bin/env ruby + +require File.dirname(__FILE__) + '/../../spec_helper' + +describe Puppet::Node::Catalog, " when compiling" do + it "should accept tags" do + config = Puppet::Node::Catalog.new("mynode") + config.tag("one") + config.tags.should == %w{one} + end + + it "should accept multiple tags at once" do + config = Puppet::Node::Catalog.new("mynode") + config.tag("one", "two") + config.tags.should == %w{one two} + end + + it "should convert all tags to strings" do + config = Puppet::Node::Catalog.new("mynode") + config.tag("one", :two) + config.tags.should == %w{one two} + end + + it "should tag with both the qualified name and the split name" do + config = Puppet::Node::Catalog.new("mynode") + config.tag("one::two") + config.tags.include?("one").should be_true + config.tags.include?("one::two").should be_true + end + + it "should accept classes" do + config = Puppet::Node::Catalog.new("mynode") + config.add_class("one") + config.classes.should == %w{one} + config.add_class("two", "three") + config.classes.should == %w{one two three} + end + + it "should tag itself with passed class names" do + config = Puppet::Node::Catalog.new("mynode") + config.add_class("one") + config.tags.should == %w{one} + end +end + +describe Puppet::Node::Catalog, " when extracting" do + it "should return extraction result as the method result" do + config = Puppet::Node::Catalog.new("mynode") + config.expects(:extraction_format).returns(:whatever) + config.expects(:extract_to_whatever).returns(:result) + config.extract.should == :result + end +end + +describe Puppet::Node::Catalog, " when extracting transobjects" do + + def mkscope + @parser = Puppet::Parser::Parser.new :Code => "" + @node = Puppet::Node.new("mynode") + @compile = Puppet::Parser::Compile.new(@node, @parser) + + # XXX This is ridiculous. + @compile.send(:evaluate_main) + @scope = @compile.topscope + end + + def mkresource(type, name) + Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope) + end + + it "should always create a TransBucket for the 'main' class" do + config = Puppet::Node::Catalog.new("mynode") + + @scope = mkscope + @source = mock 'source' + + main = mkresource("class", :main) + config.add_vertex!(main) + + bucket = mock 'bucket' + bucket.expects(:classes=).with(config.classes) + main.stubs(:builtin?).returns(false) + main.expects(:to_transbucket).returns(bucket) + + config.extract_to_transportable.should equal(bucket) + end + + # This isn't really a spec-style test, but I don't know how better to do it. + it "should transform the resource graph into a tree of TransBuckets and TransObjects" do + config = Puppet::Node::Catalog.new("mynode") + + @scope = mkscope + @source = mock 'source' + + defined = mkresource("class", :main) + builtin = mkresource("file", "/yay") + + config.add_edge!(defined, builtin) + + bucket = [] + bucket.expects(:classes=).with(config.classes) + defined.stubs(:builtin?).returns(false) + defined.expects(:to_transbucket).returns(bucket) + builtin.expects(:to_transobject).returns(:builtin) + + config.extract_to_transportable.should == [:builtin] + end + + # Now try it with a more complicated graph -- a three tier graph, each tier + it "should transform arbitrarily deep graphs into isomorphic trees" do + config = Puppet::Node::Catalog.new("mynode") + + @scope = mkscope + @scope.stubs(:tags).returns([]) + @source = mock 'source' + + # Create our scopes. + top = mkresource "class", :main + topbucket = [] + topbucket.expects(:classes=).with([]) + top.expects(:to_trans).returns(topbucket) + topres = mkresource "file", "/top" + topres.expects(:to_trans).returns(:topres) + config.add_edge! top, topres + + middle = mkresource "class", "middle" + middle.expects(:to_trans).returns([]) + config.add_edge! top, middle + midres = mkresource "file", "/mid" + midres.expects(:to_trans).returns(:midres) + config.add_edge! middle, midres + + bottom = mkresource "class", "bottom" + bottom.expects(:to_trans).returns([]) + config.add_edge! middle, bottom + botres = mkresource "file", "/bot" + botres.expects(:to_trans).returns(:botres) + config.add_edge! bottom, botres + + toparray = config.extract_to_transportable + + # This is annoying; it should look like: + # [[[:botres], :midres], :topres] + # but we can't guarantee sort order. + toparray.include?(:topres).should be_true + + midarray = toparray.find { |t| t.is_a?(Array) } + midarray.include?(:midres).should be_true + botarray = midarray.find { |t| t.is_a?(Array) } + botarray.include?(:botres).should be_true + end +end + +describe Puppet::Node::Catalog, " when converting to a transobject catalog" do + class TestResource + attr_accessor :name, :virtual, :builtin + def initialize(name, options = {}) + @name = name + options.each { |p,v| send(p.to_s + "=", v) } + end + + def ref + if builtin? + "File[%s]" % name + else + "Class[%s]" % name + end + end + + def virtual? + virtual + end + + def builtin? + builtin + end + + def to_transobject + Puppet::TransObject.new(name, builtin? ? "file" : "class") + end + end + + before do + @original = Puppet::Node::Catalog.new("mynode") + @original.tag(*%w{one two three}) + @original.add_class *%w{four five six} + + @top = TestResource.new 'top' + @topobject = TestResource.new 'topobject', :builtin => true + @virtual = TestResource.new 'virtual', :virtual => true + @virtualobject = TestResource.new 'virtualobject', :builtin => true, :virtual => true + @middle = TestResource.new 'middle' + @middleobject = TestResource.new 'middleobject', :builtin => true + @bottom = TestResource.new 'bottom' + @bottomobject = TestResource.new 'bottomobject', :builtin => true + + @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject] + + @original.add_edge!(@top, @topobject) + @original.add_edge!(@top, @virtual) + @original.add_edge!(@virtual, @virtualobject) + @original.add_edge!(@top, @middle) + @original.add_edge!(@middle, @middleobject) + @original.add_edge!(@middle, @bottom) + @original.add_edge!(@bottom, @bottomobject) + + @config = @original.to_transportable + end + + it "should add all resources as TransObjects" do + @resources.each { |resource| @config.resource(resource.ref).should be_instance_of(Puppet::TransObject) } + end + + it "should not extract defined virtual resources" do + @config.vertices.find { |v| v.name == "virtual" }.should be_nil + end + + it "should not extract builtin virtual resources" do + @config.vertices.find { |v| v.name == "virtualobject" }.should be_nil + end + + it "should copy the tag list to the new catalog" do + @config.tags.sort.should == @original.tags.sort + end + + it "should copy the class list to the new catalog" do + @config.classes.should == @original.classes + end + + it "should duplicate the original edges" do + @original.edges.each do |edge| + next if edge.source.virtual? or edge.target.virtual? + source = @config.resource(edge.source.ref) + target = @config.resource(edge.target.ref) + + source.should_not be_nil + target.should_not be_nil + @config.edge?(source, target).should be_true + end + end + + it "should set itself as the catalog for each converted resource" do + @config.vertices.each { |v| v.catalog.object_id.should equal(@config.object_id) } + end +end + +describe Puppet::Node::Catalog, " when converting to a RAL catalog" do + before do + @original = Puppet::Node::Catalog.new("mynode") + @original.tag(*%w{one two three}) + @original.add_class *%w{four five six} + + @top = Puppet::TransObject.new 'top', "class" + @topobject = Puppet::TransObject.new '/topobject', "file" + @middle = Puppet::TransObject.new 'middle', "class" + @middleobject = Puppet::TransObject.new '/middleobject', "file" + @bottom = Puppet::TransObject.new 'bottom', "class" + @bottomobject = Puppet::TransObject.new '/bottomobject', "file" + + @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject] + + @original.add_resource(*@resources) + + @original.add_edge!(@top, @topobject) + @original.add_edge!(@top, @middle) + @original.add_edge!(@middle, @middleobject) + @original.add_edge!(@middle, @bottom) + @original.add_edge!(@bottom, @bottomobject) + + @config = @original.to_ral + end + + it "should add all resources as RAL instances" do + @resources.each { |resource| @config.resource(resource.ref).should be_instance_of(Puppet::Type) } + end + + it "should copy the tag list to the new catalog" do + @config.tags.sort.should == @original.tags.sort + end + + it "should copy the class list to the new catalog" do + @config.classes.should == @original.classes + end + + it "should duplicate the original edges" do + @original.edges.each do |edge| + @config.edge?(@config.resource(edge.source.ref), @config.resource(edge.target.ref)).should be_true + end + end + + it "should set itself as the catalog for each converted resource" do + @config.vertices.each { |v| v.catalog.object_id.should equal(@config.object_id) } + end + + # This tests #931. + it "should not lose track of resources whose names vary" do + changer = Puppet::TransObject.new 'changer', 'test' + + config = Puppet::Node::Catalog.new('test') + config.add_resource(changer) + config.add_resource(@top) + + config.add_edge!(@top, changer) + + resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :catalog= => nil, :remove => nil + + changer.expects(:to_type).returns(resource) + + newconfig = nil + + Puppet::Type.allclear + + proc { @config = config.to_ral }.should_not raise_error + @config.resource("Test[changer2]").should equal(resource) + end + + after do + # Remove all resource instances. + @config.clear(true) + end +end + +describe Puppet::Node::Catalog, " when functioning as a resource container" do + before do + @config = Puppet::Node::Catalog.new("host") + @one = stub 'resource1', :ref => "Me[one]", :catalog= => nil + @two = stub 'resource2', :ref => "Me[two]", :catalog= => nil + @dupe = stub 'resource3', :ref => "Me[one]", :catalog= => nil + end + + it "should provide a method to add one or more resources" do + @config.add_resource @one, @two + @config.resource(@one.ref).should equal(@one) + @config.resource(@two.ref).should equal(@two) + end + + it "should set itself as the resource's catalog if it is not a relationship graph" do + @one.expects(:catalog=).with(@config) + @config.add_resource @one + end + + it "should not set itself as the resource's catalog if it is a relationship graph" do + @one.expects(:catalog=).never + @config.is_relationship_graph = true + @config.add_resource @one + end + + it "should make all vertices available by resource reference" do + @config.add_resource(@one) + @config.resource(@one.ref).should equal(@one) + @config.vertices.find { |r| r.ref == @one.ref }.should equal(@one) + end + + it "should canonize how resources are referred to during retrieval when both type and title are provided" do + @config.add_resource(@one) + + @config.resource("me", "one").should equal(@one) + end + + it "should canonize how resources are referred to during retrieval when just the title is provided" do + @config.add_resource(@one) + + @config.resource("me[one]", nil).should equal(@one) + end + + it "should not allow two resources with the same resource reference" do + @config.add_resource(@one) + proc { @config.add_resource(@dupe) }.should raise_error(ArgumentError) + end + + it "should not store objects that do not respond to :ref" do + proc { @config.add_resource("thing") }.should raise_error(ArgumentError) + end + + it "should remove all resources when asked" do + @config.add_resource @one + @config.add_resource @two + @one.expects :remove + @two.expects :remove + @config.clear(true) + end + + it "should support a mechanism for finishing resources" do + @one.expects :finish + @two.expects :finish + @config.add_resource @one + @config.add_resource @two + + @config.finalize + end + + it "should optionally support an initialization block and should finalize after such blocks" do + @one.expects :finish + @two.expects :finish + config = Puppet::Node::Catalog.new("host") do |conf| + conf.add_resource @one + conf.add_resource @two + end + end + + it "should inform the resource that it is the resource's catalog" do + @one.expects(:catalog=).with(@config) + @config.add_resource @one + end + + it "should be able to find resources by reference" do + @config.add_resource @one + @config.resource(@one.ref).should equal(@one) + end + + it "should be able to find resources by reference or by type/title tuple" do + @config.add_resource @one + @config.resource("me", "one").should equal(@one) + end + + it "should have a mechanism for removing resources" do + @config.add_resource @one + @one.expects :remove + @config.remove_resource(@one) + @config.resource(@one.ref).should be_nil + @config.vertex?(@one).should be_false + end + + it "should have a method for creating aliases for resources" do + @config.add_resource @one + @config.alias(@one, "other") + @config.resource("me", "other").should equal(@one) + end + + # This test is the same as the previous, but the behaviour should be explicit. + it "should alias using the class name from the resource reference, not the resource class name" do + @config.add_resource @one + @config.alias(@one, "other") + @config.resource("me", "other").should equal(@one) + end + + it "should fail to add an alias if the aliased name already exists" do + @config.add_resource @one + proc { @config.alias @two, "one" }.should raise_error(ArgumentError) + end + + it "should remove resource aliases when the target resource is removed" do + @config.add_resource @one + @config.alias(@one, "other") + @one.expects :remove + @config.remove_resource(@one) + @config.resource("me", "other").should be_nil + end +end + +module ApplyingCatalogs + def setup + @config = Puppet::Node::Catalog.new("host") + + @config.retrieval_duration = Time.now + @transaction = mock 'transaction' + Puppet::Transaction.stubs(:new).returns(@transaction) + @transaction.stubs(:evaluate) + @transaction.stubs(:cleanup) + @transaction.stubs(:addtimes) + end +end + +describe Puppet::Node::Catalog, " when applying" do + include ApplyingCatalogs + + it "should create and evaluate a transaction" do + @transaction.expects(:evaluate) + @config.apply + end + + it "should provide the catalog time to the transaction" do + @transaction.expects(:addtimes).with do |arg| + arg[:config_retrieval].should be_instance_of(Time) + true + end + @config.apply + end + + it "should clean up the transaction" do + @transaction.expects :cleanup + @config.apply + end + + it "should return the transaction" do + @config.apply.should equal(@transaction) + end + + it "should yield the transaction if a block is provided" do + @config.apply do |trans| + trans.should equal(@transaction) + end + end + + it "should default to not being a host catalog" do + @config.host_config.should be_nil + end + + it "should pass supplied tags on to the transaction" do + @transaction.expects(:tags=).with(%w{one two}) + @config.apply(:tags => %w{one two}) + end + + it "should set ignoreschedules on the transaction if specified in apply()" do + @transaction.expects(:ignoreschedules=).with(true) + @config.apply(:ignoreschedules => true) + end +end + +describe Puppet::Node::Catalog, " when applying host catalogs" do + include ApplyingCatalogs + + # super() doesn't work in the setup method for some reason + before do + @config.host_config = true + end + + it "should send a report if reporting is enabled" do + Puppet[:report] = true + @transaction.expects :send_report + @transaction.stubs :any_failed? => false + @config.apply + end + + it "should send a report if report summaries are enabled" do + Puppet[:summarize] = true + @transaction.expects :send_report + @transaction.stubs :any_failed? => false + @config.apply + end + + it "should initialize the state database before applying a catalog" do + Puppet::Util::Storage.expects(:load) + + # Short-circuit the apply, so we know we're loading before the transaction + Puppet::Transaction.expects(:new).raises ArgumentError + proc { @config.apply }.should raise_error(ArgumentError) + end + + it "should sync the state database after applying" do + Puppet::Util::Storage.expects(:store) + @transaction.stubs :any_failed? => false + @config.apply + end + + after { Puppet.settings.clear } +end + +describe Puppet::Node::Catalog, " when applying non-host catalogs" do + include ApplyingCatalogs + + before do + @config.host_config = false + end + + it "should never send reports" do + Puppet[:report] = true + Puppet[:summarize] = true + @transaction.expects(:send_report).never + @config.apply + end + + it "should never modify the state database" do + Puppet::Util::Storage.expects(:load).never + Puppet::Util::Storage.expects(:store).never + @config.apply + end + + after { Puppet.settings.clear } +end + +describe Puppet::Node::Catalog, " when creating a relationship graph" do + before do + @config = Puppet::Node::Catalog.new("host") + @compone = Puppet::Type::Component.create :name => "one" + @comptwo = Puppet::Type::Component.create :name => "two", :require => ["class", "one"] + @file = Puppet::Type.type(:file) + @one = @file.create :path => "/one" + @two = @file.create :path => "/two" + @config.add_edge! @compone, @one + @config.add_edge! @comptwo, @two + + @three = @file.create :path => "/three" + @four = @file.create :path => "/four", :require => ["file", "/three"] + @five = @file.create :path => "/five" + @config.add_resource @compone, @comptwo, @one, @two, @three, @four, @five + @relationships = @config.relationship_graph + end + + it "should fail when trying to create a relationship graph for a relationship graph" do + proc { @relationships.relationship_graph }.should raise_error(Puppet::DevError) + end + + it "should be able to create a relationship graph" do + @relationships.should be_instance_of(Puppet::Node::Catalog) + end + + it "should copy its host_config setting to the relationship graph" do + config = Puppet::Node::Catalog.new + config.host_config = true + config.relationship_graph.host_config.should be_true + end + + it "should not have any components" do + @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil + end + + it "should have all non-component resources from the catalog" do + # The failures print out too much info, so i just do a class comparison + @relationships.vertex?(@five).should be_true + end + + it "should have all resource relationships set as edges" do + @relationships.edge?(@three, @four).should be_true + end + + it "should copy component relationships to all contained resources" do + @relationships.edge?(@one, @two).should be_true + end + + it "should get removed when the catalog is cleaned up" do + @relationships.expects(:clear).with(false) + @config.clear + @config.instance_variable_get("@relationship_graph").should be_nil + end + + it "should create a new relationship graph after clearing the old one" do + @relationships.expects(:clear).with(false) + @config.clear + @config.relationship_graph.should be_instance_of(Puppet::Node::Catalog) + end + + it "should look up resources in the relationship graph if not found in the main catalog" do + five = stub 'five', :ref => "File[five]", :catalog= => nil + @relationships.add_resource five + @config.resource(five.ref).should equal(five) + end + + it "should provide a method to create additional resources that also registers the resource" do + args = {:name => "/yay", :ensure => :file} + resource = stub 'file', :ref => "File[/yay]", :catalog= => @config + Puppet::Type.type(:file).expects(:create).with(args).returns(resource) + @config.create_resource :file, args + @config.resource("File[/yay]").should equal(resource) + end + + it "should provide a mechanism for creating implicit resources" do + args = {:name => "/yay", :ensure => :file} + resource = stub 'file', :ref => "File[/yay]", :catalog= => @config + Puppet::Type.type(:file).expects(:create).with(args).returns(resource) + resource.expects(:implicit=).with(true) + @config.create_implicit_resource :file, args + @config.resource("File[/yay]").should equal(resource) + end + + it "should add implicit resources to the relationship graph if there is one" do + args = {:name => "/yay", :ensure => :file} + resource = stub 'file', :ref => "File[/yay]", :catalog= => @config + resource.expects(:implicit=).with(true) + Puppet::Type.type(:file).expects(:create).with(args).returns(resource) + # build the graph + relgraph = @config.relationship_graph + + @config.create_implicit_resource :file, args + relgraph.resource("File[/yay]").should equal(resource) + end + + it "should remove resources created mid-transaction" do + args = {:name => "/yay", :ensure => :file} + resource = stub 'file', :ref => "File[/yay]", :catalog= => @config + @transaction = mock 'transaction' + Puppet::Transaction.stubs(:new).returns(@transaction) + @transaction.stubs(:evaluate) + @transaction.stubs(:cleanup) + @transaction.stubs(:addtimes) + Puppet::Type.type(:file).expects(:create).with(args).returns(resource) + resource.expects :remove + @config.apply do |trans| + @config.create_resource :file, args + @config.resource("File[/yay]").should equal(resource) + end + @config.resource("File[/yay]").should be_nil + end + + it "should remove resources from the relationship graph if it exists" do + @config.remove_resource(@one) + @config.relationship_graph.vertex?(@one).should be_false + end + + after do + Puppet::Type.allclear + end +end + +describe Puppet::Node::Catalog, " when writing dot files" do + before do + @config = Puppet::Node::Catalog.new("host") + @name = :test + @file = File.join(Puppet[:graphdir], @name.to_s + ".dot") + end + it "should only write when it is a host catalog" do + File.expects(:open).with(@file).never + @config.host_config = false + Puppet[:graph] = true + @config.write_graph(@name) + end + + it "should only write when graphing is enabled" do + File.expects(:open).with(@file).never + @config.host_config = true + Puppet[:graph] = false + @config.write_graph(@name) + end + + it "should write a dot file based on the passed name" do + File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil)) + @config.expects(:to_dot).with("name" => @name.to_s.capitalize) + @config.host_config = true + Puppet[:graph] = true + @config.write_graph(@name) + end + + after do + Puppet.settings.clear + end +end + +describe Puppet::Node::Catalog, " when indirecting" do + before do + @indirection = mock 'indirection' + + Puppet::Indirector::Indirection.clear_cache + end + + it "should redirect to the indirection for retrieval" do + Puppet::Node::Catalog.stubs(:indirection).returns(@indirection) + @indirection.expects(:find).with(:myconfig) + Puppet::Node::Catalog.find(:myconfig) + end + + it "should default to the 'compiler' terminus" do + Puppet::Node::Catalog.indirection.terminus_class.should == :compiler + end + + after do + mocha_verify + Puppet::Indirector::Indirection.clear_cache + end +end + +describe Puppet::Node::Catalog, " when converting to yaml" do + before do + @catalog = Puppet::Node::Catalog.new("me") + @catalog.add_edge!("one", "two") + end + + it "should be able to be dumped to yaml" do + YAML.dump(@catalog).should be_instance_of(String) + end +end + +describe Puppet::Node::Catalog, " when converting from yaml" do + before do + @catalog = Puppet::Node::Catalog.new("me") + @catalog.add_edge!("one", "two") + + text = YAML.dump(@catalog) + @newcatalog = YAML.load(text) + end + + it "should get converted back to a catalog" do + @newcatalog.should be_instance_of(Puppet::Node::Catalog) + end + + it "should have all vertices" do + @newcatalog.vertex?("one").should be_true + @newcatalog.vertex?("two").should be_true + end + + it "should have all edges" do + @newcatalog.edge?("one", "two").should be_true + end +end diff --git a/spec/unit/node/configuration.rb b/spec/unit/node/configuration.rb deleted file mode 100755 index 0023e0f2b..000000000 --- a/spec/unit/node/configuration.rb +++ /dev/null @@ -1,783 +0,0 @@ -#!/usr/bin/env ruby - -require File.dirname(__FILE__) + '/../../spec_helper' - -describe Puppet::Node::Configuration, " when compiling" do - it "should accept tags" do - config = Puppet::Node::Configuration.new("mynode") - config.tag("one") - config.tags.should == %w{one} - end - - it "should accept multiple tags at once" do - config = Puppet::Node::Configuration.new("mynode") - config.tag("one", "two") - config.tags.should == %w{one two} - end - - it "should convert all tags to strings" do - config = Puppet::Node::Configuration.new("mynode") - config.tag("one", :two) - config.tags.should == %w{one two} - end - - it "should tag with both the qualified name and the split name" do - config = Puppet::Node::Configuration.new("mynode") - config.tag("one::two") - config.tags.include?("one").should be_true - config.tags.include?("one::two").should be_true - end - - it "should accept classes" do - config = Puppet::Node::Configuration.new("mynode") - config.add_class("one") - config.classes.should == %w{one} - config.add_class("two", "three") - config.classes.should == %w{one two three} - end - - it "should tag itself with passed class names" do - config = Puppet::Node::Configuration.new("mynode") - config.add_class("one") - config.tags.should == %w{one} - end -end - -describe Puppet::Node::Configuration, " when extracting" do - it "should return extraction result as the method result" do - config = Puppet::Node::Configuration.new("mynode") - config.expects(:extraction_format).returns(:whatever) - config.expects(:extract_to_whatever).returns(:result) - config.extract.should == :result - end -end - -describe Puppet::Node::Configuration, " when extracting transobjects" do - - def mkscope - @parser = Puppet::Parser::Parser.new :Code => "" - @node = Puppet::Node.new("mynode") - @compile = Puppet::Parser::Compile.new(@node, @parser) - - # XXX This is ridiculous. - @compile.send(:evaluate_main) - @scope = @compile.topscope - end - - def mkresource(type, name) - Puppet::Parser::Resource.new(:type => type, :title => name, :source => @source, :scope => @scope) - end - - it "should always create a TransBucket for the 'main' class" do - config = Puppet::Node::Configuration.new("mynode") - - @scope = mkscope - @source = mock 'source' - - main = mkresource("class", :main) - config.add_vertex!(main) - - bucket = mock 'bucket' - bucket.expects(:classes=).with(config.classes) - main.stubs(:builtin?).returns(false) - main.expects(:to_transbucket).returns(bucket) - - config.extract_to_transportable.should equal(bucket) - end - - # This isn't really a spec-style test, but I don't know how better to do it. - it "should transform the resource graph into a tree of TransBuckets and TransObjects" do - config = Puppet::Node::Configuration.new("mynode") - - @scope = mkscope - @source = mock 'source' - - defined = mkresource("class", :main) - builtin = mkresource("file", "/yay") - - config.add_edge!(defined, builtin) - - bucket = [] - bucket.expects(:classes=).with(config.classes) - defined.stubs(:builtin?).returns(false) - defined.expects(:to_transbucket).returns(bucket) - builtin.expects(:to_transobject).returns(:builtin) - - config.extract_to_transportable.should == [:builtin] - end - - # Now try it with a more complicated graph -- a three tier graph, each tier - it "should transform arbitrarily deep graphs into isomorphic trees" do - config = Puppet::Node::Configuration.new("mynode") - - @scope = mkscope - @scope.stubs(:tags).returns([]) - @source = mock 'source' - - # Create our scopes. - top = mkresource "class", :main - topbucket = [] - topbucket.expects(:classes=).with([]) - top.expects(:to_trans).returns(topbucket) - topres = mkresource "file", "/top" - topres.expects(:to_trans).returns(:topres) - config.add_edge! top, topres - - middle = mkresource "class", "middle" - middle.expects(:to_trans).returns([]) - config.add_edge! top, middle - midres = mkresource "file", "/mid" - midres.expects(:to_trans).returns(:midres) - config.add_edge! middle, midres - - bottom = mkresource "class", "bottom" - bottom.expects(:to_trans).returns([]) - config.add_edge! middle, bottom - botres = mkresource "file", "/bot" - botres.expects(:to_trans).returns(:botres) - config.add_edge! bottom, botres - - toparray = config.extract_to_transportable - - # This is annoying; it should look like: - # [[[:botres], :midres], :topres] - # but we can't guarantee sort order. - toparray.include?(:topres).should be_true - - midarray = toparray.find { |t| t.is_a?(Array) } - midarray.include?(:midres).should be_true - botarray = midarray.find { |t| t.is_a?(Array) } - botarray.include?(:botres).should be_true - end -end - -describe Puppet::Node::Configuration, " when converting to a transobject configuration" do - class TestResource - attr_accessor :name, :virtual, :builtin - def initialize(name, options = {}) - @name = name - options.each { |p,v| send(p.to_s + "=", v) } - end - - def ref - if builtin? - "File[%s]" % name - else - "Class[%s]" % name - end - end - - def virtual? - virtual - end - - def builtin? - builtin - end - - def to_transobject - Puppet::TransObject.new(name, builtin? ? "file" : "class") - end - end - - before do - @original = Puppet::Node::Configuration.new("mynode") - @original.tag(*%w{one two three}) - @original.add_class *%w{four five six} - - @top = TestResource.new 'top' - @topobject = TestResource.new 'topobject', :builtin => true - @virtual = TestResource.new 'virtual', :virtual => true - @virtualobject = TestResource.new 'virtualobject', :builtin => true, :virtual => true - @middle = TestResource.new 'middle' - @middleobject = TestResource.new 'middleobject', :builtin => true - @bottom = TestResource.new 'bottom' - @bottomobject = TestResource.new 'bottomobject', :builtin => true - - @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject] - - @original.add_edge!(@top, @topobject) - @original.add_edge!(@top, @virtual) - @original.add_edge!(@virtual, @virtualobject) - @original.add_edge!(@top, @middle) - @original.add_edge!(@middle, @middleobject) - @original.add_edge!(@middle, @bottom) - @original.add_edge!(@bottom, @bottomobject) - - @config = @original.to_transportable - end - - it "should add all resources as TransObjects" do - @resources.each { |resource| @config.resource(resource.ref).should be_instance_of(Puppet::TransObject) } - end - - it "should not extract defined virtual resources" do - @config.vertices.find { |v| v.name == "virtual" }.should be_nil - end - - it "should not extract builtin virtual resources" do - @config.vertices.find { |v| v.name == "virtualobject" }.should be_nil - end - - it "should copy the tag list to the new configuration" do - @config.tags.sort.should == @original.tags.sort - end - - it "should copy the class list to the new configuration" do - @config.classes.should == @original.classes - end - - it "should duplicate the original edges" do - @original.edges.each do |edge| - next if edge.source.virtual? or edge.target.virtual? - source = @config.resource(edge.source.ref) - target = @config.resource(edge.target.ref) - - source.should_not be_nil - target.should_not be_nil - @config.edge?(source, target).should be_true - end - end - - it "should set itself as the configuration for each converted resource" do - @config.vertices.each { |v| v.configuration.object_id.should equal(@config.object_id) } - end -end - -describe Puppet::Node::Configuration, " when converting to a RAL configuration" do - before do - @original = Puppet::Node::Configuration.new("mynode") - @original.tag(*%w{one two three}) - @original.add_class *%w{four five six} - - @top = Puppet::TransObject.new 'top', "class" - @topobject = Puppet::TransObject.new '/topobject', "file" - @middle = Puppet::TransObject.new 'middle', "class" - @middleobject = Puppet::TransObject.new '/middleobject', "file" - @bottom = Puppet::TransObject.new 'bottom', "class" - @bottomobject = Puppet::TransObject.new '/bottomobject', "file" - - @resources = [@top, @topobject, @middle, @middleobject, @bottom, @bottomobject] - - @original.add_resource(*@resources) - - @original.add_edge!(@top, @topobject) - @original.add_edge!(@top, @middle) - @original.add_edge!(@middle, @middleobject) - @original.add_edge!(@middle, @bottom) - @original.add_edge!(@bottom, @bottomobject) - - @config = @original.to_ral - end - - it "should add all resources as RAL instances" do - @resources.each { |resource| @config.resource(resource.ref).should be_instance_of(Puppet::Type) } - end - - it "should copy the tag list to the new configuration" do - @config.tags.sort.should == @original.tags.sort - end - - it "should copy the class list to the new configuration" do - @config.classes.should == @original.classes - end - - it "should duplicate the original edges" do - @original.edges.each do |edge| - @config.edge?(@config.resource(edge.source.ref), @config.resource(edge.target.ref)).should be_true - end - end - - it "should set itself as the configuration for each converted resource" do - @config.vertices.each { |v| v.configuration.object_id.should equal(@config.object_id) } - end - - # This tests #931. - it "should not lose track of resources whose names vary" do - changer = Puppet::TransObject.new 'changer', 'test' - - config = Puppet::Node::Configuration.new('test') - config.add_resource(changer) - config.add_resource(@top) - - config.add_edge!(@top, changer) - - resource = stub 'resource', :name => "changer2", :title => "changer2", :ref => "Test[changer2]", :configuration= => nil, :remove => nil - - changer.expects(:to_type).returns(resource) - - newconfig = nil - - Puppet::Type.allclear - - proc { @config = config.to_ral }.should_not raise_error - @config.resource("Test[changer2]").should equal(resource) - end - - after do - # Remove all resource instances. - @config.clear(true) - end -end - -describe Puppet::Node::Configuration, " when functioning as a resource container" do - before do - @config = Puppet::Node::Configuration.new("host") - @one = stub 'resource1', :ref => "Me[one]", :configuration= => nil - @two = stub 'resource2', :ref => "Me[two]", :configuration= => nil - @dupe = stub 'resource3', :ref => "Me[one]", :configuration= => nil - end - - it "should provide a method to add one or more resources" do - @config.add_resource @one, @two - @config.resource(@one.ref).should equal(@one) - @config.resource(@two.ref).should equal(@two) - end - - it "should set itself as the resource's configuration if it is not a relationship graph" do - @one.expects(:configuration=).with(@config) - @config.add_resource @one - end - - it "should not set itself as the resource's configuration if it is a relationship graph" do - @one.expects(:configuration=).never - @config.is_relationship_graph = true - @config.add_resource @one - end - - it "should make all vertices available by resource reference" do - @config.add_resource(@one) - @config.resource(@one.ref).should equal(@one) - @config.vertices.find { |r| r.ref == @one.ref }.should equal(@one) - end - - it "should canonize how resources are referred to during retrieval when both type and title are provided" do - @config.add_resource(@one) - - @config.resource("me", "one").should equal(@one) - end - - it "should canonize how resources are referred to during retrieval when just the title is provided" do - @config.add_resource(@one) - - @config.resource("me[one]", nil).should equal(@one) - end - - it "should not allow two resources with the same resource reference" do - @config.add_resource(@one) - proc { @config.add_resource(@dupe) }.should raise_error(ArgumentError) - end - - it "should not store objects that do not respond to :ref" do - proc { @config.add_resource("thing") }.should raise_error(ArgumentError) - end - - it "should remove all resources when asked" do - @config.add_resource @one - @config.add_resource @two - @one.expects :remove - @two.expects :remove - @config.clear(true) - end - - it "should support a mechanism for finishing resources" do - @one.expects :finish - @two.expects :finish - @config.add_resource @one - @config.add_resource @two - - @config.finalize - end - - it "should optionally support an initialization block and should finalize after such blocks" do - @one.expects :finish - @two.expects :finish - config = Puppet::Node::Configuration.new("host") do |conf| - conf.add_resource @one - conf.add_resource @two - end - end - - it "should inform the resource that it is the resource's configuration" do - @one.expects(:configuration=).with(@config) - @config.add_resource @one - end - - it "should be able to find resources by reference" do - @config.add_resource @one - @config.resource(@one.ref).should equal(@one) - end - - it "should be able to find resources by reference or by type/title tuple" do - @config.add_resource @one - @config.resource("me", "one").should equal(@one) - end - - it "should have a mechanism for removing resources" do - @config.add_resource @one - @one.expects :remove - @config.remove_resource(@one) - @config.resource(@one.ref).should be_nil - @config.vertex?(@one).should be_false - end - - it "should have a method for creating aliases for resources" do - @config.add_resource @one - @config.alias(@one, "other") - @config.resource("me", "other").should equal(@one) - end - - # This test is the same as the previous, but the behaviour should be explicit. - it "should alias using the class name from the resource reference, not the resource class name" do - @config.add_resource @one - @config.alias(@one, "other") - @config.resource("me", "other").should equal(@one) - end - - it "should fail to add an alias if the aliased name already exists" do - @config.add_resource @one - proc { @config.alias @two, "one" }.should raise_error(ArgumentError) - end - - it "should remove resource aliases when the target resource is removed" do - @config.add_resource @one - @config.alias(@one, "other") - @one.expects :remove - @config.remove_resource(@one) - @config.resource("me", "other").should be_nil - end -end - -module ApplyingConfigurations - def setup - @config = Puppet::Node::Configuration.new("host") - - @config.retrieval_duration = Time.now - @transaction = mock 'transaction' - Puppet::Transaction.stubs(:new).returns(@transaction) - @transaction.stubs(:evaluate) - @transaction.stubs(:cleanup) - @transaction.stubs(:addtimes) - end -end - -describe Puppet::Node::Configuration, " when applying" do - include ApplyingConfigurations - - it "should create and evaluate a transaction" do - @transaction.expects(:evaluate) - @config.apply - end - - it "should provide the configuration time to the transaction" do - @transaction.expects(:addtimes).with do |arg| - arg[:config_retrieval].should be_instance_of(Time) - true - end - @config.apply - end - - it "should clean up the transaction" do - @transaction.expects :cleanup - @config.apply - end - - it "should return the transaction" do - @config.apply.should equal(@transaction) - end - - it "should yield the transaction if a block is provided" do - @config.apply do |trans| - trans.should equal(@transaction) - end - end - - it "should default to not being a host configuration" do - @config.host_config.should be_nil - end - - it "should pass supplied tags on to the transaction" do - @transaction.expects(:tags=).with(%w{one two}) - @config.apply(:tags => %w{one two}) - end - - it "should set ignoreschedules on the transaction if specified in apply()" do - @transaction.expects(:ignoreschedules=).with(true) - @config.apply(:ignoreschedules => true) - end -end - -describe Puppet::Node::Configuration, " when applying host configurations" do - include ApplyingConfigurations - - # super() doesn't work in the setup method for some reason - before do - @config.host_config = true - end - - it "should send a report if reporting is enabled" do - Puppet[:report] = true - @transaction.expects :send_report - @transaction.stubs :any_failed? => false - @config.apply - end - - it "should send a report if report summaries are enabled" do - Puppet[:summarize] = true - @transaction.expects :send_report - @transaction.stubs :any_failed? => false - @config.apply - end - - it "should initialize the state database before applying a configuration" do - Puppet::Util::Storage.expects(:load) - - # Short-circuit the apply, so we know we're loading before the transaction - Puppet::Transaction.expects(:new).raises ArgumentError - proc { @config.apply }.should raise_error(ArgumentError) - end - - it "should sync the state database after applying" do - Puppet::Util::Storage.expects(:store) - @transaction.stubs :any_failed? => false - @config.apply - end - - after { Puppet.settings.clear } -end - -describe Puppet::Node::Configuration, " when applying non-host configurations" do - include ApplyingConfigurations - - before do - @config.host_config = false - end - - it "should never send reports" do - Puppet[:report] = true - Puppet[:summarize] = true - @transaction.expects(:send_report).never - @config.apply - end - - it "should never modify the state database" do - Puppet::Util::Storage.expects(:load).never - Puppet::Util::Storage.expects(:store).never - @config.apply - end - - after { Puppet.settings.clear } -end - -describe Puppet::Node::Configuration, " when creating a relationship graph" do - before do - @config = Puppet::Node::Configuration.new("host") - @compone = Puppet::Type::Component.create :name => "one" - @comptwo = Puppet::Type::Component.create :name => "two", :require => ["class", "one"] - @file = Puppet::Type.type(:file) - @one = @file.create :path => "/one" - @two = @file.create :path => "/two" - @config.add_edge! @compone, @one - @config.add_edge! @comptwo, @two - - @three = @file.create :path => "/three" - @four = @file.create :path => "/four", :require => ["file", "/three"] - @five = @file.create :path => "/five" - @config.add_resource @compone, @comptwo, @one, @two, @three, @four, @five - @relationships = @config.relationship_graph - end - - it "should fail when trying to create a relationship graph for a relationship graph" do - proc { @relationships.relationship_graph }.should raise_error(Puppet::DevError) - end - - it "should be able to create a relationship graph" do - @relationships.should be_instance_of(Puppet::Node::Configuration) - end - - it "should copy its host_config setting to the relationship graph" do - config = Puppet::Node::Configuration.new - config.host_config = true - config.relationship_graph.host_config.should be_true - end - - it "should not have any components" do - @relationships.vertices.find { |r| r.instance_of?(Puppet::Type::Component) }.should be_nil - end - - it "should have all non-component resources from the configuration" do - # The failures print out too much info, so i just do a class comparison - @relationships.vertex?(@five).should be_true - end - - it "should have all resource relationships set as edges" do - @relationships.edge?(@three, @four).should be_true - end - - it "should copy component relationships to all contained resources" do - @relationships.edge?(@one, @two).should be_true - end - - it "should get removed when the configuration is cleaned up" do - @relationships.expects(:clear).with(false) - @config.clear - @config.instance_variable_get("@relationship_graph").should be_nil - end - - it "should create a new relationship graph after clearing the old one" do - @relationships.expects(:clear).with(false) - @config.clear - @config.relationship_graph.should be_instance_of(Puppet::Node::Configuration) - end - - it "should look up resources in the relationship graph if not found in the main configuration" do - five = stub 'five', :ref => "File[five]", :configuration= => nil - @relationships.add_resource five - @config.resource(five.ref).should equal(five) - end - - it "should provide a method to create additional resources that also registers the resource" do - args = {:name => "/yay", :ensure => :file} - resource = stub 'file', :ref => "File[/yay]", :configuration= => @config - Puppet::Type.type(:file).expects(:create).with(args).returns(resource) - @config.create_resource :file, args - @config.resource("File[/yay]").should equal(resource) - end - - it "should provide a mechanism for creating implicit resources" do - args = {:name => "/yay", :ensure => :file} - resource = stub 'file', :ref => "File[/yay]", :configuration= => @config - Puppet::Type.type(:file).expects(:create).with(args).returns(resource) - resource.expects(:implicit=).with(true) - @config.create_implicit_resource :file, args - @config.resource("File[/yay]").should equal(resource) - end - - it "should add implicit resources to the relationship graph if there is one" do - args = {:name => "/yay", :ensure => :file} - resource = stub 'file', :ref => "File[/yay]", :configuration= => @config - resource.expects(:implicit=).with(true) - Puppet::Type.type(:file).expects(:create).with(args).returns(resource) - # build the graph - relgraph = @config.relationship_graph - - @config.create_implicit_resource :file, args - relgraph.resource("File[/yay]").should equal(resource) - end - - it "should remove resources created mid-transaction" do - args = {:name => "/yay", :ensure => :file} - resource = stub 'file', :ref => "File[/yay]", :configuration= => @config - @transaction = mock 'transaction' - Puppet::Transaction.stubs(:new).returns(@transaction) - @transaction.stubs(:evaluate) - @transaction.stubs(:cleanup) - @transaction.stubs(:addtimes) - Puppet::Type.type(:file).expects(:create).with(args).returns(resource) - resource.expects :remove - @config.apply do |trans| - @config.create_resource :file, args - @config.resource("File[/yay]").should equal(resource) - end - @config.resource("File[/yay]").should be_nil - end - - it "should remove resources from the relationship graph if it exists" do - @config.remove_resource(@one) - @config.relationship_graph.vertex?(@one).should be_false - end - - after do - Puppet::Type.allclear - end -end - -describe Puppet::Node::Configuration, " when writing dot files" do - before do - @config = Puppet::Node::Configuration.new("host") - @name = :test - @file = File.join(Puppet[:graphdir], @name.to_s + ".dot") - end - it "should only write when it is a host configuration" do - File.expects(:open).with(@file).never - @config.host_config = false - Puppet[:graph] = true - @config.write_graph(@name) - end - - it "should only write when graphing is enabled" do - File.expects(:open).with(@file).never - @config.host_config = true - Puppet[:graph] = false - @config.write_graph(@name) - end - - it "should write a dot file based on the passed name" do - File.expects(:open).with(@file, "w").yields(stub("file", :puts => nil)) - @config.expects(:to_dot).with("name" => @name.to_s.capitalize) - @config.host_config = true - Puppet[:graph] = true - @config.write_graph(@name) - end - - after do - Puppet.settings.clear - end -end - -describe Puppet::Node::Configuration, " when indirecting" do - before do - @indirection = mock 'indirection' - - Puppet::Indirector::Indirection.clear_cache - end - - it "should redirect to the indirection for retrieval" do - Puppet::Node::Configuration.stubs(:indirection).returns(@indirection) - @indirection.expects(:find).with(:myconfig) - Puppet::Node::Configuration.find(:myconfig) - end - - it "should default to the 'compiler' terminus" do - Puppet::Node::Configuration.indirection.terminus_class.should == :compiler - end - - after do - mocha_verify - Puppet::Indirector::Indirection.clear_cache - end -end - -describe Puppet::Node::Configuration, " when converting to yaml" do - before do - @configuration = Puppet::Node::Configuration.new("me") - @configuration.add_edge!("one", "two") - end - - it "should be able to be dumped to yaml" do - YAML.dump(@configuration).should be_instance_of(String) - end -end - -describe Puppet::Node::Configuration, " when converting from yaml" do - before do - @configuration = Puppet::Node::Configuration.new("me") - @configuration.add_edge!("one", "two") - - text = YAML.dump(@configuration) - @newconfig = YAML.load(text) - end - - it "should get converted back to a configuration" do - @newconfig.should be_instance_of(Puppet::Node::Configuration) - end - - it "should have all vertices" do - @newconfig.vertex?("one").should be_true - @newconfig.vertex?("two").should be_true - end - - it "should have all edges" do - @newconfig.edge?("one", "two").should be_true - end -end diff --git a/spec/unit/other/transaction.rb b/spec/unit/other/transaction.rb index 7990d2eef..d88f03005 100755 --- a/spec/unit/other/transaction.rb +++ b/spec/unit/other/transaction.rb @@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/../../spec_helper' describe Puppet::Transaction, " when determining tags" do before do - @config = Puppet::Node::Configuration.new + @config = Puppet::Node::Catalog.new @transaction = Puppet::Transaction.new(@config) end diff --git a/spec/unit/other/transbucket.rb b/spec/unit/other/transbucket.rb index 84cf93fa4..3904e39fe 100755 --- a/spec/unit/other/transbucket.rb +++ b/spec/unit/other/transbucket.rb @@ -65,7 +65,7 @@ describe Puppet::TransBucket do end end -describe Puppet::TransBucket, " when generating a configuration" do +describe Puppet::TransBucket, " when generating a catalog" do before do @bottom = Puppet::TransBucket.new @bottom.type = "fake" @@ -87,7 +87,7 @@ describe Puppet::TransBucket, " when generating a configuration" do @top.push(@topobj) @top.push(@middle) - @config = @top.to_configuration + @config = @top.to_catalog @users = %w{top middle bottom} @fakes = %w{Fake[bottom] Fake[middle] Fake[top]} @@ -117,21 +117,21 @@ describe Puppet::TransBucket, " when generating a configuration" do @topobj.expects(:to_type) @bottomobj.expects(:to_type) Puppet::Type.allclear - @top.to_configuration + @top.to_catalog end - it "should set each TransObject's configuration before converting to a RAL resource" do - @middleobj.expects(:configuration=).with { |c| c.is_a?(Puppet::Node::Configuration) } + it "should set each TransObject's catalog before converting to a RAL resource" do + @middleobj.expects(:catalog=).with { |c| c.is_a?(Puppet::Node::Catalog) } Puppet::Type.allclear - @top.to_configuration + @top.to_catalog end - it "should set each TransBucket's configuration before converting to a RAL resource" do + it "should set each TransBucket's catalog before converting to a RAL resource" do # each bucket is seen twice in the loop, so we have to handle the case where the config # is set twice - @bottom.expects(:configuration=).with { |c| c.is_a?(Puppet::Node::Configuration) }.at_least_once + @bottom.expects(:catalog=).with { |c| c.is_a?(Puppet::Node::Catalog) }.at_least_once Puppet::Type.allclear - @top.to_configuration + @top.to_catalog end after do diff --git a/spec/unit/parser/compile.rb b/spec/unit/parser/compile.rb index 3be7d1637..2ae99b5fd 100755 --- a/spec/unit/parser/compile.rb +++ b/spec/unit/parser/compile.rb @@ -64,8 +64,8 @@ describe Puppet::Parser::Compile, " when evaluating classes" do proc { @compile.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError) end - it "should tag the configuration with the name of each not-found class" do - @compile.configuration.expects(:tag).with("notfound") + it "should tag the catalog with the name of each not-found class" do + @compile.catalog.expects(:tag).with("notfound") @scope.expects(:findclass).with("notfound").returns(nil) @compile.evaluate_classes(%w{notfound}, @scope) end @@ -110,7 +110,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do end it "should create a resource for each found class" do - @compile.configuration.stubs(:tag) + @compile.catalog.stubs(:tag) @compile.stubs :store_resource @@ -119,7 +119,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do end it "should store each created resource in the compile" do - @compile.configuration.stubs(:tag) + @compile.catalog.stubs(:tag) @compile.expects(:store_resource).with(@scope, @resource) @@ -127,8 +127,8 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do @compile.evaluate_classes(%w{myclass}, @scope) end - it "should tag the configuration with the fully-qualified name of each found class" do - @compile.configuration.expects(:tag).with("my::class") + it "should tag the catalog with the fully-qualified name of each found class" do + @compile.catalog.expects(:tag).with("my::class") @compile.stubs(:store_resource) @@ -137,7 +137,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do end it "should not evaluate the resources created for found classes unless asked" do - @compile.configuration.stubs(:tag) + @compile.catalog.stubs(:tag) @compile.stubs(:store_resource) @resource.expects(:evaluate).never @@ -147,7 +147,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do end it "should immediately evaluate the resources created for found classes when asked" do - @compile.configuration.stubs(:tag) + @compile.catalog.stubs(:tag) @compile.stubs(:store_resource) @resource.expects(:evaluate) @@ -157,7 +157,7 @@ describe Puppet::Parser::Compile, " when evaluating found classes" do end it "should return the list of found classes" do - @compile.configuration.stubs(:tag) + @compile.catalog.stubs(:tag) @compile.stubs(:store_resource) @scope.stubs(:findclass).with("notfound").returns(nil) @@ -227,14 +227,14 @@ describe Puppet::Parser::Compile, " when evaluating AST nodes with AST nodes pre @compile.send(:evaluate_ast_node) end - it "should tag the configuration with the found node name" do + it "should tag the catalog with the found node name" do node_class = stub 'node', :classname => "c" @nodes.stubs(:[]).with("c").returns(node_class) node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil Puppet::Parser::Resource.stubs(:new).returns(node_resource) - @compile.configuration.expects(:tag).with("c") + @compile.catalog.expects(:tag).with("c") @compile.send(:evaluate_ast_node) end diff --git a/spec/unit/parser/interpreter.rb b/spec/unit/parser/interpreter.rb index 782b30cc7..ed30ced93 100755 --- a/spec/unit/parser/interpreter.rb +++ b/spec/unit/parser/interpreter.rb @@ -111,7 +111,7 @@ describe Puppet::Parser::Interpreter, " when managing parser instances" do end end -describe Puppet::Parser::Interpreter, " when compiling configurations" do +describe Puppet::Parser::Interpreter, " when compiling catalog" do before do @interp = Puppet::Parser::Interpreter.new @node = stub 'node', :environment => :myenv @@ -132,12 +132,12 @@ describe Puppet::Parser::Interpreter, " when compiling configurations" do end end -describe Puppet::Parser::Interpreter, " when returning configuration version" do +describe Puppet::Parser::Interpreter, " when returning catalog version" do before do @interp = Puppet::Parser::Interpreter.new end - it "should ask the appropriate parser for the configuration version" do + it "should ask the appropriate parser for the catalog version" do node = mock 'node' node.expects(:environment).returns(:myenv) parser = mock 'parser' diff --git a/spec/unit/ral/type.rb b/spec/unit/ral/type.rb index 60b99eeb8..25f8cbaf1 100755 --- a/spec/unit/ral/type.rb +++ b/spec/unit/ral/type.rb @@ -4,15 +4,15 @@ require File.dirname(__FILE__) + '/../../spec_helper' describe Puppet::Type, " when in a configuration" do before do - @configuration = Puppet::Node::Configuration.new + @catalog = Puppet::Node::Catalog.new @container = Puppet::Type.type(:component).create(:name => "container") @one = Puppet::Type.type(:file).create(:path => "/file/one") @two = Puppet::Type.type(:file).create(:path => "/file/two") - @configuration.add_resource @container - @configuration.add_resource @one - @configuration.add_resource @two - @configuration.add_edge! @container, @one - @configuration.add_edge! @container, @two + @catalog.add_resource @container + @catalog.add_resource @one + @catalog.add_resource @two + @catalog.add_edge! @container, @one + @catalog.add_edge! @container, @two end it "should have no parent if there is no in edge" do @@ -24,6 +24,6 @@ describe Puppet::Type, " when in a configuration" do end after do - @configuration.clear(true) + @catalog.clear(true) end end diff --git a/spec/unit/ral/types/package.rb b/spec/unit/ral/types/package.rb index fd200c56f..f14a792b9 100755 --- a/spec/unit/ral/types/package.rb +++ b/spec/unit/ral/types/package.rb @@ -107,8 +107,8 @@ module PackageEvaluationTesting Puppet::Type::Package.defaultprovider.stubs(:new).returns(@provider) @package = Puppet::Type::Package.create(:name => "yay") - @configuration = Puppet::Node::Configuration.new - @configuration.add_resource(@package) + @catalog = Puppet::Node::Catalog.new + @catalog.add_resource(@package) end def setprops(properties) @@ -116,7 +116,7 @@ module PackageEvaluationTesting end def teardown - @configuration.clear(true) + @catalog.clear(true) Puppet::Type::Package.clear end end @@ -128,14 +128,14 @@ describe Puppet::Type::Package, "when it should be purged" do it "should do nothing if it is :purged" do @provider.expects(:properties).returns(:ensure => :purged) - @configuration.apply + @catalog.apply end [:absent, :installed, :present, :latest].each do |state| it "should purge if it is #{state.to_s}" do @provider.stubs(:properties).returns(:ensure => state) @provider.expects(:purge) - @configuration.apply + @catalog.apply end end end @@ -148,7 +148,7 @@ describe Puppet::Type::Package, "when it should be absent" do [:purged, :absent].each do |state| it "should do nothing if it is #{state.to_s}" do @provider.expects(:properties).returns(:ensure => state) - @configuration.apply + @catalog.apply end end @@ -156,7 +156,7 @@ describe Puppet::Type::Package, "when it should be absent" do it "should uninstall if it is #{state.to_s}" do @provider.stubs(:properties).returns(:ensure => state) @provider.expects(:uninstall) - @configuration.apply + @catalog.apply end end end @@ -169,7 +169,7 @@ describe Puppet::Type::Package, "when it should be present" do [:present, :latest, "1.0"].each do |state| it "should do nothing if it is #{state.to_s}" do @provider.expects(:properties).returns(:ensure => state) - @configuration.apply + @catalog.apply end end @@ -177,7 +177,7 @@ describe Puppet::Type::Package, "when it should be present" do it "should install if it is #{state.to_s}" do @provider.stubs(:properties).returns(:ensure => state) @provider.expects(:install) - @configuration.apply + @catalog.apply end end end @@ -191,7 +191,7 @@ describe Puppet::Type::Package, "when it should be latest" do it "should upgrade if it is #{state.to_s}" do @provider.stubs(:properties).returns(:ensure => state) @provider.expects(:update) - @configuration.apply + @catalog.apply end end @@ -199,21 +199,21 @@ describe Puppet::Type::Package, "when it should be latest" do @provider.stubs(:properties).returns(:ensure => "1.0") @provider.stubs(:latest).returns("2.0") @provider.expects(:update) - @configuration.apply + @catalog.apply end it "should do nothing if it is equal to the latest version" do @provider.stubs(:properties).returns(:ensure => "1.0") @provider.stubs(:latest).returns("1.0") @provider.expects(:update).never - @configuration.apply + @catalog.apply end it "should do nothing if the provider returns :present as the latest version" do @provider.stubs(:properties).returns(:ensure => :present) @provider.stubs(:latest).returns("1.0") @provider.expects(:update).never - @configuration.apply + @catalog.apply end end @@ -226,19 +226,19 @@ describe Puppet::Type::Package, "when it should be a specific version" do it "should install if it is #{state.to_s}" do @provider.stubs(:properties).returns(:ensure => state) @provider.expects(:install) - @configuration.apply + @catalog.apply end end it "should do nothing if the current version is equal to the desired version" do @provider.stubs(:properties).returns(:ensure => "1.0") @provider.expects(:install).never - @configuration.apply + @catalog.apply end it "should install if the current version is not equal to the specified version" do @provider.stubs(:properties).returns(:ensure => "2.0") @provider.expects(:install) - @configuration.apply + @catalog.apply end end diff --git a/spec/unit/resource_reference.rb b/spec/unit/resource_reference.rb index 93eeaa5b8..ef172d80a 100755 --- a/spec/unit/resource_reference.rb +++ b/spec/unit/resource_reference.rb @@ -42,7 +42,7 @@ describe Puppet::ResourceReference do end end -describe Puppet::ResourceReference, "when resolving resources without a configuration" do +describe Puppet::ResourceReference, "when resolving resources without a catalog" do it "should be able to resolve builtin resources from their types" do Puppet::Type.type(:file).expects(:[]).with("myfile").returns(:myfile) Puppet::ResourceReference.new(:file, "myfile").resolve.should == :myfile @@ -54,11 +54,11 @@ describe Puppet::ResourceReference, "when resolving resources without a configur end end -describe Puppet::ResourceReference, "when resolving resources with a configuration" do - it "should resolve all resources using the configuration" do - config = mock 'configuration' +describe Puppet::ResourceReference, "when resolving resources with a catalog" do + it "should resolve all resources using the catalog" do + config = mock 'catalog' ref = Puppet::ResourceReference.new("foo::bar", "yay") - ref.configuration = config + ref.catalog = config config.expects(:resource).with("Foo::Bar[yay]").returns(:myresource) diff --git a/spec/unit/util/settings.rb b/spec/unit/util/settings.rb index 5a0333798..540743d7e 100755 --- a/spec/unit/util/settings.rb +++ b/spec/unit/util/settings.rb @@ -485,7 +485,7 @@ describe Puppet::Util::Settings, " when being used to manage the host machine" d @trans = mock 'transaction' @settings.expects(:to_transportable).with(:whatever).returns(@bucket) - @bucket.expects(:to_configuration).returns(@config) + @bucket.expects(:to_catalog).returns(@config) @config.expects(:apply).yields(@trans) @config.stubs(:host_config=) end diff --git a/test/language/ast/hostclass.rb b/test/language/ast/hostclass.rb index 62d4f9ee3..80032f30c 100755 --- a/test/language/ast/hostclass.rb +++ b/test/language/ast/hostclass.rb @@ -175,7 +175,7 @@ class TestASTHostClass < Test::Unit::TestCase sub = parser.newclass "sub", :parent => "base" base.expects(:safeevaluate).with do |args| - assert(scope.compile.configuration.tags.include?("sub"), "Did not tag with sub class name before evaluating base class") + assert(scope.compile.catalog.tags.include?("sub"), "Did not tag with sub class name before evaluating base class") base.evaluate(args) true end diff --git a/test/language/compile.rb b/test/language/compile.rb index 50b16a24d..298493c0a 100755 --- a/test/language/compile.rb +++ b/test/language/compile.rb @@ -74,7 +74,7 @@ class TestCompile < Test::Unit::TestCase klass.expects(:classname).returns("myname") compile = mkcompile - compile.configuration.expects(:tag).with("myname") + compile.catalog.expects(:tag).with("myname") assert_nothing_raised("Could not set class") do compile.class_set "myname", "myscope" @@ -153,7 +153,7 @@ class TestCompile < Test::Unit::TestCase [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated, :finish].each do |method| compile.expects(method) end - assert_instance_of(Puppet::Node::Configuration, compile.compile, "Did not return the configuration") + assert_instance_of(Puppet::Node::Catalog, compile.compile, "Did not return the catalog") end # Test setting the node's parameters into the top scope. @@ -416,7 +416,7 @@ class TestCompile < Test::Unit::TestCase compile.expects(:verify_uniqueness).with(resource) scope = stub("scope", :resource => mock('resource')) - compile.configuration.expects(:add_edge!).with(scope.resource, resource) + compile.catalog.expects(:add_edge!).with(scope.resource, resource) assert_nothing_raised("Could not store resource") do compile.store_resource(scope, resource) diff --git a/test/language/functions.rb b/test/language/functions.rb index 70dd6af7b..132ee97ac 100755 --- a/test/language/functions.rb +++ b/test/language/functions.rb @@ -66,8 +66,8 @@ class TestLangFunctions < Test::Unit::TestCase # Now make sure we correctly get tags. scope.resource.tag("resourcetag") assert(scope.function_tagged("resourcetag"), "tagged function did not catch resource tags") - scope.compile.configuration.tag("configtag") - assert(scope.function_tagged("configtag"), "tagged function did not catch configuration tags") + scope.compile.catalog.tag("configtag") + assert(scope.function_tagged("configtag"), "tagged function did not catch catalog tags") end def test_failfunction @@ -212,15 +212,15 @@ class TestLangFunctions < Test::Unit::TestCase Puppet[:environment] = "yay" - configuration = nil + catalog = nil assert_nothing_raised { - configuration = interp.compile(node) + catalog = interp.compile(node) } - version = configuration.version + version = catalog.version - fileobj = configuration.vertices.find { |r| r.title == file } - assert(fileobj, "File was not in configuration") + fileobj = catalog.vertices.find { |r| r.title == file } + assert(fileobj, "File was not in catalog") assert_equal("original text\n", fileobj["content"], "Template did not work") diff --git a/test/language/snippets.rb b/test/language/snippets.rb index 0806a40b4..2a4ba0220 100755 --- a/test/language/snippets.rb +++ b/test/language/snippets.rb @@ -197,7 +197,7 @@ class TestSnippets < Test::Unit::TestCase def snippet_classpathtest path = "/tmp/classtest" - file = @configuration.resource(:file, path) + file = @catalog.resource(:file, path) assert(file, "did not create file %s" % path) assert_nothing_raised { @@ -460,13 +460,13 @@ class TestSnippets < Test::Unit::TestCase node = Puppet::Node.new("testhost") node.merge(facts) - config = nil - assert_nothing_raised("Could not compile configuration") { - config = Puppet::Node::Configuration.find(node) + catalog = nil + assert_nothing_raised("Could not compile catalog") { + catalog = Puppet::Node::Catalog.find(node) } - assert_nothing_raised("Could not convert configuration") { - config = config.to_ral + assert_nothing_raised("Could not convert catalog") { + catalog = catalog.to_ral } Puppet::Type.eachtype { |type| @@ -479,7 +479,7 @@ class TestSnippets < Test::Unit::TestCase assert(obj.name) } } - @configuration = config + @catalog = catalog assert_nothing_raised { self.send(mname) } diff --git a/test/lib/puppettest/parsertesting.rb b/test/lib/puppettest/parsertesting.rb index 3e3ce6cb9..6fd60180a 100644 --- a/test/lib/puppettest/parsertesting.rb +++ b/test/lib/puppettest/parsertesting.rb @@ -312,7 +312,7 @@ module PuppetTest::ParserTesting config = nil assert_nothing_raised { - config = trans.extract.to_configuration + config = trans.extract.to_catalog } config.apply diff --git a/test/lib/puppettest/support/assertions.rb b/test/lib/puppettest/support/assertions.rb index 906bb3c76..2159c8d3e 100644 --- a/test/lib/puppettest/support/assertions.rb +++ b/test/lib/puppettest/support/assertions.rb @@ -52,7 +52,7 @@ module PuppetTest msg = resources.pop end - config = resources2config(*resources) + config = resources2catalog(*resources) transaction = Puppet::Transaction.new(config) run_events(:evaluate, transaction, events, msg) @@ -62,7 +62,7 @@ module PuppetTest # A simpler method that just applies what we have. def assert_apply(*resources) - config = resources2config(*resources) + config = resources2catalog(*resources) events = nil assert_nothing_raised("Failed to evaluate") { diff --git a/test/lib/puppettest/support/resources.rb b/test/lib/puppettest/support/resources.rb index 18d7caa77..384f61c33 100755 --- a/test/lib/puppettest/support/resources.rb +++ b/test/lib/puppettest/support/resources.rb @@ -25,13 +25,13 @@ module PuppetTest::Support::Resources end def mktree - configuration = Puppet::Node::Configuration.new do |config| + catalog = Puppet::Node::Catalog.new do |config| one = treenode(config, "one", "a", "b") two = treenode(config, "two", "c", "d") middle = treenode(config, "middle", "e", "f", two) top = treenode(config, "top", "g", "h", middle, one) end - return configuration + return catalog end end diff --git a/test/lib/puppettest/support/utils.rb b/test/lib/puppettest/support/utils.rb index d9bd6b2b6..cb4a6924c 100644 --- a/test/lib/puppettest/support/utils.rb +++ b/test/lib/puppettest/support/utils.rb @@ -21,10 +21,10 @@ module PuppetTest::Support::Utils } end - # Turn a list of resources, or possibly a configuration and some resources, - # into a configuration object. - def resources2config(*resources) - if resources[0].is_a?(Puppet::Node::Configuration) + # Turn a list of resources, or possibly a catalog and some resources, + # into a catalog object. + def resources2catalog(*resources) + if resources[0].is_a?(Puppet::Node::Catalog) config = resources.shift unless resources.empty? resources.each { |r| config.add_resource r } @@ -34,7 +34,7 @@ module PuppetTest::Support::Utils comp = resources.shift comp.delve else - config = Puppet::Node::Configuration.new + config = Puppet::Node::Catalog.new resources.each { |res| config.add_resource res } end return config @@ -159,13 +159,13 @@ module PuppetTest::Support::Utils } end - def mk_configuration(*resources) + def mk_catalog(*resources) if resources[0].is_a?(String) name = resources.shift else name = :testing end - config = Puppet::Node::Configuration.new :testing do |conf| + config = Puppet::Node::Catalog.new :testing do |conf| resources.each { |resource| conf.add_resource resource } end diff --git a/test/network/client/client.rb b/test/network/client/client.rb index 918b9e86a..2588b9be5 100755 --- a/test/network/client/client.rb +++ b/test/network/client/client.rb @@ -46,13 +46,13 @@ class TestClient < Test::Unit::TestCase assert(File.exists?(certfile)) assert(File.exists?(publickeyfile)) - # verify we can retrieve the configuration - assert_nothing_raised("Client could not retrieve configuration") { + # verify we can retrieve the catalog + assert_nothing_raised("Client could not retrieve catalog") { client.getconfig } # and apply it - assert_nothing_raised("Client could not apply configuration") { + assert_nothing_raised("Client could not apply catalog") { client.apply } diff --git a/test/network/client/master.rb b/test/network/client/master.rb index 84cd9388c..60058aed9 100755 --- a/test/network/client/master.rb +++ b/test/network/client/master.rb @@ -558,12 +558,12 @@ end ftype = Puppet::Type.type(:file) file = ftype.create :title => "/what/ever", :ensure => :present - config = Puppet::Node::Configuration.new + config = Puppet::Node::Catalog.new config.add_resource(file) config.expects :apply - client.configuration = config + client.catalog = config client.expects(:getconfig) client.run @@ -581,7 +581,7 @@ end end end - def test_invalid_configurations_do_not_get_cached + def test_invalid_catalogs_do_not_get_cached master = mkmaster :Code => "notify { one: require => File[yaytest] }" master.local = false # so it gets cached client = mkclient(master) diff --git a/test/other/events.rb b/test/other/events.rb index 2dfdfeb74..9d6bd2bb7 100755 --- a/test/other/events.rb +++ b/test/other/events.rb @@ -22,7 +22,7 @@ class TestEvents < Test::Unit::TestCase :subscribe => [[file.class.name, file.name]] ) - comp = mk_configuration("eventtesting", file, exec) + comp = mk_catalog("eventtesting", file, exec) trans = assert_events([:file_created, :triggered], comp) @@ -43,7 +43,7 @@ class TestEvents < Test::Unit::TestCase ) - config = mk_configuration + config = mk_catalog config.add_resource file config.add_resource exec trans = config.apply @@ -74,7 +74,7 @@ class TestEvents < Test::Unit::TestCase ["file", f.name] } - comp = mk_configuration(exec, *files) + comp = mk_catalog(exec, *files) assert_apply(comp) assert(FileTest.exists?(fname), "Exec file did not get created") @@ -106,7 +106,7 @@ class TestEvents < Test::Unit::TestCase ) execs = [exec1, exec2, exec3] - config = mk_configuration(exec1,exec2,exec3) + config = mk_catalog(exec1,exec2,exec3) trans = Puppet::Transaction.new(config) execs.each do |e| assert(config.vertex?(e), "%s is not in graph" % e.title) end diff --git a/test/other/overrides.rb b/test/other/overrides.rb index 272f78e30..e0e3fdf5f 100755 --- a/test/other/overrides.rb +++ b/test/other/overrides.rb @@ -90,7 +90,7 @@ class TestOverrides < Test::Unit::TestCase } } - config = mk_configuration(baseobj, *children) + config = mk_catalog(baseobj, *children) assert_nothing_raised("Could not eval component") { config.apply diff --git a/test/other/relationships.rb b/test/other/relationships.rb index 0f2a103fe..bf83caf4a 100755 --- a/test/other/relationships.rb +++ b/test/other/relationships.rb @@ -176,7 +176,7 @@ class TestRelationships < Test::Unit::TestCase # Now make sure that these relationships are added to the # relationship graph - config = mk_configuration(file, exec) + config = mk_catalog(file, exec) config.apply do |trans| assert(config.relationship_graph.edge?(file, exec), "autorequire edge was not created") end diff --git a/test/other/report.rb b/test/other/report.rb index 1ccb44546..9894e2a8d 100755 --- a/test/other/report.rb +++ b/test/other/report.rb @@ -27,7 +27,7 @@ class TestReports < Test::Unit::TestCase ) end - config = mk_configuration(*objects) + config = mk_catalog(*objects) # So the report works out. config.retrieval_duration = 0.001 trans = config.apply diff --git a/test/other/transactions.rb b/test/other/transactions.rb index 8156ba478..79971a28b 100755 --- a/test/other/transactions.rb +++ b/test/other/transactions.rb @@ -131,7 +131,7 @@ class TestTransactions < Test::Unit::TestCase inst = type.create :name => "yay" # Create a transaction - trans = Puppet::Transaction.new(mk_configuration(inst)) + trans = Puppet::Transaction.new(mk_catalog(inst)) # Make sure prefetch works assert_nothing_raised do @@ -253,7 +253,7 @@ class TestTransactions < Test::Unit::TestCase } - component = mk_configuration("file",file) + component = mk_catalog("file",file) require 'etc' groupname = Etc.getgrgid(File.stat(file.name).gid).name assert_nothing_raised() { @@ -293,7 +293,7 @@ class TestTransactions < Test::Unit::TestCase file[:check] = check file[:group] = @groups[0] - config = mk_configuration(file) + config = mk_catalog(file) config.apply @@tmpfiles << execfile @@ -314,9 +314,9 @@ class TestTransactions < Test::Unit::TestCase file[:mode] = "755" } - # Make a new configuration so the resource relationships get + # Make a new catalog so the resource relationships get # set up. - config = mk_configuration(file, exec) + config = mk_catalog(file, exec) trans = assert_events([:file_changed, :triggered], config) @@ -344,7 +344,7 @@ class TestTransactions < Test::Unit::TestCase file[:group] = @groups[0] assert_apply(file) - config = Puppet::Node::Configuration.new + config = Puppet::Node::Catalog.new fcomp = Puppet::Type.type(:component).create(:name => "file") config.add_resource fcomp config.add_resource file @@ -445,7 +445,7 @@ class TestTransactions < Test::Unit::TestCase :subscribe => ["file", file.name] ) - config = mk_configuration(file, exec) + config = mk_catalog(file, exec) # Run it once assert_apply(config) @@ -501,7 +501,7 @@ class TestTransactions < Test::Unit::TestCase :ensure => :file ) - config = mk_configuration(exec, file1, file2) + config = mk_catalog(exec, file1, file2) assert_apply(config) @@ -532,7 +532,7 @@ class TestTransactions < Test::Unit::TestCase graph = trans.relationship_graph end - assert_instance_of(Puppet::Node::Configuration, graph, + assert_instance_of(Puppet::Node::Catalog, graph, "Did not get relationship graph") # Make sure all of the components are gone @@ -560,7 +560,7 @@ class TestTransactions < Test::Unit::TestCase end end - trans.configuration.leaves(config.resource("middle")).each do |child| + trans.catalog.leaves(config.resource("middle")).each do |child| assert(graph.dependents(config.f(:h)).include?(child), "%s not marked a dep of h" % [child.ref]) assert(sorted.index(child) < sorted.index(config.f(:h)), @@ -596,7 +596,7 @@ class TestTransactions < Test::Unit::TestCase yay = Puppet::Type.newgenerator :title => "yay" rah = Puppet::Type.newgenerator :title => "rah" - config = mk_configuration(yay, rah) + config = mk_catalog(yay, rah) trans = Puppet::Transaction.new(config) assert_nothing_raised do @@ -604,7 +604,7 @@ class TestTransactions < Test::Unit::TestCase end %w{ya ra y r}.each do |name| - assert(trans.configuration.vertex?(Puppet::Type.type(:generator)[name]), + assert(trans.catalog.vertex?(Puppet::Type.type(:generator)[name]), "Generated %s was not a vertex" % name) assert($finished.include?(name), "%s was not finished" % name) end @@ -615,7 +615,7 @@ class TestTransactions < Test::Unit::TestCase end %w{ya ra y r}.each do |name| - assert(!trans.configuration.vertex?(Puppet::Type.type(:generator)[name]), + assert(!trans.catalog.vertex?(Puppet::Type.type(:generator)[name]), "Generated vertex %s was not removed from graph" % name) assert_nil(Puppet::Type.type(:generator)[name], "Generated vertex %s was not removed from class" % name) @@ -635,7 +635,7 @@ class TestTransactions < Test::Unit::TestCase yay = Puppet::Type.newgenerator :title => "yay" rah = Puppet::Type.newgenerator :title => "rah", :subscribe => yay - config = mk_configuration(yay, rah) + config = mk_catalog(yay, rah) trans = Puppet::Transaction.new(config) trans.prepare @@ -715,39 +715,39 @@ class TestTransactions < Test::Unit::TestCase end def test_ignore_tags? - config = Puppet::Node::Configuration.new + config = Puppet::Node::Catalog.new config.host_config = true transaction = Puppet::Transaction.new(config) - assert(! transaction.ignore_tags?, "Ignoring tags when applying a host configuration") + assert(! transaction.ignore_tags?, "Ignoring tags when applying a host catalog") config.host_config = false transaction = Puppet::Transaction.new(config) - assert(transaction.ignore_tags?, "Not ignoring tags when applying a non-host configuration") + assert(transaction.ignore_tags?, "Not ignoring tags when applying a non-host catalog") end def test_missing_tags? resource = stub 'resource', :tagged? => true - config = Puppet::Node::Configuration.new + config = Puppet::Node::Catalog.new # Mark it as a host config so we don't care which test is first config.host_config = true transaction = Puppet::Transaction.new(config) assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when none are set") - # host configurations pay attention to tags, no one else does. + # host catalogs pay attention to tags, no one else does. Puppet[:tags] = "three,four" config.host_config = false transaction = Puppet::Transaction.new(config) - assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when not running a host configuration") + assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when not running a host catalog") # config.host_config = true transaction = Puppet::Transaction.new(config) - assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when running a host configuration and all tags are present") + assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when running a host catalog and all tags are present") transaction = Puppet::Transaction.new(config) resource.stubs :tagged? => false - assert(transaction.missing_tags?(resource), "Considered a resource not to be missing tags when running a host configuration and tags are missing") + assert(transaction.missing_tags?(resource), "Considered a resource not to be missing tags when running a host catalog and tags are missing") end # Make sure changes generated by eval_generated resources have proxies @@ -761,7 +761,7 @@ class TestTransactions < Test::Unit::TestCase end resource = type.create :name => "test" - config = mk_configuration(resource) + config = mk_catalog(resource) trans = Puppet::Transaction.new(config) trans.prepare @@ -820,7 +820,7 @@ class TestTransactions < Test::Unit::TestCase end # Make a graph with some stuff in it. - graph = Puppet::Node::Configuration.new + graph = Puppet::Node::Catalog.new # Add a non-triggering edge. a = trigger.new(:a) @@ -877,7 +877,7 @@ class TestTransactions < Test::Unit::TestCase file = Puppet::Type.newfile(:path => tempfile(), :content => "yay") exec1 = Puppet::Type.type(:exec).create :command => "/bin/echo exec1" exec2 = Puppet::Type.type(:exec).create :command => "/bin/echo exec2" - trans = Puppet::Transaction.new(mk_configuration(file, exec1, exec2)) + trans = Puppet::Transaction.new(mk_catalog(file, exec1, exec2)) # First try it with an edge that has no callback edge = Puppet::Relationship.new(file, exec1) @@ -924,7 +924,7 @@ class TestTransactions < Test::Unit::TestCase one[:require] = two two[:require] = one - config = mk_configuration(one, two) + config = mk_catalog(one, two) trans = Puppet::Transaction.new(config) assert_raise(Puppet::Error) do trans.prepare @@ -992,7 +992,7 @@ class TestTransactions < Test::Unit::TestCase rels[dir] = file rels.each do |after, before| - config = mk_configuration(before, after) + config = mk_catalog(before, after) trans = Puppet::Transaction.new(config) str = "from %s to %s" % [before, after] diff --git a/test/ral/manager/instances.rb b/test/ral/manager/instances.rb index 88f766038..a50ecb213 100755 --- a/test/ral/manager/instances.rb +++ b/test/ral/manager/instances.rb @@ -93,8 +93,8 @@ class TestTypeInstances < Test::Unit::TestCase # Make sure resources are entirely deleted. def test_delete aliases = %w{one} - config = mk_configuration - obj = @type.create(:name => "testing", :alias => "two", :configuration => config) + catalog = mk_catalog + obj = @type.create(:name => "testing", :alias => "two", :catalog => catalog) aliases << "two" @type.alias("two", obj) diff --git a/test/ral/manager/type.rb b/test/ral/manager/type.rb index 350d3dd15..6a044687e 100755 --- a/test/ral/manager/type.rb +++ b/test/ral/manager/type.rb @@ -138,9 +138,9 @@ class TestType < Test::Unit::TestCase ) resource.stubs(:path).returns("") - configuration = stub 'configuration' - configuration.expects(:resource).with(:file, "/path/to/some/missing/file").returns(resource) - resource.configuration = configuration + catalog = stub 'catalog' + catalog.expects(:resource).with(:file, "/path/to/some/missing/file").returns(resource) + resource.catalog = catalog # Verify our adding ourselves as an alias isn't an error. assert_nothing_raised("Could not add alias") { @@ -150,17 +150,17 @@ class TestType < Test::Unit::TestCase assert_equal(resource.object_id, Puppet.type(:file)["/path/to/some/missing/file"].object_id, "Could not retrieve alias to self") end - def test_aliases_are_added_to_class_and_configuration + def test_aliases_are_added_to_class_and_catalog resource = Puppet.type(:file).create( :name => "/path/to/some/missing/file", :ensure => "file" ) resource.stubs(:path).returns("") - configuration = stub 'configuration' - configuration.stubs(:resource).returns(nil) - configuration.expects(:alias).with(resource, "funtest") - resource.configuration = configuration + catalog = stub 'catalog' + catalog.stubs(:resource).returns(nil) + catalog.expects(:alias).with(resource, "funtest") + resource.catalog = catalog assert_nothing_raised("Could not add alias") { resource[:alias] = "funtest" @@ -169,22 +169,22 @@ class TestType < Test::Unit::TestCase assert_equal(resource.object_id, Puppet.type(:file)["funtest"].object_id, "Could not retrieve alias") end - def test_aliasing_fails_without_a_configuration + def test_aliasing_fails_without_a_catalog resource = Puppet.type(:file).create( :name => "/no/such/file", :ensure => "file" ) - assert_raise(Puppet::Error, "Did not fail to alias when no configuration was available") { + assert_raise(Puppet::Error, "Did not fail to alias when no catalog was available") { resource[:alias] = "funtest" } end - def test_configurations_are_set_during_initialization_if_present_on_the_transobject + def test_catalogs_are_set_during_initialization_if_present_on_the_transobject trans = Puppet::TransObject.new("/path/to/some/file", :file) - trans.configuration = :my_config + trans.catalog = :my_config resource = trans.to_type - assert_equal(resource.configuration, trans.configuration, "Did not set configuration on initialization") + assert_equal(resource.catalog, trans.catalog, "Did not set catalog on initialization") end # Verify that requirements don't depend on file order @@ -207,7 +207,7 @@ class TestType < Test::Unit::TestCase ) } - comp = mk_configuration(twoobj, oneobj) + comp = mk_catalog(twoobj, oneobj) assert_nothing_raised { comp.finalize @@ -695,7 +695,7 @@ class TestType < Test::Unit::TestCase end def test_path - config = mk_configuration + config = mk_catalog # Check that our paths are built correctly. Just pick a random, "normal" type. type = Puppet::Type.type(:exec) diff --git a/test/ral/types/basic.rb b/test/ral/types/basic.rb index 4427238bf..7bbadc5bc 100755 --- a/test/ral/types/basic.rb +++ b/test/ral/types/basic.rb @@ -35,7 +35,7 @@ class TestBasic < Test::Unit::TestCase :path => ENV["PATH"] ) } - @config = mk_configuration(@component, @configfile, @command) + @config = mk_catalog(@component, @configfile, @command) @config.add_edge! @component, @configfile @config.add_edge! @component, @command end diff --git a/test/ral/types/cron.rb b/test/ral/types/cron.rb index ca60477ed..73e941894 100755 --- a/test/ral/types/cron.rb +++ b/test/ral/types/cron.rb @@ -90,7 +90,7 @@ class TestCron < Test::Unit::TestCase text = obj.read name = cron.name - comp = mk_configuration(name, cron) + comp = mk_catalog(name, cron) assert_events([:cron_created], comp) cron.provider.class.prefetch @@ -153,7 +153,7 @@ class TestCron < Test::Unit::TestCase def test_makeandretrievecron %w{storeandretrieve a-name another-name more_naming SomeName}.each do |name| cron = mkcron(name) - comp = mk_configuration(name, cron) + comp = mk_catalog(name, cron) trans = assert_events([:cron_created], comp, name) cron.provider.class.prefetch diff --git a/test/ral/types/exec.rb b/test/ral/types/exec.rb index 11a6d4055..f718f944e 100755 --- a/test/ral/types/exec.rb +++ b/test/ral/types/exec.rb @@ -179,7 +179,7 @@ class TestExec < Test::Unit::TestCase ) } - comp = mk_configuration("createstest", exec) + comp = mk_catalog("createstest", exec) assert_events([:executed_command], comp, "creates") assert_events([], comp, "creates") end @@ -202,7 +202,7 @@ class TestExec < Test::Unit::TestCase :require => [:file, oexe] ) - comp = mk_configuration("Testing", file, exec) + comp = mk_catalog("Testing", file, exec) assert_events([:file_created, :executed_command], comp) end @@ -299,7 +299,7 @@ class TestExec < Test::Unit::TestCase :path => ENV['PATH'] ) } - comp = mk_configuration(exec) + comp = mk_catalog(exec) assert_events([:executed_command], comp) assert_events([:executed_command], comp) @@ -344,7 +344,7 @@ class TestExec < Test::Unit::TestCase exec = Puppet.type(:exec).create(args) } - comp = mk_configuration("usertest", exec) + comp = mk_catalog("usertest", exec) assert_events([:executed_command], comp, "usertest") assert(FileTest.exists?(file), "File does not exist") @@ -425,7 +425,7 @@ class TestExec < Test::Unit::TestCase ) } - comp = mk_configuration(file, exec) + comp = mk_catalog(file, exec) comp.finalize assert_events([:executed_command, :file_changed], comp) diff --git a/test/ral/types/file.rb b/test/ral/types/file.rb index 402ca010d..fdb2eb656 100755 --- a/test/ral/types/file.rb +++ b/test/ral/types/file.rb @@ -130,7 +130,7 @@ class TestFile < Test::Unit::TestCase ) } - comp = mk_configuration("createusertest", file) + comp = mk_catalog("createusertest", file) assert_events([:file_created], comp) end @@ -503,7 +503,7 @@ class TestFile < Test::Unit::TestCase # Create a test directory path = tempfile() dir = @file.create :path => path, :mode => 0755, :recurse => true - config = mk_configuration(dir) + config = mk_catalog(dir) Dir.mkdir(path) @@ -684,7 +684,7 @@ class TestFile < Test::Unit::TestCase :check => %w{owner mode group} ) } - config = mk_configuration dir + config = mk_catalog dir children = nil @@ -769,7 +769,7 @@ class TestFile < Test::Unit::TestCase :check => %w{owner mode group} ) } - mk_configuration dir + mk_catalog dir assert_nothing_raised { dir.eval_generate @@ -812,7 +812,7 @@ class TestFile < Test::Unit::TestCase :check => %w{mode owner group} ) } - mk_configuration dirobj + mk_catalog dirobj assert_nothing_raised { dirobj.eval_generate @@ -901,7 +901,7 @@ class TestFile < Test::Unit::TestCase ) } - comp = mk_configuration("yay", file) + comp = mk_catalog("yay", file) comp.finalize assert_apply(comp) #assert_events([:directory_created], comp) @@ -1300,7 +1300,7 @@ class TestFile < Test::Unit::TestCase :backup => false, :recurse => true) - config = mk_configuration(lfobj, destobj) + config = mk_catalog(lfobj, destobj) config.apply assert(FileTest.exists?(dsourcefile), "File did not get copied") @@ -1351,7 +1351,7 @@ class TestFile < Test::Unit::TestCase group = Puppet.type(:group).create( :name => "pptestg" ) - comp = mk_configuration(user, group, home) + comp = mk_catalog(user, group, home) } # Now make sure we get a relationship for each of these @@ -1647,7 +1647,7 @@ class TestFile < Test::Unit::TestCase file = File.join(dir, "file") File.open(file, "w") { |f| f.puts "" } obj = Puppet::Type.newfile :path => dir, :recurse => true, :mode => 0755 - mk_configuration obj + mk_catalog obj assert_equal("/%s" % obj.ref, obj.path) @@ -1758,7 +1758,7 @@ class TestFile < Test::Unit::TestCase File.open(file, "w") { |f| f.puts "yay" } File.chmod(0644, file) obj = Puppet::Type.newfile(:path => dir, :mode => 0750, :recurse => "2") - config = mk_configuration(obj) + config = mk_catalog(obj) children = nil assert_nothing_raised("Failure when recursing") do @@ -1767,7 +1767,7 @@ class TestFile < Test::Unit::TestCase assert(obj.class[subdir], "did not create subdir object") children.each do |c| assert_nothing_raised("Failure when recursing on %s" % c) do - c.configuration = config + c.catalog = config others = c.eval_generate end end @@ -1801,7 +1801,7 @@ class TestFile < Test::Unit::TestCase obj = Puppet::Type.newfile(:path => dir, :ensure => :directory, :recurse => true) - config = mk_configuration(obj) + config = mk_catalog(obj) children = nil assert_nothing_raised do children = obj.eval_generate diff --git a/test/ral/types/file/target.rb b/test/ral/types/file/target.rb index ffb60e0fa..035ea905b 100755 --- a/test/ral/types/file/target.rb +++ b/test/ral/types/file/target.rb @@ -46,7 +46,7 @@ class TestFileTarget < Test::Unit::TestCase def test_linkrecurse dest = tempfile() link = @file.create :path => tempfile(), :recurse => true, :ensure => dest - mk_configuration link + mk_catalog link ret = nil @@ -320,7 +320,7 @@ class TestFileTarget < Test::Unit::TestCase :source => dirs["source"], :recurse => true ) - config = mk_configuration obj + config = mk_catalog obj config.apply newfile = File.join(dirs["target"], "sourcefile") diff --git a/test/ral/types/fileignoresource.rb b/test/ral/types/fileignoresource.rb index 2314c8008..ff867c879 100755 --- a/test/ral/types/fileignoresource.rb +++ b/test/ral/types/fileignoresource.rb @@ -75,7 +75,7 @@ class TestFileIgnoreSources < Test::Unit::TestCase ) } - config = mk_configuration(tofile) + config = mk_catalog(tofile) config.apply @@ -141,7 +141,7 @@ class TestFileIgnoreSources < Test::Unit::TestCase ) } - config = mk_configuration(tofile) + config = mk_catalog(tofile) config.apply #topath should exist as a directory with sourcedir as a directory @@ -216,7 +216,7 @@ class TestFileIgnoreSources < Test::Unit::TestCase ) } - config = mk_configuration(tofile) + config = mk_catalog(tofile) config.apply #topath should exist as a directory with sourcedir as a directory diff --git a/test/ral/types/filesources.rb b/test/ral/types/filesources.rb index 54d29968c..6180eed18 100755 --- a/test/ral/types/filesources.rb +++ b/test/ral/types/filesources.rb @@ -64,7 +64,7 @@ class TestFileSources < Test::Unit::TestCase :name => path ) } - config = mk_configuration(file) + config = mk_catalog(file) child = nil assert_nothing_raised { child = file.newchild("childtest", true) @@ -278,7 +278,7 @@ class TestFileSources < Test::Unit::TestCase # The sourcerecurse method will only ever get called when we're # recursing, so we go ahead and set it. obj = Puppet::Type.newfile :source => source, :path => dest, :recurse => true - config = mk_configuration(obj) + config = mk_catalog(obj) result = nil sourced = nil @@ -628,7 +628,7 @@ class TestFileSources < Test::Unit::TestCase file.retrieve } - comp = mk_configuration(file) + comp = mk_catalog(file) comp.apply assert(!FileTest.exists?(name), "File with no source exists anyway") @@ -678,7 +678,7 @@ class TestFileSources < Test::Unit::TestCase ) } - comp = mk_configuration(file) + comp = mk_catalog(file) assert_events([:file_created], comp) assert(File.exists?(to), "File does not exist") @@ -764,7 +764,7 @@ class TestFileSources < Test::Unit::TestCase trans = nil assert_nothing_raised { file[:links] = :manage - comp = mk_configuration(file) + comp = mk_catalog(file) trans = comp.apply } diff --git a/test/ral/types/group.rb b/test/ral/types/group.rb index 944b7e074..d28c8eea5 100755 --- a/test/ral/types/group.rb +++ b/test/ral/types/group.rb @@ -65,7 +65,7 @@ class TestGroup < Test::Unit::TestCase def attrtest_ensure(group) group[:ensure] = :absent - comp = mk_configuration("ensuretest", group) + comp = mk_catalog("ensuretest", group) assert_apply(comp) assert_equal(:absent, group.provider.ensure, "Group is still present") group[:ensure] = :present @@ -91,7 +91,7 @@ class TestGroup < Test::Unit::TestCase assert_equal(15, group.should(:gid), "Did not convert gid to number") - comp = mk_configuration(group) + comp = mk_catalog(group) trans = assert_events([:group_modified], comp, "group") assert_equal(15, group.provider.gid, "GID was not changed") diff --git a/test/ral/types/host.rb b/test/ral/types/host.rb index 1013651c5..088f93c1f 100755 --- a/test/ral/types/host.rb +++ b/test/ral/types/host.rb @@ -39,7 +39,7 @@ class TestHost < Test::Unit::TestCase @hcount = 1 end - @configuration ||= mk_configuration + @catalog ||= mk_catalog host = nil assert_nothing_raised { @@ -47,7 +47,7 @@ class TestHost < Test::Unit::TestCase :name => "fakehost%s" % @hcount, :ip => "192.168.27.%s" % @hcount, :alias => "alias%s" % @hcount, - :configuration => @configuration + :catalog => @catalog ) } diff --git a/test/ral/types/parameter.rb b/test/ral/types/parameter.rb index 1d402cb85..e1b8e00b3 100755 --- a/test/ral/types/parameter.rb +++ b/test/ral/types/parameter.rb @@ -113,8 +113,8 @@ class TestParameter < Test::Unit::TestCase inst = type.create(:name => "test") - config = mk_configuration - inst.configuration = config + config = mk_catalog + inst.catalog = config assert_nothing_raised("Could not create shadowed param") { inst[:alias] = "foo" @@ -136,7 +136,7 @@ class TestParameter < Test::Unit::TestCase # Now try it during initialization other = nil assert_nothing_raised("Could not create instance with shadow") do - other = type.create(:name => "rah", :alias => "one", :configuration => config) + other = type.create(:name => "rah", :alias => "one", :catalog => config) end params = other.instance_variable_get("@parameters") obj = params[:alias] diff --git a/test/ral/types/sshkey.rb b/test/ral/types/sshkey.rb index c99f7562a..b9aed20e8 100755 --- a/test/ral/types/sshkey.rb +++ b/test/ral/types/sshkey.rb @@ -47,7 +47,7 @@ class TestSSHKey < Test::Unit::TestCase @kcount = 1 end - @config ||= mk_configuration + @catalog ||= mk_catalog assert_nothing_raised { key = @sshkeytype.create( @@ -55,7 +55,7 @@ class TestSSHKey < Test::Unit::TestCase :key => "%sAAAAB3NzaC1kc3MAAACBAMnhSiku76y3EGkNCDsUlvpO8tRgS9wL4Eh54WZfQ2lkxqfd2uT/RTT9igJYDtm/+UHuBRdNGpJYW1Nw2i2JUQgQEEuitx4QKALJrBotejGOAWxxVk6xsh9xA0OW8Q3ZfuX2DDitfeC8ZTCl4xodUMD8feLtP+zEf8hxaNamLlt/AAAAFQDYJyf3vMCWRLjTWnlxLtOyj/bFpwAAAIEAmRxxXb4jjbbui9GYlZAHK00689DZuX0EabHNTl2yGO5KKxGC6Esm7AtjBd+onfu4Rduxut3jdI8GyQCIW8WypwpJofCIyDbTUY4ql0AQUr3JpyVytpnMijlEyr41FfIb4tnDqnRWEsh2H7N7peW+8DWZHDFnYopYZJ9Yu4/jHRYAAACAERG50e6aRRb43biDr7Ab9NUCgM9bC0SQscI/xdlFjac0B/kSWJYTGVARWBDWug705hTnlitY9cLC5Ey/t/OYOjylTavTEfd/bh/8FkAYO+pWdW3hx6p97TBffK0b6nrc6OORT2uKySbbKOn0681nNQh4a6ueR3JRppNkRPnTk5c=" % @kcount, :type => "ssh-dss", :alias => ["192.168.0.%s" % @kcount], - :configuration => @config + :catalog => @catalog ) } diff --git a/test/ral/types/tidy.rb b/test/ral/types/tidy.rb index 59a0e5e2d..60fad6516 100755 --- a/test/ral/types/tidy.rb +++ b/test/ral/types/tidy.rb @@ -57,7 +57,7 @@ class TestTidy < Test::Unit::TestCase assert_nothing_raised { link = newlink(:target => source, :recurse => true) } - comp = mk_configuration("linktest",link) + comp = mk_catalog("linktest",link) cycle(comp) path = link.name diff --git a/test/ral/types/user.rb b/test/ral/types/user.rb index 6cbe78f0f..b280acfed 100755 --- a/test/ral/types/user.rb +++ b/test/ral/types/user.rb @@ -82,7 +82,7 @@ class TestUser < Test::Unit::TestCase old = user.provider.ensure user[:ensure] = :absent - comp = mk_configuration("ensuretest", user) + comp = mk_catalog("ensuretest", user) assert_apply(user) assert(!user.provider.exists?, "User is still present") user[:ensure] = :present @@ -102,7 +102,7 @@ class TestUser < Test::Unit::TestCase old = user.provider.comment user[:comment] = "A different comment" - comp = mk_configuration("commenttest", user) + comp = mk_catalog("commenttest", user) trans = assert_events([:user_changed], comp, "user") @@ -117,7 +117,7 @@ class TestUser < Test::Unit::TestCase def attrtest_home(user) obj = nil - comp = mk_configuration("hometest", user) + comp = mk_catalog("hometest", user) old = user.provider.home user[:home] = old @@ -137,7 +137,7 @@ class TestUser < Test::Unit::TestCase def attrtest_shell(user) old = user.provider.shell - comp = mk_configuration("shelltest", user) + comp = mk_catalog("shelltest", user) user[:shell] = old @@ -167,7 +167,7 @@ class TestUser < Test::Unit::TestCase def attrtest_gid(user) obj = nil old = user.provider.gid - comp = mk_configuration("gidtest", user) + comp = mk_catalog("gidtest", user) user.retrieve @@ -216,7 +216,7 @@ class TestUser < Test::Unit::TestCase def attrtest_uid(user) obj = nil - comp = mk_configuration("uidtest", user) + comp = mk_catalog("uidtest", user) user.provider.uid = 1 @@ -387,7 +387,7 @@ class TestUser < Test::Unit::TestCase ogroup = Puppet.type(:group).create( :name => "yayness" ) - comp = mk_configuration(user, group, home, ogroup) + comp = mk_catalog(user, group, home, ogroup) } rels = nil @@ -404,7 +404,7 @@ class TestUser < Test::Unit::TestCase user = mkuser(name) - comp = mk_configuration("usercomp", user) + comp = mk_catalog("usercomp", user) trans = assert_events([:user_created], comp, "user") @@ -424,7 +424,7 @@ class TestUser < Test::Unit::TestCase assert(! user.provider.exists?, "User %s is present" % name) - comp = mk_configuration("usercomp", user) + comp = mk_catalog("usercomp", user) trans = assert_events([:user_created], comp, "user") -- cgit