chef-zero 0.9

data/lib/chef_zero/rest_error_response.rb

@@ -0,0 +1,11 @@
+module ChefZero
+  class RestErrorResponse < Exception
+    def initialize(response_code, error)
+      @response_code = response_code
+      @error = error
+    end
+
+    attr_reader :response_code
+    attr_reader :error
+  end
+end

data/lib/chef_zero/rest_request.rb

@@ -0,0 +1,42 @@
+require 'rack/request'
+
+module ChefZero
+  class RestRequest
+    def initialize(env)
+      @env = env
+    end
+
+    attr_reader :env
+
+    def base_uri
+      @base_uri ||= "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}#{env['SCRIPT_NAME']}"
+    end
+
+    def method
+      @env['REQUEST_METHOD']
+    end
+
+    def rest_path
+      @rest_path ||= env['PATH_INFO'].split('/').select { |part| part != "" }
+    end
+
+    def body=(body)
+      @body = body
+    end
+
+    def body
+      @body ||= env['rack.input'].read
+    end
+
+    def query_params
+      @query_params ||= begin
+        params = Rack::Request.new(env).GET
+        params.keys.each do |key|
+          params[key] = URI.unescape(params[key])
+        end
+        params
+      end
+    end
+  end
+end
+

data/lib/chef_zero/router.rb

@@ -0,0 +1,26 @@
+require 'chef/log'
+
+module ChefZero
+  class Router
+    def initialize(routes)
+      @routes = routes.map do |route, endpoint|
+        pattern = Regexp.new("^#{route.gsub('*', '[^/]*')}$")
+        [ pattern, endpoint ]
+      end
+    end
+
+    attr_reader :routes
+    attr_accessor :not_found
+
+    def call(env)
+      Chef::Log.debug "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}#{env['QUERY_STRING'] != '' ? "?" + env['QUERY_STRING'] : ''}"
+      clean_path = "/" + env['PATH_INFO'].split('/').select { |part| part != "" }.join("/")
+      routes.each do |route, endpoint|
+        if route.match(clean_path)
+          return endpoint.call(env)
+        end
+      end
+      not_found.call(env)
+    end
+  end
+end

data/lib/chef_zero/server.rb

@@ -0,0 +1,255 @@
+#
+# 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 'rubygems'
+require 'thin'
+require 'openssl'
+require 'chef_zero'
+require 'chef_zero/router'
+require 'timeout'
+require 'chef_zero/cookbook_data'
+
+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
+    def initialize(options = {})
+      @options = options
+      options[:host] ||= '127.0.0.1'
+      options[:port] ||= 80
+      options[:generate_real_keys] = true if !options.has_key?(:generate_real_keys)
+      @server = Thin::Server.new(options[:host], options[:port], make_app)
+      @generate_real_keys = options[:generate_real_keys]
+      @data = {
+        'clients' => {
+          'chef-validator' => '{ "validator": true }',
+          'chef-webui' => '{ "admin": true }'
+        },
+        'cookbooks' => {},
+        'data' => {},
+        'environments' => {
+          '_default' => '{ "description": "The default Chef environment" }'
+        },
+        'file_store' => {},
+        'nodes' => {},
+        'roles' => {},
+        'sandboxes' => {},
+        'users' => {
+          'admin' => '{ "admin": true }'
+        }
+      }
+    end
+
+    attr_reader :server
+    attr_reader :data
+    attr_reader :options
+    attr_reader :generate_real_keys
+
+    include ChefZero::Endpoints
+
+    def url
+      "http://#{options[:host]}:#{options[:port]}"
+    end
+
+    def start
+      server.start
+    end
+
+    def start_background(timeout = 5)
+      @thread = Thread.new do
+        begin
+          server.start
+        rescue
+          @server_error = $!
+          Chef::Log.error("#{$!.message}\n#{$!.backtrace.join("\n")}")
+        end
+      end
+      Timeout::timeout(timeout) do
+        until server.running? || @server_error
+          sleep(0.01)
+        end
+      end
+    end
+
+    def running?
+      server.running?
+    end
+
+    def stop(timeout = 5)
+      Timeout::timeout(timeout) do
+        server.stop
+        until !server.running? || !server_error
+          sleep(0.01)
+        end
+      end
+      if @thread
+        @thread.kill
+        @thread = nil
+      end
+    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
+
+    # 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])
+          data[data_type].merge!(contents[data_type])
+        end
+      end
+      if contents['data']
+        contents['data'].values.each do |data_bag|
+          dejsonize_children!(data_bag)
+        end
+        data['data'].merge!(contents['data'])
+      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['cookbooks'][cookbook_data[:cookbook_name]] = {} if !data['cookbooks'][cookbook_data[:cookbook_name]]
+          data['cookbooks'][cookbook_data[:cookbook_name]][cookbook_data[:version]] = JSON.pretty_generate(cookbook_data)
+          cookbook_data.values.each do |files|
+            next unless files.is_a? Array
+            files.each do |file|
+              data['file_store'][file[:checksum]] = get_file(cookbook, file[:path])
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def make_app
+      router = Router.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
+      router
+    end
+
+    def dejsonize_children!(hash)
+      hash.each_pair do |key, value|
+        hash[key] = JSON.pretty_generate(value) if value.is_a?(Hash)
+      end
+    end
+
+    def get_file(directory, path)
+      value = directory
+      path.split('/').each do |part|
+        value = value[part]
+      end
+      value
+    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

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

@@ -0,0 +1,23 @@
+require 'chef_zero/solr/query/regexpable_query'
+
+module ChefZero
+  module Solr
+    module Query
+      class Phrase < RegexpableQuery
+        def initialize(terms)
+          # Phrase is terms separated by whitespace
+          if terms.size == 0 && terms[0].literal_string
+            literal_string = terms[0].literal_string
+          else
+            literal_string = nil
+          end
+          super(terms.map { |term| term.regexp_string }.join("#{NON_WORD_CHARACTER}+"), literal_string)
+        end
+
+        def to_s
+          "Phrase(\"#{@regexp_string}\")"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module ChefZero
+  module Solr
+    module Query
+      class RangeQuery
+        def initialize(from, to, from_inclusive, to_inclusive)
+          @from = from
+          @to = to
+          @from_inclusive = from_inclusive
+          @to_inclusive = to_inclusive
+        end
+
+        def to_s
+          "#{@from_inclusive ? '[' : '{'}#{@from} TO #{@to}#{@to_inclusive ? '[' : '{'}"
+        end
+
+        def matches?(key, value)
+          case @from <=> value
+          when -1
+            return false
+          when 0
+            return false if !@from_inclusive
+          end
+          case @to <=> value
+          when 1
+            return false
+          when 0
+            return false if !@to_inclusive
+          end
+          return true
+        end
+      end
+    end
+  end
+end