cloud-toaster 1.1.2

data/chef/cookbooks/chef-solo-search/README.md

@@ -0,0 +1,143 @@
+# chef-solo-search
+
+[![Build Status](https://travis-ci.org/edelight/chef-solo-search.png?branch=master)](https://travis-ci.org/edelight/chef-solo-search)
+
+Chef-solo-search is a cookbook library that adds data bag search powers
+to Chef Solo. Data bag support was added to Chef Solo by Chef 0.10.4.
+Please see *Supported queries* for a list of query types which are supported.
+
+## Requirements
+
+    * ruby >= 1.8
+    * ruby-chef >= 0.10.4
+
+## Installation
+
+In order to use this extension, create a (dummy-) cookbook and add a directory
+called *libraries*. Next copy *libraries/search.rb* and *libraries/parser.rb* to the newly created directory.
+Now you have to make sure chef-solo knows about data bags, therefore add
+
+    data_bag_path "<node_work_path>/data_bags"
+
+to the config file of chef-solo (defaults to /etc/chef/solo.rb).
+
+The same for your roles, add
+
+    role_path "<node_work_path>/roles"
+
+## Supported queries
+
+The search methods supports a basic sub-set of the lucene query language.
+Sample supported queries are:
+
+### General queries:
+
+    search(:users, "*:*")
+    search(:users)
+    search(:users, nil)
+        getting all items in ':users'
+    search(:users, "username:*")
+    search(:users, "username:[* TO *]")
+        getting all items from ':users' which have a 'username' attribute
+    search(:users, "(NOT username:*)")
+    search(:users, "(NOT username:[* TO *])")
+        getting all items from ':users' which don't have a 'username' attribute
+
+### Queries on attributes with string values:
+
+    search(:users, "username:speedy")
+        getting all items from ':users' with username equals 'speedy'
+    search(:users, "NOT username:speedy")
+        getting all items from ':users' with username is unequal to 'speedy'
+    search(:users, "username:spe*")
+        getting all items which 'username'-value begins with 'spe'
+
+### Queries on attributes with array values:
+
+    search(:users, "children:tom")
+        getting all items which 'children' attribute contains 'tom'
+    search(:users, "children:t*")
+        getting all items which have at least one element in 'children'
+        which starts with 't'
+
+### Queries on attributes with boolean values:
+
+    search(:users, "married:true")
+
+### Queries in attributes with integer values:
+
+    search(:users, "age:35")
+
+### OR conditions in queries:
+
+    search(:users, "age:42 OR age:22")
+
+### AND conditions in queries:
+
+    search(:users, "married:true AND age:35")
+
+### NOT condition in queries:
+
+    search(:users, "children:tom NOT gender:female")
+
+### More complex queries:
+
+    search(:users, "children:tom NOT gender:female AND age:42")
+
+
+## Supported Objects
+The search methods have support for 'roles', 'nodes' and 'databags'.
+
+### Roles
+You can use the standard role objects in json form and put them into your role path
+
+    {
+      "name": "monitoring",
+      "default_attributes": { },
+      "override_attributes": { },
+      "json_class": "Chef::Role",
+      "description": "This is just a monitoring role, no big deal.",
+          "run_list": [
+          ],
+      "chef_type": "role"
+
+
+### Nodes
+Nodes are injected through a databag called 'node'.  Create a databag called 'node' and put your json files there
+You can use the standard node objects in json form.
+
+    {
+      "id": "vagrant",
+      "name": "vagrant-vm",
+      "chef_environment": "_default",
+      "json_class": "Chef::Node",
+      "automatic": {
+        "hostname": "vagrant.vm",
+        "os": "centos"
+      },
+      "normal": {
+      },
+      "chef_type": "node",
+      "default": {
+      },
+      "override": {
+      },
+      "run_list": [
+        "role[monitoring]"
+      ]
+    }
+
+### Databags
+You can use the standard databag objects in json form
+
+    {
+      "id": "my-ssh",
+      "hostgroup_name": "all",
+      "command_line": "$USER1$/check_ssh $HOSTADDRESS$"
+    }
+
+## Running tests
+
+Running tests is as simple as:
+
+    % rake test

data/chef/cookbooks/chef-solo-search/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.pattern = "tests/test_*.rb"
+  t.libs    = %w(libraries)
+end
+
+desc "Run tests"
+task :default => :test

data/chef/cookbooks/chef-solo-search/libraries/search/overrides.rb

@@ -0,0 +1,100 @@
+#
+# Copyright 2011, edelight GmbH
+#
+# Authors:
+#       Markus Korn <markus.korn@edelight.de>
+#       Seth Chisamore <schisamo@opscode.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Search
+  module Overrides
+    # Overwrite the search method of recipes to operate locally by using
+    # data found in data_bags.
+    # Only very basic lucene syntax is supported and also sorting the result
+    # is not implemented, if this search method does not support a given query
+    # an exception is raised.
+    # This search() method returns a block iterator or an Array, depending
+    # on how this method is called.
+    def search(obj, query=nil, sort=nil, start=0, rows=1000, &block)
+      if !sort.nil?
+        raise "Sorting search results is not supported"
+      end
+      _query = Query.parse(query)
+      if _query.nil?
+        raise "Query #{query} is not supported"
+      end
+      _result = []
+
+      case obj
+      when :node
+        nodes = search_nodes(_query, start, rows, &block)
+        _result += nodes
+      when :role
+        roles = search_roles(_query, start, rows, &block)
+         _result += roles
+      else
+        bags = search_data_bag(_query, obj, start, rows, &block)
+        _result += bags
+      end
+
+
+      if block_given?
+        pos = 0
+        while (pos >= start and pos < (start + rows) and pos < _result.size)
+          yield _result[pos]
+          pos += 1
+        end
+      else
+        return _result.slice(start, rows)
+      end
+    end
+
+    def search_nodes(_query, start, rows, &block)
+      _result = []
+      node_path = Chef::Config[:nodes_path] || File.join(Chef::Config[:data_bag_path], "node")
+      Dir.glob(File.join(node_path, "*.json")).map do |f|
+        # parse and hashify the node
+        node = Chef::JSONCompat.from_json(IO.read(f))
+        if _query.match(node.to_hash)
+          _result << node
+        end
+      end
+      return _result
+    end
+
+    def search_roles(_query, start, rows, &block)
+      _result = []
+      Dir.glob(File.join(Chef::Config[:role_path], "*.json")).map do |f|
+        # parse and hashify the role
+        role = Chef::JSONCompat.from_json(IO.read(f))
+        if _query.match(role.to_hash)
+          _result << role
+        end
+      end
+      return _result
+    end
+
+    def search_data_bag(_query, bag_name, start, rows, &block)
+      _result = []
+      data_bag(bag_name.to_s).each do |bag_item_id|
+        bag_item = data_bag_item(bag_name.to_s, bag_item_id)
+        if _query.match(bag_item)
+          _result << bag_item
+        end
+      end
+      return _result
+    end
+  end
+end

data/chef/cookbooks/chef-solo-search/libraries/search/parser.rb

@@ -0,0 +1,222 @@
+#
+# Copyright 2011, edelight GmbH
+#
+# Authors:
+#       Markus Korn <markus.korn@edelight.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/solr_query/query_transform'
+
+# mock QueryTransform such that we can access the location of the lucene grammar
+class Chef
+  class SolrQuery
+    class QueryTransform
+      def self.base_path
+        class_variable_get(:@@base_path)
+      end
+    end
+  end
+end
+
+def build_flat_hash(hsh, prefix="")
+  result = {}
+  hsh.each_pair do |key, value|
+    if value.kind_of?(Hash)
+      result.merge!(build_flat_hash(value, "#{prefix}#{key}_"))
+    else
+      result[prefix+key] = value
+    end
+  end
+  result
+end
+
+module Lucene
+
+  class Term < Treetop::Runtime::SyntaxNode
+    # compares a query value and a value, tailing '*'-wildcards are handled correctly.
+    # Value can either be a string or an array, all other objects are converted
+    # to a string and than checked.
+    def match( value )
+      if value.is_a?(Array)
+        value.any?{ |x| self.match(x) }
+      else
+        File.fnmatch(self.text_value, value.to_s)
+      end
+    end
+  end
+
+  class Field < Treetop::Runtime::SyntaxNode
+    # simple field -> value matches, supporting tailing '*'-wildcards in keys
+    # as well as in values
+    def match( item )
+      keys = self.elements[0].match(item)
+      if keys.nil?
+        false
+      else
+        keys.any?{ |key| self.elements[1].match(item[key]) }
+      end
+    end
+  end
+
+  # we don't support range matches
+  # range of integers would be easy to implement
+  # but string ranges are hard
+  class FiledRange < Treetop::Runtime::SyntaxNode
+  end
+
+  # we handle '[* TO *]' as a special case since it is common in
+  # cookbooks for matching the existence of keys
+  class InclFieldRange
+    def match(item)
+      field = self.elements[0].text_value
+      range_start = self.elements[1].transform
+      range_end = self.elements[2].transform
+      if range_start == "*" and range_end == "*"
+        !!item[field]
+      else
+        raise "Ranges not really supported yet"
+      end
+    end
+  end
+
+  class ExclFieldRange < FieldRange
+  end
+
+  class RangeValue < Treetop::Runtime::SyntaxNode
+  end
+
+  class FieldName < Treetop::Runtime::SyntaxNode
+    def match( item )
+      if self.text_value.count("_") > 0
+        item.merge!(build_flat_hash(item))
+      end
+      if self.text_value.end_with?("*")
+        part = self.text_value.chomp("*")
+        item.keys.collect{ |key| key.start_with?(part)? key: nil}.compact
+      else
+        if item.has_key?(self.text_value)
+          [self.text_value,]
+        else
+          nil
+        end
+      end
+    end
+  end
+
+  class Body < Treetop::Runtime::SyntaxNode
+    def match( item )
+      self.elements[0].match( item )
+    end
+  end
+
+  class Group < Treetop::Runtime::SyntaxNode
+    def match( item )
+      self.elements[0].match(item)
+    end
+  end
+
+  class BinaryOp < Treetop::Runtime::SyntaxNode
+    def match( item )
+      self.elements[1].match(
+        self.elements[0].match(item),
+        self.elements[2].match(item)
+      )
+    end
+  end
+
+  class OrOperator < Treetop::Runtime::SyntaxNode
+    def match( cond1, cond2 )
+      cond1 or cond2
+    end
+  end
+
+  class AndOperator < Treetop::Runtime::SyntaxNode
+    def match( cond1, cond2 )
+      cond1 and cond2
+    end
+  end
+
+  # we don't support fuzzy string matching
+  class FuzzyOp < Treetop::Runtime::SyntaxNode
+  end
+
+  class BoostOp < Treetop::Runtime::SyntaxNode
+  end
+
+  class FuzzyParam < Treetop::Runtime::SyntaxNode
+  end
+
+  class UnaryOp < Treetop::Runtime::SyntaxNode
+    def match( item )
+      self.elements[0].match(
+        self.elements[1].match(item)
+      )
+    end
+  end
+
+  class NotOperator < Treetop::Runtime::SyntaxNode
+    def match( cond )
+      not cond
+    end
+  end
+
+  class RequiredOperator < Treetop::Runtime::SyntaxNode
+  end
+
+  class ProhibitedOperator < Treetop::Runtime::SyntaxNode
+  end
+
+  class Phrase < Treetop::Runtime::SyntaxNode
+    # a quoted ::Term
+    def match( value )
+      self.elements[0].match(value)
+    end
+  end
+end
+
+class Query
+  # initialize the parser by using the grammar shipped with chef
+  @@grammar = File.join(Chef::SolrQuery::QueryTransform.base_path, "lucene.treetop")
+  Treetop.load(@@grammar)
+  @@parser = LuceneParser.new
+
+  def self.parse(data)
+    # parse the query into a query tree
+    if data.nil?
+      data = "*:*"
+    end
+    tree = @@parser.parse(data)
+    if tree.nil?
+      msg = "Parse error at offset: #{@@parser.index}\n"
+      msg += "Reason: #{@@parser.failure_reason}"
+      raise "Query #{data} is not supported: #{msg}"
+    end
+    self.clean_tree(tree)
+    tree
+  end
+
+  private
+
+  def self.clean_tree(root_node)
+    # remove all SyntaxNode elements from the tree, we don't need them as
+    # the related ruby class already knowns what to do.
+    return if root_node.elements.nil?
+    root_node.elements.delete_if do |node|
+      node.class.name == "Treetop::Runtime::SyntaxNode"
+    end
+    root_node.elements.each { |node| self.clean_tree(node) }
+  end
+end
+

data/chef/cookbooks/chef-solo-search/libraries/search.rb

@@ -0,0 +1,75 @@
+#
+# Copyright 2011, edelight GmbH
+#
+# Authors:
+#       Markus Korn <markus.korn@edelight.de>
+#       Seth Chisamore <schisamo@opscode.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+puts "DEBUG: Chef::Config[:solo] = #{Chef::Config[:solo]}"
+if Chef::Config[:solo]
+
+  # add currrent dir to load path
+  $: << File.dirname(__FILE__)
+
+  # All chef/solr_query/* classes were removed in Chef 11; Load vendored copy
+  # that ships with this cookbook
+  $: << File.expand_path("vendor", File.dirname(__FILE__)) if Chef::VERSION.to_i >= 11
+
+  # Ensure the treetop gem is installed and available
+  begin
+    require 'treetop'
+  rescue LoadError
+    run_context = Chef::RunContext.new(Chef::Node.new, {}, Chef::EventDispatch::Dispatcher.new)
+    chef_gem = Chef::Resource::ChefGem.new("treetop", run_context)
+    chef_gem.version('>= 1.4')
+    chef_gem.run_action(:install)
+  end
+
+  require 'search/overrides'
+  require 'search/parser'
+
+  module Search; class Helper; end; end
+
+  # The search and data_bag related methods moved form `Chef::Mixin::Language`
+  # to `Chef::DSL::DataQuery` in Chef 11.
+  if Chef::VERSION.to_i >= 11
+    module Chef::DSL::DataQuery
+      def self.included(base)
+        base.send(:include, Search::Overrides)
+      end
+    end
+    Search::Helper.send(:include, Chef::DSL::DataQuery)
+  else
+    module Chef::Mixin::Language
+      def self.included(base)
+        base.send(:include, Search::Overrides)
+      end
+    end
+    Search::Helper.send(:include, Chef::Mixin::Language)
+  end
+
+  class Chef
+    class Search
+      class Query
+        def initialize(*args)
+        end
+        def search(*args, &block)
+          ::Search::Helper.new.search(*args, &block)
+        end
+      end
+    end
+  end
+end

data/chef/cookbooks/chef-solo-search/libraries/vendor/chef/solr_query/lucene.treetop

@@ -0,0 +1,150 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright (c) 2010-2011 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+grammar Lucene
+
+  rule body
+    (expression / space)* <Body>
+  end
+
+  rule expression
+    operation / group / field / field_range / term / string
+  end
+
+  rule term
+    keyword valid_letter+ <Term> / !keyword !"?" valid_letter <Term>
+  end
+
+  rule field
+    field_name ":" (term/string/group) <Field>
+  end
+
+  rule field_range
+    field_name ":" "[" range_value " TO " range_value "]" <InclFieldRange>
+    /
+    field_name ":" "{" range_value " TO " range_value "}" <ExclFieldRange>
+  end
+
+  rule field_name
+    !keyword valid_letter+ <FieldName>
+  end
+
+  rule range_value
+    valid_letter+ <RangeValue> / "*" <RangeValue>
+  end
+
+  rule group
+    space? '(' body ')' space? <Group>
+  end
+
+  rule operation
+    binary_op / unary_op / fuzzy_op / boost_op
+  end
+
+  rule unary_op
+    not_op / required_op / prohibited_op
+  end
+
+  rule binary_op
+    (group / field / field_range / term) space? boolean_operator space+ body <BinaryOp>
+  end
+
+  rule boolean_operator
+    and_operator / or_operator
+  end
+
+  rule and_operator
+    'AND' <AndOperator> / '&&' <AndOperator>
+  end
+
+  rule or_operator
+    'OR' <OrOperator> / '||' <OrOperator>
+  end
+
+  rule not_op
+    not_operator space (group / field / field_range / term / string) <UnaryOp>
+    /
+    bang_operator space? (group / field / field_range / term / string) <UnaryOp>
+  end
+
+  rule not_operator
+    'NOT' <NotOperator>
+  end
+
+  rule bang_operator
+    '!' <NotOperator>
+  end
+
+  rule required_op
+    !valid_letter required_operator (term/string) <UnaryOp>
+    /
+    required_operator (term/string) <UnaryOp>
+  end
+
+  rule required_operator
+    '+' <RequiredOperator>
+  end
+
+  rule prohibited_op
+    !valid_letter prohibited_operator (field/field_range/term/string) <UnaryOp>
+  end
+
+  rule prohibited_operator
+    '-' <ProhibitedOperator>
+  end
+
+  rule boost_op
+    (term/string) '^' fuzzy_param <BoostOp>
+  end
+
+  rule fuzzy_op
+    (term/string) '~' fuzzy_param? (space / !valid_letter) <FuzzyOp>
+  end
+
+  rule fuzzy_param
+    [0-9] '.'? [0-9] <FuzzyParam> / [0-9]+ <FuzzyParam>
+  end
+
+  rule string
+    '"' term (space term)* '"' <Phrase>
+  end
+
+  rule keyword
+    'AND' / 'OR' / 'NOT'
+  end
+
+  rule valid_letter
+    start_letter+ ([a-zA-Z0-9@*?_.-] / '\\' special_char)*
+  end
+
+  rule start_letter
+    [a-zA-Z0-9@._*] / '\\' special_char
+  end
+
+  rule end_letter
+    [a-zA-Z0-9*?_.] / '\\' special_char
+  end
+
+  rule special_char
+    [-+&|!(){}\[\]^"~*?:\\]
+  end
+
+  rule space
+    [\s]+
+  end
+end