chef-zero 1.4.0.alpha-x86-mingw32

data/lib/chef_zero/rspec.rb

@@ -0,0 +1,107 @@
+require 'tempfile'
+require 'chef_zero/server'
+require 'chef_zero/rest_request'
+
+module ChefZero
+  module RSpec
+    def self.server
+      @server
+    end
+    def self.server=(value)
+      @server = value
+    end
+    def self.client_key
+      @client_key
+    end
+    def self.client_key=(value)
+      @client_key = value
+    end
+    def self.request_log
+      @request_log ||= []
+    end
+    def self.clear_request_log
+      @request_log = []
+    end
+
+    def when_the_chef_server(description, *tags, &block)
+      context "When the Chef server #{description}", *tags do
+        before :each do
+          unless ChefZero::RSpec.server
+            # Set up configuration so that clients will point to the server
+            ChefZero::RSpec.server = ChefZero::Server.new(:port => 8889, :signals => false, :log_requests => true)
+            ChefZero::RSpec.client_key = Tempfile.new(['chef_zero_client_key', '.pem'])
+            ChefZero::RSpec.client_key.write(ChefZero::PRIVATE_KEY)
+            ChefZero::RSpec.client_key.close
+            # Start the server
+            ChefZero::RSpec.server.start_background
+            ChefZero::RSpec.server.on_response do |request, response|
+              ChefZero::RSpec.request_log << [ request, response ]
+            end
+          else
+            ChefZero::RSpec.server.clear_data
+          end
+          ChefZero::RSpec.clear_request_log
+
+          if defined?(Chef::Config)
+            @old_chef_server_url = Chef::Config.chef_server_url
+            @old_node_name = Chef::Config.node_name
+            @old_client_key = Chef::Config.client_key
+            Chef::Config.chef_server_url = ChefZero::RSpec.server.url
+            Chef::Config.node_name = 'admin'
+            Chef::Config.client_key = ChefZero::RSpec.client_key.path
+            Chef::Config.http_retry_count = 0
+          end
+        end
+
+        if defined?(Chef::Config)
+          after :each do
+            Chef::Config.chef_server_url = @old_chef_server_url
+            Chef::Config.node_name = @old_node_name
+            Chef::Config.client_key = @old_client_key
+          end
+        end
+
+        def self.client(name, client)
+          before(:each) { ChefZero::RSpec.server.load_data({ 'clients' => { name => client }}) }
+        end
+
+        def self.cookbook(name, version, cookbook, options = {})
+          before(:each) { ChefZero::RSpec.server.load_data({ 'cookbooks' => { "#{name}-#{version}" => cookbook.merge(options) }}) }
+        end
+
+        def self.data_bag(name, data_bag)
+          before(:each) { ChefZero::RSpec.server.load_data({ 'data' => { name => data_bag }}) }
+        end
+
+        def self.environment(name, environment)
+          before(:each) { ChefZero::RSpec.server.load_data({ 'environments' => { name => environment }}) }
+        end
+
+        def self.node(name, node)
+          before(:each) { ChefZero::RSpec.server.load_data({ 'nodes' => { name => node }}) }
+        end
+
+        def self.role(name, role)
+          before(:each) { ChefZero::RSpec.server.load_data({ 'roles' => { name => role }}) }
+        end
+
+        def self.user(name, user)
+          before(:each) { ChefZero::RSpec.server.load_data({ 'users' => { name => user }}) }
+        end
+
+#        after :each do
+#          if @@ChefZero::RSpec.server
+#            @@ChefZero::RSpec.server.stop
+#            @@ChefZero::RSpec.server = nil
+#          end
+#          if @@ChefZero::RSpec.client_key
+#            @@ChefZero::RSpec.client_key.unlink
+#            @@ChefZero::RSpec.client_key = nil
+#          end
+#        end
+
+        instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/chef_zero/server.rb

@@ -0,0 +1,309 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2012 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.
+#
+
+require 'openssl'
+require 'puma'
+require 'rubygems'
+require 'timeout'
+
+require 'chef_zero'
+require 'chef_zero/cookbook_data'
+require 'chef_zero/rest_router'
+require 'chef_zero/data_store/memory_store'
+require 'chef_zero/version'
+
+require 'chef_zero/endpoints/authenticate_user_endpoint'
+require 'chef_zero/endpoints/actors_endpoint'
+require 'chef_zero/endpoints/actor_endpoint'
+require 'chef_zero/endpoints/cookbooks_endpoint'
+require 'chef_zero/endpoints/cookbook_endpoint'
+require 'chef_zero/endpoints/cookbook_version_endpoint'
+require 'chef_zero/endpoints/data_bags_endpoint'
+require 'chef_zero/endpoints/data_bag_endpoint'
+require 'chef_zero/endpoints/data_bag_item_endpoint'
+require 'chef_zero/endpoints/rest_list_endpoint'
+require 'chef_zero/endpoints/environment_endpoint'
+require 'chef_zero/endpoints/environment_cookbooks_endpoint'
+require 'chef_zero/endpoints/environment_cookbook_endpoint'
+require 'chef_zero/endpoints/environment_cookbook_versions_endpoint'
+require 'chef_zero/endpoints/environment_nodes_endpoint'
+require 'chef_zero/endpoints/environment_recipes_endpoint'
+require 'chef_zero/endpoints/environment_role_endpoint'
+require 'chef_zero/endpoints/node_endpoint'
+require 'chef_zero/endpoints/principal_endpoint'
+require 'chef_zero/endpoints/role_endpoint'
+require 'chef_zero/endpoints/role_environments_endpoint'
+require 'chef_zero/endpoints/sandboxes_endpoint'
+require 'chef_zero/endpoints/sandbox_endpoint'
+require 'chef_zero/endpoints/searches_endpoint'
+require 'chef_zero/endpoints/search_endpoint'
+require 'chef_zero/endpoints/file_store_file_endpoint'
+require 'chef_zero/endpoints/not_found_endpoint'
+
+module ChefZero
+  class Server
+    DEFAULT_OPTIONS = {
+      :host => '127.0.0.1',
+      :port => 8889,
+      :log_level => :info,
+      :generate_real_keys => true
+    }.freeze
+
+    def initialize(options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+      @url = "http://#{options[:host]}:#{options[:port]}"
+      @generate_real_keys = options[:generate_real_keys]
+
+      ChefZero::Log.level = options[:log_level].to_sym
+
+      @server = Puma::Server.new(make_app, Puma::Events.new(STDERR, STDOUT))
+      @server.add_tcp_listener(options[:host], options[:port])
+
+      @data_store = options[:data_store] || DataStore::MemoryStore.new
+    end
+
+    attr_reader :server
+    attr_reader :data_store
+    attr_reader :url
+
+    include ChefZero::Endpoints
+
+    def start(options = {})
+      if options[:publish]
+        puts ">> Starting Chef Zero (v#{ChefZero::VERSION})..."
+        puts ">> Puma (v#{Puma::Const::PUMA_VERSION}) is listening at #{url}"
+        puts ">> Press CTRL+C to stop"
+      end
+
+      begin
+        thread = server.run.join
+      rescue Object, Interrupt
+        puts "\n>> Stopping Puma..."
+        server.stop(true) if running?
+      end
+    end
+
+    def start_background(wait = 5)
+      @thread = Thread.new {
+        begin
+          start
+        rescue
+          @server_error = $!
+          ChefZero::Log.error("#{$!.message}\n#{$!.backtrace.join("\n")}")
+        end
+      }
+
+      # Wait x seconds to make sure the server actually started
+      Timeout::timeout(wait) {
+        sleep(0.01) until running? || @server_error
+        raise @server_error if @server_error
+      }
+
+      # Give the user the thread, just in case they want it
+      @thread
+    end
+
+    def running?
+      !!server.running
+    end
+
+    def stop(wait = 5)
+      if @thread
+        @thread.join(wait)
+      else
+        server.stop(true)
+      end
+    rescue
+      ChefZero::Log.error "Server did not stop within #{wait} seconds. Killing..."
+      @thread.kill if @thread
+    ensure
+      @thread = nil
+    end
+
+    def gen_key_pair
+      if generate_real_keys?
+        private_key = OpenSSL::PKey::RSA.new(2048)
+        public_key = private_key.public_key.to_s
+        public_key.sub!(/^-----BEGIN RSA PUBLIC KEY-----/, '-----BEGIN PUBLIC KEY-----')
+        public_key.sub!(/-----END RSA PUBLIC KEY-----(\s+)$/, '-----END PUBLIC KEY-----\1')
+        [private_key.to_s, public_key]
+      else
+        [PRIVATE_KEY, PUBLIC_KEY]
+      end
+    end
+
+    def on_request(&block)
+      @on_request_proc = block
+    end
+
+    def on_response(&block)
+      @on_response_proc = block
+    end
+
+    # Load data in a nice, friendly form:
+    # {
+    #   'roles' => {
+    #     'desert' => '{ "description": "Hot and dry"' },
+    #     'rainforest' => { "description" => 'Wet and humid' }
+    #   },
+    #   'cookbooks' => {
+    #     'apache2-1.0.1' => {
+    #       'templates' => { 'default' => { 'blah.txt' => 'hi' }}
+    #       'recipes' => { 'default.rb' => 'template "blah.txt"' }
+    #       'metadata.rb' => 'depends "mysql"'
+    #     },
+    #     'apache2-1.2.0' => {
+    #       'templates' => { 'default' => { 'blah.txt' => 'lo' }}
+    #       'recipes' => { 'default.rb' => 'template "blah.txt"' }
+    #       'metadata.rb' => 'depends "mysql"'
+    #     },
+    #     'mysql' => {
+    #       'recipes' => { 'default.rb' => 'file { contents "hi" }' },
+    #       'metadata.rb' => 'version "1.0.0"'
+    #     }
+    #   }
+    # }
+    def load_data(contents)
+      %w(clients environments nodes roles users).each do |data_type|
+        if contents[data_type]
+          dejsonize_children(contents[data_type]).each_pair do |name, data|
+            data_store.set([data_type, name], data, :create)
+          end
+        end
+      end
+      if contents['data']
+        contents['data'].each_pair do |key, data_bag|
+          data_store.create_dir(['data'], key, :recursive)
+          dejsonize_children(data_bag).each do |item_name, item|
+            data_store.set(['data', key, item_name], item, :create)
+          end
+        end
+      end
+      if contents['cookbooks']
+        contents['cookbooks'].each_pair do |name_version, cookbook|
+          if name_version =~ /(.+)-(\d+\.\d+\.\d+)$/
+            cookbook_data = CookbookData.to_hash(cookbook, $1, $2)
+          else
+            cookbook_data = CookbookData.to_hash(cookbook, name_version)
+          end
+          raise "No version specified" if !cookbook_data[:version]
+          data_store.create_dir(['cookbooks'], cookbook_data[:cookbook_name], :recursive)
+          data_store.set(['cookbooks', cookbook_data[:cookbook_name], cookbook_data[:version]], JSON.pretty_generate(cookbook_data), :create)
+          cookbook_data.values.each do |files|
+            next unless files.is_a? Array
+            files.each do |file|
+              data_store.set(['file_store', 'checksums', file[:checksum]], get_file(cookbook, file[:path]), :create)
+            end
+          end
+        end
+      end
+    end
+
+    def clear_data
+      @data_store.clear
+    end
+
+    def request_handler(&block)
+      @request_handler = block
+    end
+
+    private
+
+    def make_app
+      router = RestRouter.new([
+        [ '/authenticate_user', AuthenticateUserEndpoint.new(self) ],
+        [ '/clients', ActorsEndpoint.new(self) ],
+        [ '/clients/*', ActorEndpoint.new(self) ],
+        [ '/cookbooks', CookbooksEndpoint.new(self) ],
+        [ '/cookbooks/*', CookbookEndpoint.new(self) ],
+        [ '/cookbooks/*/*', CookbookVersionEndpoint.new(self) ],
+        [ '/data', DataBagsEndpoint.new(self) ],
+        [ '/data/*', DataBagEndpoint.new(self) ],
+        [ '/data/*/*', DataBagItemEndpoint.new(self) ],
+        [ '/environments', RestListEndpoint.new(self) ],
+        [ '/environments/*', EnvironmentEndpoint.new(self) ],
+        [ '/environments/*/cookbooks', EnvironmentCookbooksEndpoint.new(self) ],
+        [ '/environments/*/cookbooks/*', EnvironmentCookbookEndpoint.new(self) ],
+        [ '/environments/*/cookbook_versions', EnvironmentCookbookVersionsEndpoint.new(self) ],
+        [ '/environments/*/nodes', EnvironmentNodesEndpoint.new(self) ],
+        [ '/environments/*/recipes', EnvironmentRecipesEndpoint.new(self) ],
+        [ '/environments/*/roles/*', EnvironmentRoleEndpoint.new(self) ],
+        [ '/nodes', RestListEndpoint.new(self) ],
+        [ '/nodes/*', NodeEndpoint.new(self) ],
+        [ '/principals/*', PrincipalEndpoint.new(self) ],
+        [ '/roles', RestListEndpoint.new(self) ],
+        [ '/roles/*', RoleEndpoint.new(self) ],
+        [ '/roles/*/environments', RoleEnvironmentsEndpoint.new(self) ],
+        [ '/roles/*/environments/*', EnvironmentRoleEndpoint.new(self) ],
+        [ '/sandboxes', SandboxesEndpoint.new(self) ],
+        [ '/sandboxes/*', SandboxEndpoint.new(self) ],
+        [ '/search', SearchesEndpoint.new(self) ],
+        [ '/search/*', SearchEndpoint.new(self) ],
+        [ '/users', ActorsEndpoint.new(self) ],
+        [ '/users/*', ActorEndpoint.new(self) ],
+
+        [ '/file_store/**', FileStoreFileEndpoint.new(self) ],
+      ])
+      router.not_found = NotFoundEndpoint.new
+
+      return proc do |env|
+        request = RestRequest.new(env)
+        if @on_request_proc
+          @on_request_proc.call(request)
+        end
+        response = nil
+        if @request_handler
+          response = @request_handler.call(request)
+        end
+        unless response
+          response = router.call(request)
+        end
+        if @on_response_proc
+          @on_response_proc.call(request, response)
+        end
+
+        # Puma expects the response to be an array (chunked responses). Since
+        # we are statically generating data, we won't ever have said chunked
+        # response, so fake it.
+        response[-1] = Array(response[-1])
+
+        response
+      end
+    end
+
+    def dejsonize_children(hash)
+      result = {}
+      hash.each_pair do |key, value|
+        result[key] = value.is_a?(Hash)  ? JSON.pretty_generate(value) : value
+      end
+      result
+    end
+
+    def get_file(directory, path)
+      value = directory
+      path.split('/').each do |part|
+        value = value[part]
+      end
+      value
+    end
+
+    def generate_real_keys?
+      !!@generate_real_keys
+    end
+  end
+end

data/lib/chef_zero/solr/query/binary_operator.rb

@@ -0,0 +1,53 @@
+module ChefZero
+  module Solr
+    module Query
+      class BinaryOperator
+        def initialize(left, operator, right)
+          @left = left
+          @operator = operator
+          @right = right
+        end
+
+        def to_s
+          "(#{left} #{operator} #{right})"
+        end
+
+        attr_reader :left
+        attr_reader :operator
+        attr_reader :right
+
+        def matches_doc?(doc)
+          case @operator
+          when 'AND'
+            left.matches_doc?(doc) && right.matches_doc?(doc)
+          when 'OR'
+            left.matches_doc?(doc) || right.matches_doc?(doc)
+          when '^'
+            left.matches_doc?(doc)
+          when ':'
+            if left.respond_to?(:literal_string) && left.literal_string
+              value = doc[left.literal_string]
+              right.matches_values?([value])
+            else
+              values = doc.matching_values { |key| left.matches_values?([key]) }
+              right.matches_values?(values)
+            end
+          end
+        end
+
+        def matches_values?(values)
+          case @operator
+          when 'AND'
+            left.matches_values?(values) && right.matches_values?(values)
+          when 'OR'
+            left.matches_values?(values) || right.matches_values?(values)
+          when '^'
+            left.matches_values?(values)
+          when ':'
+            raise ": does not work inside a : or term"
+          end
+        end
+      end
+    end
+  end
+end