chef-zero 1.4.0.alpha-x86-mingw32

data/lib/chef_zero/endpoints/search_endpoint.rb

@@ -0,0 +1,188 @@
+require 'json'
+require 'chef_zero/endpoints/rest_object_endpoint'
+require 'chef_zero/data_normalizer'
+require 'chef_zero/rest_error_response'
+require 'chef_zero/solr/solr_parser'
+require 'chef_zero/solr/solr_doc'
+
+module ChefZero
+  module Endpoints
+    # /search/INDEX
+    class SearchEndpoint < RestBase
+      def get(request)
+        results = search(request)
+        results['rows'] = results['rows'].map { |name,uri,value,search_value| value }
+        json_response(200, results)
+      end
+
+      def post(request)
+        full_results = search(request)
+        keys = JSON.parse(request.body, :create_additions => false)
+        partial_results = full_results['rows'].map do |name, uri, doc, search_value|
+          data = {}
+          keys.each_pair do |key, path|
+            if path.size > 0
+              value = search_value
+              path.each do |path_part|
+                value = value[path_part] if !value.nil?
+              end
+              data[key] = value
+            else
+              data[key] = nil
+            end
+          end
+          {
+            'url' => uri,
+            'data' => data
+          }
+        end
+        json_response(200, {
+          'rows' => partial_results,
+          'start' => full_results['start'],
+          'total' => full_results['total']
+        })
+      end
+
+      private
+
+      def search_container(request, index)
+        case index
+        when 'client'
+          [ ['clients'], Proc.new { |client, name| DataNormalizer.normalize_client(client, name) }, build_uri(request.base_uri, [ 'clients' ]) ]
+        when 'node'
+          [ ['nodes'], Proc.new { |node, name| DataNormalizer.normalize_node(node, name) }, build_uri(request.base_uri, [ 'nodes' ]) ]
+        when 'environment'
+          [ ['environments'], Proc.new { |environment, name| DataNormalizer.normalize_environment(environment, name) }, build_uri(request.base_uri, [ 'environments' ]) ]
+        when 'role'
+          [ ['roles'], Proc.new { |role, name| DataNormalizer.normalize_role(role, name) }, build_uri(request.base_uri, [ 'roles' ]) ]
+        else
+          [ ['data', index], Proc.new { |data_bag_item, id| DataNormalizer.normalize_data_bag_item(data_bag_item, index, id, 'DELETE') }, build_uri(request.base_uri, [ 'data', index ]) ]
+        end
+      end
+
+      def expand_for_indexing(value, index, id)
+        if index == 'node'
+          result = {}
+          deep_merge!(value['default'] || {}, result)
+          deep_merge!(value['normal'] || {}, result)
+          deep_merge!(value['override'] || {}, result)
+          deep_merge!(value['automatic'] || {}, result)
+          result['recipe'] = []
+          result['role'] = []
+          if value['run_list']
+            value['run_list'].each do |run_list_entry|
+              if run_list_entry =~ /^(recipe|role)\[(.*)\]/
+                result[$1] << $2
+              end
+            end
+          end
+          value.each_pair do |key, value|
+            result[key] = value unless %w(default normal override automatic).include?(key)
+          end
+          result
+
+        elsif !%w(client environment role).include?(index)
+          DataNormalizer.normalize_data_bag_item(value, index, id, 'GET')
+        else
+          value
+        end
+      end
+
+      def search(request)
+        # Extract parameters
+        index = request.rest_path[1]
+        query_string = request.query_params['q'] || '*:*'
+        solr_query = ChefZero::Solr::SolrParser.new(query_string).parse
+        sort_string = request.query_params['sort']
+        start = request.query_params['start']
+        start = start.to_i if start
+        rows = request.query_params['rows']
+        rows = rows.to_i if rows
+
+        # Get the search container
+        container, expander, base_uri = search_container(request, index)
+
+        # Search!
+        result = []
+        list_data(request, container).each do |name|
+          value = get_data(request, container + [name])
+          expanded = expander.call(JSON.parse(value, :create_additions => false), name)
+          result << [ name, build_uri(base_uri, [name]), expanded, expand_for_indexing(expanded, index, name) ]
+        end
+        result = result.select do |name, uri, value, search_value|
+          solr_query.matches_doc?(ChefZero::Solr::SolrDoc.new(search_value, name))
+        end
+        total = result.size
+
+        # Sort
+        if sort_string
+          sort_key, sort_order = sort_string.split(/\s+/, 2)
+          result = result.sort_by { |name,uri,value,search_value| ChefZero::Solr::SolrDoc.new(search_value, name)[sort_key] }
+          result = result.reverse if sort_order == "DESC"
+        end
+
+        # Paginate
+        if start
+          result = result[start..start+(rows||-1)]
+        end
+        {
+          'rows' => result,
+          'start' => start || 0,
+          'total' => total
+        }
+      end
+
+      private
+
+      # Deep Merge core documentation.
+      # deep_merge! method permits merging of arbitrary child elements. The two top level
+      # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
+      # of child elements. These child elements to not have to be of the same types.
+      # Where child elements are of the same type, deep_merge will attempt to merge them together.
+      # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
+      # the destination element with the contents of the source element at that level.
+      # So if you have two hashes like this:
+      #   source = {:x => [1,2,3], :y => 2}
+      #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+      #   dest.deep_merge!(source)
+      #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+      # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
+      # To avoid this, use "deep_merge" (no bang/exclamation mark)
+      def deep_merge!(source, dest)
+        # if dest doesn't exist, then simply copy source to it
+        if dest.nil?
+          dest = source; return dest
+        end
+
+        case source
+        when nil
+          dest
+        when Hash
+          source.each do |src_key, src_value|
+            if dest.kind_of?(Hash)
+              if dest[src_key]
+                dest[src_key] = deep_merge!(src_value, dest[src_key])
+              else # dest[src_key] doesn't exist so we take whatever source has
+                dest[src_key] = src_value
+              end
+            else # dest isn't a hash, so we overwrite it completely
+              dest = source
+            end
+          end
+        when Array
+          if dest.kind_of?(Array)
+            dest = dest | source
+          else
+            dest = source
+          end
+        when String
+          dest = source
+        else # src_hash is not an array or hash, so we'll have to overwrite dest
+          dest = source
+        end
+        dest
+      end # deep_merge!
+
+    end
+  end
+end

data/lib/chef_zero/endpoints/searches_endpoint.rb

@@ -0,0 +1,18 @@
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /search
+    class SearchesEndpoint < RestBase
+      def get(request)
+        # Get the result
+        result_hash = {}
+        indices = (%w(client environment node role) + data_store.list(['data'])).sort
+        indices.each do |index|
+          result_hash[index] = build_uri(request.base_uri, request.rest_path + [index])
+        end
+        json_response(200, result_hash)
+      end
+    end
+  end
+end

data/lib/chef_zero/log.rb

@@ -0,0 +1,7 @@
+require 'mixlib/log'
+
+module ChefZero
+  class Log
+    extend Mixlib::Log
+  end
+end

data/lib/chef_zero/rest_base.rb

@@ -0,0 +1,133 @@
+require 'chef_zero/rest_request'
+require 'chef_zero/rest_error_response'
+require 'chef_zero/data_store/data_not_found_error'
+
+module ChefZero
+  class RestBase
+    def initialize(server)
+      @server = server
+    end
+
+    attr_reader :server
+
+    def data_store
+      server.data_store
+    end
+
+    def call(request)
+      method = request.method.downcase.to_sym
+      if !self.respond_to?(method)
+        accept_methods = [:get, :put, :post, :delete].select { |m| self.respond_to?(m) }
+        accept_methods_str = accept_methods.map { |m| m.to_s.upcase }.join(', ')
+        return [405, {"Content-Type" => "text/plain", "Allow" => accept_methods_str}, "Bad request method for '#{request.env['REQUEST_PATH']}': #{request.env['REQUEST_METHOD']}"]
+      end
+      if json_only && request.env['HTTP_ACCEPT'] && !request.env['HTTP_ACCEPT'].split(';').include?('application/json')
+        return [406, {"Content-Type" => "text/plain"}, "Must accept application/json"]
+      end
+      # Dispatch to get()/post()/put()/delete()
+      begin
+        self.send(method, request)
+      rescue RestErrorResponse => e
+        error(e.response_code, e.error)
+      end
+    end
+
+    def json_only
+      true
+    end
+
+    def get_data(request, rest_path=nil, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.get(rest_path, request)
+      rescue DataStore::DataNotFoundError
+        if options.include?(:nil)
+          nil
+        else
+          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, rest_path)}")
+        end
+      end
+    end
+
+    def list_data(request, rest_path=nil)
+      rest_path ||= request.rest_path
+      begin
+        data_store.list(rest_path)
+      rescue DataStore::DataNotFoundError
+        raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, rest_path)}")
+      end
+    end
+
+    def delete_data(request, rest_path=nil)
+      rest_path ||= request.rest_path
+      begin
+        data_store.delete(rest_path)
+      rescue DataStore::DataNotFoundError
+        raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
+      end
+    end
+
+    def delete_data_dir(request, rest_path, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.delete_dir(rest_path)
+      rescue DataStore::DataNotFoundError
+        raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
+      end
+    end
+
+    def set_data(request, rest_path, data, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.set(rest_path, request.body, *options)
+      rescue DataStore::DataNotFoundError
+        raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
+      end
+    end
+
+    def create_data(request, rest_path, name, data, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.create(rest_path, name, data, *options)
+      rescue DataStore::DataNotFoundError
+        raise RestErrorResponse.new(404, "Parent not found: #{build_uri(request.base_uri, request.rest_path)}")
+      rescue DataStore::DataAlreadyExistsError
+        raise RestErrorResponse.new(409, "Object already exists: #{build_uri(request.base_uri, request.rest_path + [name])}")
+      end
+    end
+
+    def exists_data?(request, rest_path=nil)
+      rest_path ||= request.rest_path
+      data_store.exists?(rest_path)
+    end
+
+    def exists_data_dir?(request, rest_path=nil)
+      rest_path ||= request.rest_path
+      data_store.exists_dir?(rest_path)
+    end
+
+    def error(response_code, error)
+      json_response(response_code, {"error" => [error]})
+    end
+
+    def json_response(response_code, json)
+      already_json_response(response_code, JSON.pretty_generate(json))
+    end
+
+    def already_json_response(response_code, json_text)
+      [response_code, {"Content-Type" => "application/json"}, json_text]
+    end
+
+    def build_uri(base_uri, rest_path)
+      RestBase::build_uri(base_uri, rest_path)
+    end
+
+    def self.build_uri(base_uri, rest_path)
+      "#{base_uri}/#{rest_path.join('/')}"
+    end
+
+    def populate_defaults(request, response)
+      response
+    end
+  end
+end

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,56 @@
+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
+
+    def to_s
+      result = "#{method} #{rest_path.join('/')}"
+      if query_params.size > 0
+        result << "?#{query_params.map { |k,v| "#{k}=#{v}" }.join('&') }"
+      end
+      if body.chomp != ''
+        result << "\n--- #{method} BODY ---\n"
+        result << body
+        result << "\n" if !body.end_with?("\n")
+        result << "--- END #{method} BODY ---"
+      end
+      result
+    end
+  end
+end
+

data/lib/chef_zero/rest_router.rb

@@ -0,0 +1,44 @@
+module ChefZero
+  class RestRouter
+    def initialize(routes)
+      @routes = routes.map do |route, endpoint|
+        if route =~ /\*\*$/
+          pattern = Regexp.new("^#{route[0..-3].gsub('*', '[^/]*')}")
+        else
+          pattern = Regexp.new("^#{route.gsub('*', '[^/]*')}$")
+        end
+        [ pattern, endpoint ]
+      end
+    end
+
+    attr_reader :routes
+    attr_accessor :not_found
+
+    def call(request)
+      begin
+        ChefZero::Log.debug(request)
+
+        clean_path = "/" + request.rest_path.join("/")
+
+        response = find_endpoint(clean_path).call(request)
+        ChefZero::Log.debug([
+          "",
+          "--- RESPONSE (#{response[0]}) ---",
+          response[2],
+          "--- END RESPONSE ---",
+        ].join("\n"))
+        return response
+      rescue
+        ChefZero::Log.error("#{$!.inspect}\n#{$!.backtrace.join("\n")}")
+        [500, {"Content-Type" => "text/plain"}, "Exception raised!  #{$!.inspect}\n#{$!.backtrace.join("\n")}"]
+      end
+    end
+
+    private
+
+      def find_endpoint(clean_path)
+        _, endpoint = routes.find { |route, endpoint| route.match(clean_path) }
+        endpoint || not_found
+      end
+  end
+end