puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/lib/puppet/rails/fact_name.rb

@@ -1,7 +0,0 @@
-require 'active_record'
-require 'puppet/rails'
-require 'puppet/rails/fact_value'
-
-class Puppet::Rails::FactName < ActiveRecord::Base
-  has_many :fact_values, :dependent => :destroy
-end

data/lib/puppet/rails/fact_value.rb

@@ -1,10 +0,0 @@
-require 'active_record'
-
-class Puppet::Rails::FactValue < ActiveRecord::Base
-  belongs_to :fact_name
-  belongs_to :host
-
-  def to_label
-    "#{self.fact_name.name}"
-  end
-end

data/lib/puppet/rails/host.rb

@@ -1,258 +0,0 @@
-require 'puppet/node/environment'
-require 'puppet/rails'
-require 'puppet/rails/resource'
-require 'puppet/rails/fact_name'
-require 'puppet/rails/source_file'
-require 'puppet/rails/benchmark'
-require 'puppet/util/rails/collection_merger'
-
-class Puppet::Rails::Host < ActiveRecord::Base
-  include Puppet::Rails::Benchmark
-  extend Puppet::Rails::Benchmark
-  include Puppet::Util
-  include Puppet::Util::CollectionMerger
-
-  has_many :fact_values, :dependent => :destroy, :class_name => "Puppet::Rails::FactValue"
-  has_many :fact_names, :through => :fact_values, :class_name => "Puppet::Rails::FactName"
-  belongs_to :source_file
-  has_many :resources, :dependent => :destroy, :class_name => "Puppet::Rails::Resource"
-
-  def self.from_puppet(node)
-    host = find_by_name(node.name) || new(:name => node.name)
-
-    {"ipaddress" => "ip", "environment" => "environment"}.each do |myparam, itsparam|
-      if value = node.send(myparam)
-        host.send(itsparam + "=", value)
-      end
-    end
-
-    host
-  end
-
-  # Override the setter for environment to force it to be a string, lest it
-  # be YAML encoded.  See #4487.
-  def environment=(value)
-    super value.to_s
-  end
-
-  # returns a hash of fact_names.name => [ fact_values ] for this host.
-  # Note that 'fact_values' is actually a list of the value instances, not
-  # just actual values.
-  def get_facts_hash
-    fact_values = self.fact_values.find(:all, :include => :fact_name)
-    return fact_values.inject({}) do | hash, value |
-      hash[value.fact_name.name] ||= []
-      hash[value.fact_name.name] << value
-      hash
-    end
-  end
-
-
-  # This is *very* similar to the merge_parameters method
-  # of Puppet::Rails::Resource.
-  def merge_facts(facts)
-    db_facts = {}
-
-    deletions = []
-    self.fact_values.find(:all, :include => :fact_name).each do |value|
-      deletions << value['id'] and next unless facts.include?(value['name'])
-      # Now store them for later testing.
-      db_facts[value['name']] ||= []
-      db_facts[value['name']] << value
-    end
-
-    # Now get rid of any parameters whose value list is different.
-    # This might be extra work in cases where an array has added or lost
-    # a single value, but in the most common case (a single value has changed)
-    # this makes sense.
-    db_facts.each do |name, value_hashes|
-      values = value_hashes.collect { |v| v['value'] }
-
-      unless values == facts[name]
-        value_hashes.each { |v| deletions << v['id'] }
-      end
-    end
-
-    # Perform our deletions.
-    Puppet::Rails::FactValue.delete(deletions) unless deletions.empty?
-
-    # Lastly, add any new parameters.
-    facts.each do |name, value|
-      next if db_facts.include?(name)
-      values = value.is_a?(Array) ? value : [value]
-
-      values.each do |v|
-        fact_values.build(:value => v, :fact_name => Puppet::Rails::FactName.find_or_create_by_name(name))
-      end
-    end
-  end
-
-  # Set our resources.
-  def merge_resources(list)
-    # keep only exported resources in thin_storeconfig mode
-    list = list.select { |r| r.exported? } if Puppet.settings[:thin_storeconfigs]
-
-    resources_by_id = nil
-    debug_benchmark("Searched for resources") {
-      resources_by_id = find_resources
-    }
-
-    debug_benchmark("Searched for resource params and tags") {
-      find_resources_parameters_tags(resources_by_id)
-    } if id
-
-    debug_benchmark("Performed resource comparison") {
-      compare_to_catalog(resources_by_id, list)
-    }
-  end
-
-  def find_resources
-    condition = { :exported => true } if Puppet.settings[:thin_storeconfigs]
-
-    resources.find(:all, :include => :source_file, :conditions => condition || {}).inject({}) do | hash, resource |
-      hash[resource.id] = resource
-      hash
-    end
-  end
-
-  def find_resources_parameters_tags(resources)
-    find_resources_parameters(resources)
-    find_resources_tags(resources)
-  end
-
-  def compare_to_catalog(existing, list)
-    compiled = list.inject({}) do |hash, resource|
-      hash[resource.ref] = resource
-      hash
-    end
-
-    resources = nil
-    debug_benchmark("Resource removal") {
-      resources = remove_unneeded_resources(compiled, existing)
-    }
-
-    # Now for all resources in the catalog but not in the db, we're pretty easy.
-    additions = nil
-    debug_benchmark("Resource merger") {
-      additions = perform_resource_merger(compiled, resources)
-    }
-
-    debug_benchmark("Resource addition") {
-      additions.each do |resource|
-        build_rails_resource_from_parser_resource(resource)
-      end
-
-      log_accumulated_marks "Added resources"
-    }
-  end
-
-  def add_new_resources(additions)
-    additions.each do |resource|
-      Puppet::Rails::Resource.from_parser_resource(self, resource)
-    end
-  end
-
-  # Turn a parser resource into a Rails resource.
-  def build_rails_resource_from_parser_resource(resource)
-    db_resource = nil
-    accumulate_benchmark("Added resources", :initialization) {
-      args = Puppet::Rails::Resource.rails_resource_initial_args(resource)
-
-      db_resource = self.resources.build(args)
-
-      # Our file= method does the name to id conversion.
-      db_resource.file = resource.file
-    }
-
-
-    accumulate_benchmark("Added resources", :parameters) {
-      resource.each do |param, value|
-        Puppet::Rails::ParamValue.from_parser_param(param, value).each do |value_hash|
-          db_resource.param_values.build(value_hash)
-        end
-      end
-    }
-
-    accumulate_benchmark("Added resources", :tags) {
-      resource.tags.each { |tag| db_resource.add_resource_tag(tag) }
-    }
-
-    db_resource.save
-
-    db_resource
-  end
-
-
-  def perform_resource_merger(compiled, resources)
-    return compiled.values if resources.empty?
-
-    # Now for all resources in the catalog but not in the db, we're pretty easy.
-    additions = []
-    compiled.each do |ref, resource|
-      if db_resource = resources[ref]
-        db_resource.merge_parser_resource(resource)
-      else
-        additions << resource
-      end
-    end
-    log_accumulated_marks "Resource merger"
-
-    additions
-  end
-
-  def remove_unneeded_resources(compiled, existing)
-    deletions = []
-    resources = {}
-    existing.each do |id, resource|
-      # it seems that it can happen (see bug #2010) some resources are duplicated in the
-      # database (ie logically corrupted database), in which case we remove the extraneous
-      # entries.
-      if resources.include?(resource.ref)
-        deletions << id
-        next
-      end
-
-      # If the resource is in the db but not in the catalog, mark it
-      # for removal.
-      unless compiled.include?(resource.ref)
-        deletions << id
-        next
-      end
-
-      resources[resource.ref] = resource
-    end
-    # We need to use 'destroy' here, not 'delete', so that all
-    # dependent objects get removed, too.
-    Puppet::Rails::Resource.destroy(deletions) unless deletions.empty?
-
-    resources
-  end
-
-  def find_resources_parameters(resources)
-    params = Puppet::Rails::ParamValue.find_all_params_from_host(self)
-
-    # assign each loaded parameters/tags to the resource it belongs to
-    params.each do |param|
-      resources[param['resource_id']].add_param_to_list(param) if resources.include?(param['resource_id'])
-    end
-  end
-
-  def find_resources_tags(resources)
-    tags = Puppet::Rails::ResourceTag.find_all_tags_from_host(self)
-
-    tags.each do |tag|
-      resources[tag['resource_id']].add_tag_to_list(tag) if resources.include?(tag['resource_id'])
-    end
-  end
-
-  def to_puppet
-    node = Puppet::Node.new(self.name)
-    {"ip" => "ipaddress", "environment" => "environment"}.each do |myparam, itsparam|
-      if value = send(myparam)
-        node.send(itsparam + "=", value)
-      end
-    end
-
-    node
-  end
-end

data/lib/puppet/rails/inventory_fact.rb

@@ -1,5 +0,0 @@
-require 'puppet/rails/inventory_node'
-
-class Puppet::Rails::InventoryFact < ::ActiveRecord::Base
-  belongs_to :node, :class_name => "Puppet::Rails::InventoryNode"
-end

data/lib/puppet/rails/inventory_node.rb

@@ -1,43 +0,0 @@
-require 'puppet/rails/inventory_fact'
-
-class Puppet::Rails::InventoryNode < ::ActiveRecord::Base
-  has_many :facts, :class_name => "Puppet::Rails::InventoryFact", :foreign_key => :node_id, :dependent => :delete_all
-
-  if Puppet::Util.activerecord_version < 3.0
-    # For backward compatibility, use the old named_scope with pre 3.0 activerecord
-    named_scope :has_fact_with_value, lambda { |name,value|
-      {
-        :conditions => ["inventory_facts.name = ? AND inventory_facts.value = ?", name, value.to_s],
-        :joins => :facts
-      }
-    }
-
-    named_scope :has_fact_without_value, lambda { |name,value|
-      {
-        :conditions => ["inventory_facts.name = ? AND inventory_facts.value != ?", name, value.to_s],
-        :joins => :facts
-      }
-    }
-  else
-    # Use scope for activerecord >= 3.0
-    scope :has_fact_with_value, lambda { |name,value|
-      {
-        :conditions => ["inventory_facts.name = ? AND inventory_facts.value = ?", name, value.to_s],
-        :joins => :facts
-      }
-    }
-
-    scope :has_fact_without_value, lambda { |name,value|
-      {
-        :conditions => ["inventory_facts.name = ? AND inventory_facts.value != ?", name, value.to_s],
-        :joins => :facts
-      }
-    }
-  end
-
-  def facts_to_hash
-    facts.inject({}) do |fact_hash,fact|
-      fact_hash.merge(fact.name => fact.value)
-    end
-  end
-end

data/lib/puppet/rails/param_name.rb

@@ -1,25 +0,0 @@
-require 'puppet/util/rails/collection_merger'
-require 'puppet/rails/param_value'
-require 'puppet/util/rails/cache_accumulator'
-
-class Puppet::Rails::ParamName < ActiveRecord::Base
-  include Puppet::Util::CollectionMerger
-  has_many :param_values, :dependent => :destroy
-
-  include Puppet::Util::CacheAccumulator
-  accumulates :name
-
-  def to_resourceparam(resource, source)
-    hash = {}
-    hash[:name] = self.name.to_sym
-    hash[:source] = source
-    hash[:value] = resource.param_values.find(:all, :conditions => [ "param_name_id = ?", self.id]).collect { |v| v.value }
-    if hash[:value].length == 1
-      hash[:value] = hash[:value].shift
-    elsif hash[:value].empty?
-      hash[:value] = nil
-    end
-    Puppet::Parser::Resource::Param.new hash
-  end
-end
-

data/lib/puppet/rails/param_value.rb

@@ -1,74 +0,0 @@
-require 'puppet/util/rails/reference_serializer'
-
-class Puppet::Rails::ParamValue < ActiveRecord::Base
-  include Puppet::Util::ReferenceSerializer
-  extend Puppet::Util::ReferenceSerializer
-
-  belongs_to :param_name
-  belongs_to :resource
-
-  # Store a new parameter in a Rails db.
-  def self.from_parser_param(param, values)
-    values = munge_parser_values(values)
-
-    param_name = Puppet::Rails::ParamName.find_or_create_by_name(param.to_s)
-    return values.collect do |v|
-      {:value => v, :param_name => param_name}
-    end
-  end
-
-  # Make sure an array (or possibly not an array) of values is correctly
-  # set up for Rails.  The main thing is that Resource::Reference objects
-  # should stay objects, so they just get serialized.
-  def self.munge_parser_values(value)
-    values = value.is_a?(Array) ? value : [value]
-    values.map do |v|
-      if v.is_a?(Puppet::Resource)
-        v
-      else
-        v.to_s
-      end
-    end
-  end
-
-
-  def value
-    unserialize_value(self[:value])
-  end
-
-  # I could not find a cleaner way to handle making sure that resource references
-  # were consistently serialized and deserialized.
-  def value=(val)
-    self[:value] = serialize_value(val)
-  end
-
-  def to_label
-    "#{self.param_name.name}"
-  end
-
-  # returns an array of hash containing all the parameters of a given resource
-  def self.find_all_params_from_resource(db_resource)
-    params = db_resource.connection.select_all("SELECT v.id, v.value, v.line, v.resource_id, v.param_name_id, n.name FROM param_values v INNER JOIN param_names n ON v.param_name_id=n.id WHERE v.resource_id=#{db_resource.id}")
-    params.each do |val|
-      val['value'] = unserialize_value(val['value'])
-      val['line'] = val['line'] ? Integer(val['line']) : nil
-      val['resource_id'] = Integer(val['resource_id'])
-    end
-    params
-  end
-
-  # returns an array of hash containing all the parameters of a given host
-  def self.find_all_params_from_host(db_host)
-    params = db_host.connection.select_all("SELECT v.id, v.value,  v.line, v.resource_id, v.param_name_id, n.name FROM param_values v INNER JOIN resources r ON v.resource_id=r.id INNER JOIN param_names n ON v.param_name_id=n.id WHERE r.host_id=#{db_host.id}")
-    params.each do |val|
-      val['value'] = unserialize_value(val['value'])
-      val['line'] = val['line'] ? Integer(val['line']) : nil
-      val['resource_id'] = Integer(val['resource_id'])
-    end
-    params
-  end
-
-  def to_s
-    "#{self.name} => #{self.value}"
-  end
-end

data/lib/puppet/rails/puppet_tag.rb

@@ -1,10 +0,0 @@
-require 'puppet/rails/resource_tag'
-require 'puppet/util/rails/cache_accumulator'
-
-class Puppet::Rails::PuppetTag < ActiveRecord::Base
-  has_many :resource_tags, :dependent => :destroy
-  has_many :resources, :through => :resource_tags
-
-  include Puppet::Util::CacheAccumulator
-  accumulates :name
-end

data/lib/puppet/rails/resource.rb

@@ -1,235 +0,0 @@
-require 'puppet'
-require 'puppet/rails/param_name'
-require 'puppet/rails/param_value'
-require 'puppet/rails/puppet_tag'
-require 'puppet/rails/benchmark'
-require 'puppet/util/rails/collection_merger'
-
-class Puppet::Rails::Resource < ActiveRecord::Base
-  include Puppet::Util::CollectionMerger
-  include Puppet::Util::ReferenceSerializer
-  include Puppet::Rails::Benchmark
-
-  has_many :param_values, :dependent => :destroy, :class_name => "Puppet::Rails::ParamValue"
-  has_many :param_names, :through => :param_values, :class_name => "Puppet::Rails::ParamName"
-
-  has_many :resource_tags, :dependent => :destroy, :class_name => "Puppet::Rails::ResourceTag"
-  has_many :puppet_tags, :through => :resource_tags, :class_name => "Puppet::Rails::PuppetTag"
-
-  belongs_to :source_file
-  belongs_to :host
-
-  @tags = {}
-  def self.tags
-    @tags
-  end
-
-  # Determine the basic details on the resource.
-  def self.rails_resource_initial_args(resource)
-    result = [:type, :title, :line].inject({}) do |hash, param|
-      # 'type' isn't a valid column name, so we have to use another name.
-      to = (param == :type) ? :restype : param
-      if value = resource.send(param)
-        hash[to] = value
-      end
-      hash
-    end
-
-    # We always want a value here, regardless of what the resource has,
-    # so we break it out separately.
-    result[:exported] = resource.exported || false
-
-    result
-  end
-
-  def add_resource_tag(tag)
-    pt = Puppet::Rails::PuppetTag.accumulate_by_name(tag)
-    resource_tags.build(:puppet_tag => pt)
-  end
-
-  def file
-    (f = self.source_file) ? f.filename : nil
-  end
-
-  def file=(file)
-    self.source_file = Puppet::Rails::SourceFile.find_or_create_by_filename(file)
-  end
-
-  def title
-    unserialize_value(self[:title])
-  end
-
-  def params_list
-    @params_list ||= []
-  end
-
-  def params_list=(params)
-    @params_list = params
-  end
-
-  def add_param_to_list(param)
-    params_list << param
-  end
-
-  def tags_list
-    @tags_list ||= []
-  end
-
-  def tags_list=(tags)
-    @tags_list = tags
-  end
-
-  def add_tag_to_list(tag)
-    tags_list << tag
-  end
-
-  def [](param)
-    if param == 'id'
-      super
-    else
-      super || parameter(param)
-    end
-  end
-
-  # Make sure this resource is equivalent to the provided Parser resource.
-  def merge_parser_resource(resource)
-    accumulate_benchmark("Individual resource merger", :attributes) { merge_attributes(resource) }
-    accumulate_benchmark("Individual resource merger", :parameters) { merge_parameters(resource) }
-    accumulate_benchmark("Individual resource merger", :tags) { merge_tags(resource) }
-    save
-  end
-
-  def merge_attributes(resource)
-    args = self.class.rails_resource_initial_args(resource)
-    args.each do |param, value|
-      self[param] = value unless resource[param] == value
-    end
-
-    # Handle file specially
-    self.file = resource.file if (resource.file and  (!resource.file or self.file != resource.file))
-  end
-
-  def merge_parameters(resource)
-    catalog_params = {}
-    resource.each do |param, value|
-      catalog_params[param.to_s] = value
-    end
-
-    db_params = {}
-
-    deletions = []
-    params_list.each do |value|
-      # First remove any parameters our catalog resource doesn't have at all.
-      deletions << value['id'] and next unless catalog_params.include?(value['name'])
-
-      # Now store them for later testing.
-      db_params[value['name']] ||= []
-      db_params[value['name']] << value
-    end
-
-    # Now get rid of any parameters whose value list is different.
-    # This might be extra work in cases where an array has added or lost
-    # a single value, but in the most common case (a single value has changed)
-    # this makes sense.
-    db_params.each do |name, value_hashes|
-      values = value_hashes.collect { |v| v['value'] }
-
-      value_hashes.each { |v| deletions << v['id'] } unless value_compare(catalog_params[name], values)
-    end
-
-    # Perform our deletions.
-    Puppet::Rails::ParamValue.delete(deletions) unless deletions.empty?
-
-    # Lastly, add any new parameters.
-    catalog_params.each do |name, value|
-      next if db_params.include?(name) && ! db_params[name].find{ |val| deletions.include?( val["id"] ) }
-      values = value.is_a?(Array) ? value : [value]
-
-      values.each do |v|
-        param_values.build(:value => serialize_value(v), :line => resource.line, :param_name => Puppet::Rails::ParamName.accumulate_by_name(name))
-      end
-    end
-  end
-
-  # Make sure the tag list is correct.
-  def merge_tags(resource)
-    in_db = []
-    deletions = []
-    resource_tags = resource.tags
-    tags_list.each do |tag|
-      deletions << tag['id'] and next unless resource_tags.include?(tag['name'])
-      in_db << tag['name']
-    end
-    Puppet::Rails::ResourceTag.delete(deletions) unless deletions.empty?
-
-    (resource_tags - in_db).each do |tag|
-      add_resource_tag(tag)
-    end
-  end
-
-  def value_compare(v,db_value)
-    v = [v] unless v.is_a?(Array)
-
-    v == db_value
-  end
-
-  def name
-    ref
-  end
-
-  def parameter(param)
-    if pn = param_names.find_by_name(param)
-      return (pv = param_values.find(:first, :conditions => [ 'param_name_id = ?', pn])) ? pv.value : nil
-    end
-  end
-
-  def ref(dummy_argument=:work_arround_for_ruby_GC_bug)
-    "#{self[:restype].split("::").collect { |s| s.capitalize }.join("::")}[#{self.title}]"
-  end
-
-  # Returns a hash of parameter names and values, no ActiveRecord instances.
-  def to_hash
-    Puppet::Rails::ParamValue.find_all_params_from_resource(self).inject({}) do |hash, value|
-      hash[value['name']] ||= []
-      hash[value['name']] << value.value
-      hash
-    end
-  end
-
-  # Convert our object to a resource.  Do not retain whether the object
-  # is exported, though, since that would cause it to get stripped
-  # from the configuration.
-  def to_resource(scope)
-    hash = self.attributes
-    hash["type"] = hash["restype"]
-    hash.delete("restype")
-
-    # FIXME At some point, we're going to want to retain this information
-    # for logging and auditing.
-    hash.delete("host_id")
-    hash.delete("updated_at")
-    hash.delete("source_file_id")
-    hash.delete("created_at")
-    hash.delete("id")
-    hash.each do |p, v|
-      hash.delete(p) if v.nil?
-    end
-    hash[:scope] = scope
-    hash[:source] = scope.source
-    hash[:parameters] = []
-    names = []
-    self.param_names.each do |pname|
-      # We can get the same name multiple times because of how the
-      # db layout works.
-      next if names.include?(pname.name)
-      names << pname.name
-      hash[:parameters] << pname.to_resourceparam(self, scope.source)
-    end
-    obj = Puppet::Parser::Resource.new(hash.delete("type"), hash.delete("title"), hash)
-
-    # Store the ID, so we can check if we're re-collecting the same resource.
-    obj.collector_id = self.id
-
-    obj
-  end
-end