# class Puppet::Rails::Host

### Public Class Methods

from_puppet(node) click to toggle source

    # File lib/puppet/rails/host.rb, line 20
    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

### Public Instance Methods

add_new_resources(additions) click to toggle source

    # File lib/puppet/rails/host.rb, line 149
    def add_new_resources(additions)
      additions.each do |resource|
        Puppet::Rails::Resource.from_parser_resource(self, resource)
      end
    end

build_rails_resource_from_parser_resource(resource) click to toggle source

Turn a parser resource into a Rails resource.

    # File lib/puppet/rails/host.rb, line 156
    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

compare_to_catalog(existing, list) click to toggle source

    # File lib/puppet/rails/host.rb, line 123
    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

environment=(value) click to toggle source

Override the setter for environment to force it to be a string, lest it be YAML encoded. See #4487.

Calls superclass method

    # File lib/puppet/rails/host.rb, line 34
    def environment=(value)
      super value.to_s
    end

find_resources() click to toggle source

    # File lib/puppet/rails/host.rb, line 109
    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

find_resources_parameters(resources) click to toggle source

    # File lib/puppet/rails/host.rb, line 231
    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

find_resources_parameters_tags(resources) click to toggle source

    # File lib/puppet/rails/host.rb, line 118
    def find_resources_parameters_tags(resources)
      find_resources_parameters(resources)
      find_resources_tags(resources)
    end

find_resources_tags(resources) click to toggle source

    # File lib/puppet/rails/host.rb, line 240
    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

get_facts_hash() click to toggle source

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.

    # File lib/puppet/rails/host.rb, line 41
    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

merge_facts(facts) click to toggle source

This is very similar to the merge_parameters method of Puppet::Rails::Resource.

    # File lib/puppet/rails/host.rb, line 53
    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

merge_resources(list) click to toggle source

Set our resources.

    # File lib/puppet/rails/host.rb, line 91
    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

perform_resource_merger(compiled, resources) click to toggle source

    # File lib/puppet/rails/host.rb, line 186
    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

remove_unneeded_resources(compiled, existing) click to toggle source

    # File lib/puppet/rails/host.rb, line 203
    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

to_puppet() click to toggle source

    # File lib/puppet/rails/host.rb, line 248
    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