Skip to content

Commit

Permalink
(puppetlabs#6338) Remove inventory indirection, and move to facts ind…
Browse files Browse the repository at this point in the history 
…irection

The inventory indirection was just providing the search method for facts.
Because the route is now facts_search instead of inventory, it can just be
implemented as the search method for facts.

Reviewed-By: Daniel Pittman
  • Loading branch information
@nicklewis
nicklewis committed Mar 4, 2011
1 parent 63d8a1f commit c3baa28
Show file tree
Hide file tree
Showing 6 changed files with 289 additions and 310 deletions.
75 changes: 75 additions & 0 deletions lib/puppet/indirector/facts/yaml.rb
View file
Expand Up @@ -4,4 +4,79 @@
class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
desc "Store client facts as flat files, serialized using YAML, or
return deserialized facts from disk."

def search(request)
node_names = []
Dir.glob(yaml_dir_path).each do |file|
facts = YAML.load_file(file)
node_names << facts.name if node_matches?(facts, request.options)
end
node_names
end

private

# Return the path to a given node's file.
def yaml_dir_path
base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
File.join(base, 'facts', '*.yaml')
end

def node_matches?(facts, options)
options.each do |key, value|
type, name, operator = key.to_s.split(".")
operator ||= 'eq'

return false unless node_matches_option?(type, name, operator, value, facts)
end
return true
end

def node_matches_option?(type, name, operator, value, facts)
case type
when "meta"
case name
when "timestamp"
compare_timestamp(operator, facts.timestamp, Time.parse(value))
end
when "facts"
compare_facts(operator, facts.values[name], value)
end
end

def compare_facts(operator, value1, value2)
return false unless value1

case operator
when "eq"
value1.to_s == value2.to_s
when "le"
value1.to_f <= value2.to_f
when "ge"
value1.to_f >= value2.to_f
when "lt"
value1.to_f < value2.to_f
when "gt"
value1.to_f > value2.to_f
when "ne"
value1.to_s != value2.to_s
end
end

def compare_timestamp(operator, value1, value2)
case operator
when "eq"
value1 == value2
when "le"
value1 <= value2
when "ge"
value1 >= value2
when "lt"
value1 < value2
when "gt"
value1 > value2
when "ne"
value1 != value2
end
end
end
81 changes: 0 additions & 81 deletions lib/puppet/indirector/inventory/yaml.rb
View file

This file was deleted.

1 change: 0 additions & 1 deletion lib/puppet/node.rb
View file
Expand Up @@ -3,7 +3,6 @@
# A class for managing nodes, including their facts and environment.
class Puppet::Node
require 'puppet/node/facts'
require 'puppet/node/inventory'
require 'puppet/node/environment'

# Set up indirection, so that nodes can be looked for in
Expand Down
7 changes: 0 additions & 7 deletions lib/puppet/node/inventory.rb
View file

This file was deleted.

214 changes: 214 additions & 0 deletions spec/unit/indirector/facts/yaml_spec.rb
View file
Expand Up @@ -23,4 +23,218 @@
it "should have its name set to :yaml" do
Puppet::Node::Facts::Yaml.name.should == :yaml
end

describe "#search" do
def assert_search_matches(matching, nonmatching, query)
request = Puppet::Indirector::Request.new(:inventory, :search, nil, query)

Dir.stubs(:glob).returns(matching.keys + nonmatching.keys)
[matching, nonmatching].each do |examples|
examples.each do |key, value|
YAML.stubs(:load_file).with(key).returns value
end
end
Puppet::Node::Facts::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
end

it "should return node names that match the search query options" do
assert_search_matches({
'/path/to/matching.yaml' => Puppet::Node::Facts.new("matchingnode", "architecture" => "i386", 'processor_count' => '4'),
'/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
},
{
"/path/to/nonmatching.yaml" => Puppet::Node::Facts.new("nonmatchingnode", "architecture" => "powerpc", 'processor_count' => '4'),
"/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
"/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '5'),
"/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3", 'processor_count' => '4'),
},
{'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
)
end

it "should return empty array when no nodes match the search query options" do
assert_search_matches({}, {
"/path/to/nonmatching.yaml" => Puppet::Node::Facts.new("nonmatchingnode", "architecture" => "powerpc", 'processor_count' => '10'),
"/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
"/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '5'),
"/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3", 'processor_count' => '4'),
},
{'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
)
end


it "should return node names that match the search query options with the greater than operator" do
assert_search_matches({
'/path/to/matching.yaml' => Puppet::Node::Facts.new("matchingnode", "architecture" => "i386", 'processor_count' => '5'),
'/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
},
{
"/path/to/nonmatching.yaml" => Puppet::Node::Facts.new("nonmatchingnode", "architecture" => "powerpc", 'processor_count' => '4'),
"/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '3'),
"/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3" ),
},
{'facts.processor_count.gt' => '4'}
)
end

it "should return node names that match the search query options with the less than operator" do
assert_search_matches({
'/path/to/matching.yaml' => Puppet::Node::Facts.new("matchingnode", "architecture" => "i386", 'processor_count' => '5'),
'/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
},
{
"/path/to/nonmatching.yaml" => Puppet::Node::Facts.new("nonmatchingnode", "architecture" => "powerpc", 'processor_count' => '50' ),
"/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '100'),
"/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3" ),
},
{'facts.processor_count.lt' => '50'}
)
end

it "should return node names that match the search query options with the less than or equal to operator" do
assert_search_matches({
'/path/to/matching.yaml' => Puppet::Node::Facts.new("matchingnode", "architecture" => "i386", 'processor_count' => '5'),
'/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
},
{
"/path/to/nonmatching.yaml" => Puppet::Node::Facts.new("nonmatchingnode", "architecture" => "powerpc", 'processor_count' => '100' ),
"/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '5000'),
"/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3" ),
},
{'facts.processor_count.le' => '50'}
)
end

it "should return node names that match the search query options with the greater than or equal to operator" do
assert_search_matches({
'/path/to/matching.yaml' => Puppet::Node::Facts.new("matchingnode", "architecture" => "i386", 'processor_count' => '100'),
'/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
},
{
"/path/to/nonmatching.yaml" => Puppet::Node::Facts.new("nonmatchingnode", "architecture" => "powerpc", 'processor_count' => '40'),
"/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
"/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3" ),
},
{'facts.processor_count.ge' => '50'}
)
end

it "should return node names that match the search query options with the not equal operator" do
assert_search_matches({
'/path/to/matching.yaml' => Puppet::Node::Facts.new("matchingnode", "architecture" => 'arm' ),
'/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
},
{
"/path/to/nonmatching.yaml" => Puppet::Node::Facts.new("nonmatchingnode", "architecture" => "i386" ),
"/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
"/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3" ),
},
{'facts.architecture.ne' => 'i386'}
)
end

def apply_timestamp(facts, timestamp)
facts.timestamp = timestamp
facts
end

it "should be able to query based on meta.timestamp.gt" do
assert_search_matches({
'/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
'/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
},
{
'/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
'/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
'/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
},
{'meta.timestamp.gt' => '2010-10-15'}
)
end

it "should be able to query based on meta.timestamp.le" do
assert_search_matches({
'/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
'/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
'/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
},
{
'/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
'/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
},
{'meta.timestamp.le' => '2010-10-15'}
)
end

it "should be able to query based on meta.timestamp.lt" do
assert_search_matches({
'/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
'/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
},
{
'/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
'/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
'/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
},
{'meta.timestamp.lt' => '2010-10-15'}
)
end

it "should be able to query based on meta.timestamp.ge" do
assert_search_matches({
'/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
'/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
'/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
},
{
'/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
'/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
},
{'meta.timestamp.ge' => '2010-10-15'}
)
end

it "should be able to query based on meta.timestamp.eq" do
assert_search_matches({
'/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
},
{
'/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
'/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
'/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
'/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
},
{'meta.timestamp.eq' => '2010-10-15'}
)
end

it "should be able to query based on meta.timestamp" do
assert_search_matches({
'/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
},
{
'/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
'/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
'/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
'/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
},
{'meta.timestamp' => '2010-10-15'}
)
end

it "should be able to query based on meta.timestamp.ne" do
assert_search_matches({
'/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
'/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
'/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
'/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
},
{
'/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
},
{'meta.timestamp.ne' => '2010-10-15'}
)
end
end
end

0 comments on commit c3baa28

Please sign in to comment.