chef-zero 0.9

data/lib/chef_zero/endpoints/principal_endpoint.rb

@@ -0,0 +1,30 @@
+require 'json'
+require 'chef_zero'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /principals/NAME
+    class PrincipalEndpoint < RestBase
+      def get(request)
+        name = request.rest_path[-1]
+        json = data['users'][name]
+        if json
+          type = 'user'
+        else
+          json = data['clients'][name]
+          type = 'client'
+        end
+        if json
+          json_response(200, {
+            'name' => name,
+            'type' => type,
+            'public_key' => JSON.parse(json)['public_key'] || PUBLIC_KEY
+          })
+        else
+          error(404, 'Principal not found')
+        end
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/rest_list_endpoint.rb

@@ -0,0 +1,41 @@
+require 'json'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # Typical REST list endpoint (/roles or /data/BAG)
+    class RestListEndpoint < RestBase
+      def initialize(server, identity_key = 'name')
+        super(server)
+        @identity_key = identity_key
+      end
+
+      attr_reader :identity_key
+
+      def get(request)
+        # Get the result
+        result_hash = {}
+        get_data(request).keys.sort.each do |name|
+          result_hash[name] = "#{build_uri(request.base_uri, request.rest_path + [name])}"
+        end
+        json_response(200, result_hash)
+      end
+
+      def post(request)
+        container = get_data(request)
+        contents = request.body
+        key = get_key(contents)
+        if container[key]
+          error(409, 'Object already exists')
+        else
+          container[key] = contents
+          json_response(201, {'uri' => "#{build_uri(request.base_uri, request.rest_path + [key])}"})
+        end
+      end
+
+      def get_key(contents)
+        JSON.parse(contents, :create_additions => false)[identity_key]
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/rest_object_endpoint.rb

@@ -0,0 +1,65 @@
+require 'json'
+require 'chef_zero/rest_base'
+require 'chef_zero/rest_error_response'
+
+module ChefZero
+  module Endpoints
+    # Typical REST leaf endpoint (/roles/NAME or /data/BAG/NAME)
+    class RestObjectEndpoint < RestBase
+      def initialize(server, identity_key = 'name')
+        super(server)
+        @identity_key = identity_key
+      end
+
+      attr_reader :identity_key
+
+      def get(request)
+        already_json_response(200, populate_defaults(request, get_data(request)))
+      end
+
+      def put(request)
+        # We grab the old body to trigger a 404 if it doesn't exist
+        old_body = get_data(request)
+        request_json = JSON.parse(request.body, :create_additions => false)
+        key = request_json[identity_key] || request.rest_path[-1]
+        container = get_data(request, request.rest_path[0..-2])
+        # If it's a rename, check for conflict and delete the old value
+        rename = key != request.rest_path[-1]
+        if rename
+          if container.has_key?(key)
+            return error(409, "Cannot rename '#{request.rest_path[-1]}' to '#{key}': '#{key}' already exists")
+          end
+          container.delete(request.rest_path[-1])
+        end
+        container[key] = request.body
+        already_json_response(200, populate_defaults(request, request.body))
+      end
+
+      def delete(request)
+        key = request.rest_path[-1]
+        container = get_data(request, request.rest_path[0..-2])
+        if !container.has_key?(key)
+          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
+        end
+        result = container[key]
+        container.delete(key)
+        already_json_response(200, populate_defaults(request, result))
+      end
+
+      def patch_request_body(request)
+        container = get_data(request, request.rest_path[0..-2])
+        existing_value = container[request.rest_path[-1]]
+        if existing_value
+          request_json = JSON.parse(request.body, :create_additions => false)
+          existing_json = JSON.parse(existing_value, :create_additions => false)
+          merged_json = existing_json.merge(request_json)
+          if merged_json.size > request_json.size
+            return JSON.pretty_generate(merged_json)
+          end
+        end
+        request.body
+      end
+    end
+  end
+end
+

data/lib/chef_zero/endpoints/role_endpoint.rb

@@ -0,0 +1,16 @@
+require 'json'
+require 'chef_zero/endpoints/rest_object_endpoint'
+require 'chef_zero/data_normalizer'
+
+module ChefZero
+  module Endpoints
+    # /roles/NAME
+    class RoleEndpoint < RestObjectEndpoint
+      def populate_defaults(request, response_json)
+        role = JSON.parse(response_json, :create_additions => false)
+        role = DataNormalizer.normalize_role(role, request.rest_path[1])
+        JSON.pretty_generate(role)
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/role_environments_endpoint.rb

@@ -0,0 +1,14 @@
+require 'json'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /roles/NAME/environments
+    class RoleEnvironmentsEndpoint < RestBase
+      def get(request)
+        role = JSON.parse(get_data(request, request.rest_path[0..1]), :create_additions => false)
+        json_response(200, [ '_default' ] + (role['env_run_lists'].keys || []))
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/sandbox_endpoint.rb

@@ -0,0 +1,22 @@
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /sandboxes/ID
+    class SandboxEndpoint < RestBase
+      def put(request)
+        existing_sandbox = get_data(request, request.rest_path)
+        data['sandboxes'].delete(request.rest_path[1])
+        time_str = existing_sandbox[:create_time].strftime('%Y-%m-%dT%H:%M:%S%z')
+        time_str = "#{time_str[0..21]}:#{time_str[22..23]}"
+        json_response(200, {
+          :guid => request.rest_path[1],
+          :name => request.rest_path[1],
+          :checksums => existing_sandbox[:checksums],
+          :create_time => time_str,
+          :is_completed => true
+        })
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/sandboxes_endpoint.rb

@@ -0,0 +1,44 @@
+require 'json'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /sandboxes
+    class SandboxesEndpoint < RestBase
+      def initialize(server)
+        super(server)
+        @next_id = 1
+      end
+
+      def post(request)
+        sandbox_checksums = []
+
+        needed_checksums = JSON.parse(request.body, :create_additions => false)['checksums']
+        result_checksums = {}
+        needed_checksums.keys.each do |needed_checksum|
+          if data['file_store'].has_key?(needed_checksum)
+            result_checksums[needed_checksum] = { :needs_upload => false }
+          else
+            result_checksums[needed_checksum] = {
+              :needs_upload => true,
+              :url => build_uri(request.base_uri, ['file_store', needed_checksum])
+            }
+            sandbox_checksums << needed_checksum
+          end
+        end
+
+        id = @next_id.to_s
+        @next_id+=1
+
+        data['sandboxes'][id] = { :create_time => Time.now.utc, :checksums => sandbox_checksums }
+
+        json_response(201, {
+          :uri => build_uri(request.base_uri, request.rest_path + [id.to_s]),
+          :checksums => result_checksums,
+          :sandbox_id => id
+        })
+      end
+    end
+  end
+end
+

data/lib/chef_zero/endpoints/search_endpoint.rb

@@ -0,0 +1,139 @@
+require 'json'
+require 'chef/mixin/deep_merge'
+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'
+          [ data['clients'], Proc.new { |client, name| DataNormalizer.normalize_client(client, name) }, build_uri(request.base_uri, [ 'clients' ]) ]
+        when 'node'
+          [ data['nodes'], Proc.new { |node, name| DataNormalizer.normalize_node(node, name) }, build_uri(request.base_uri, [ 'nodes' ]) ]
+        when 'environment'
+          [ data['environments'], Proc.new { |environment, name| DataNormalizer.normalize_environment(environment, name) }, build_uri(request.base_uri, [ 'environments' ]) ]
+        when 'role'
+          [ data['roles'], Proc.new { |role, name| DataNormalizer.normalize_role(role, name) }, build_uri(request.base_uri, [ 'roles' ]) ]
+        else
+          [ data['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 = {}
+          Chef::Mixin::DeepMerge.deep_merge!(value['default'] || {}, result)
+          Chef::Mixin::DeepMerge.deep_merge!(value['normal'] || {}, result)
+          Chef::Mixin::DeepMerge.deep_merge!(value['override'] || {}, result)
+          Chef::Mixin::DeepMerge.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)
+        if container.nil?
+          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
+        end
+
+        # Search!
+        result = []
+        container.each_pair do |name,value|
+          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
+    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['data'].keys).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/rest_base.rb

@@ -0,0 +1,82 @@
+require 'chef_zero/rest_request'
+require 'chef_zero/rest_error_response'
+require 'chef/log'
+
+module ChefZero
+  class RestBase
+    def initialize(server)
+      @server = server
+    end
+
+    attr_reader :server
+
+    def data
+      server.data
+    end
+
+    def call(env)
+      begin
+        rest_path = env['PATH_INFO'].split('/').select { |part| part != "" }
+        method = env['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 '#{env['REQUEST_PATH']}': #{env['REQUEST_METHOD']}"]
+        end
+        if json_only && !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, RestRequest.new(env))
+        rescue RestErrorResponse => e
+          error(e.response_code, e.error)
+        end
+      rescue
+        Chef::Log.error("#{$!.inspect}\n#{$!.backtrace.join("\n")}")
+        raise
+      end
+    end
+
+    def json_only
+      true
+    end
+
+    def get_data(request, rest_path=nil)
+      rest_path ||= request.rest_path
+      # Grab the value we're looking for
+      value = data
+      rest_path.each do |path_part|
+        if !value.has_key?(path_part)
+          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, rest_path)}")
+        end
+        value = value[path_part]
+      end
+      value
+    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