chef-zero 4.3.0 → 4.3.1

data/lib/chef_zero/endpoints/system_recovery_endpoint.rb

@@ -1,30 +1,30 @@
-require 'ffi_yajl'
-require 'chef_zero/rest_base'
-
-module ChefZero
-  module Endpoints
-    # /system_recovery
-    class SystemRecoveryEndpoint < RestBase
-      def post(request)
-        request_json = FFI_Yajl::Parser.parse(request.body, :create_additions => false)
-        name = request_json['username']
-        password = request_json['password']
-        user = get_data(request, request.rest_path[0..-2] + ['users', name], :nil)
-        if !user
-          raise RestErrorResponse.new(403, "Nonexistent user")
-        end
-
-        user = FFI_Yajl::Parser.parse(user, :create_additions => false)
-        user = ChefData::DataNormalizer.normalize_user(user, name, [ 'username' ], server.options[:osc_compat])
-        if !user['recovery_authentication_enabled']
-          raise RestErrorResponse.new(403, "Only users with recovery_authentication_enabled=true may use /system_recovery to log in")
-        end
-        if user['password'] != password
-          raise RestErrorResponse.new(401, "Incorrect password")
-        end
-
-        json_response(200, user)
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /system_recovery
+    class SystemRecoveryEndpoint < RestBase
+      def post(request)
+        request_json = FFI_Yajl::Parser.parse(request.body, :create_additions => false)
+        name = request_json['username']
+        password = request_json['password']
+        user = get_data(request, request.rest_path[0..-2] + ['users', name], :nil)
+        if !user
+          raise RestErrorResponse.new(403, "Nonexistent user")
+        end
+
+        user = FFI_Yajl::Parser.parse(user, :create_additions => false)
+        user = ChefData::DataNormalizer.normalize_user(user, name, [ 'username' ], server.options[:osc_compat])
+        if !user['recovery_authentication_enabled']
+          raise RestErrorResponse.new(403, "Only users with recovery_authentication_enabled=true may use /system_recovery to log in")
+        end
+        if user['password'] != password
+          raise RestErrorResponse.new(401, "Incorrect password")
+        end
+
+        json_response(200, user)
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/user_association_request_endpoint.rb

@@ -1,40 +1,40 @@
-require 'ffi_yajl'
-require 'chef_zero/rest_base'
-
-module ChefZero
-  module Endpoints
-    # /users/USER/association_requests/ID
-    class UserAssociationRequestEndpoint < RestBase
-      def put(request)
-        username = request.rest_path[1]
-        id = request.rest_path[3]
-        if id !~ /^#{username}-(.+)/
-          raise RestErrorResponse.new(400, "Association request #{id} is invalid.  Must be #{username}-orgname.")
-        end
-        orgname = $1
-
-        json = FFI_Yajl::Parser.parse(request.body, :create_additions => false)
-        association_request_path = [ 'organizations', orgname, 'association_requests', username ]
-        if json['response'] == 'accept'
-          users = get_data(request, [ 'organizations', orgname, 'groups', 'users' ])
-          users = FFI_Yajl::Parser.parse(users, :create_additions => false)
-
-          delete_data(request, association_request_path)
-          create_data(request, [ 'organizations', orgname, 'users' ], username, '{}')
-
-          # Add the user to the users group if it isn't already there
-          if !users['users'] || !users['users'].include?(username)
-            users['users'] ||= []
-            users['users'] |= [ username ]
-            set_data(request, [ 'organizations', orgname, 'groups', 'users' ], FFI_Yajl::Encoder.encode(users, :pretty => true))
-          end
-        elsif json['response'] == 'reject'
-          delete_data(request, association_request_path)
-        else
-          raise RestErrorResponse.new(400, "response parameter was missing or set to the wrong value (must be accept or reject)")
-        end
-        json_response(200, { 'organization' => { 'name' => orgname } })
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /users/USER/association_requests/ID
+    class UserAssociationRequestEndpoint < RestBase
+      def put(request)
+        username = request.rest_path[1]
+        id = request.rest_path[3]
+        if id !~ /^#{username}-(.+)/
+          raise RestErrorResponse.new(400, "Association request #{id} is invalid.  Must be #{username}-orgname.")
+        end
+        orgname = $1
+
+        json = FFI_Yajl::Parser.parse(request.body, :create_additions => false)
+        association_request_path = [ 'organizations', orgname, 'association_requests', username ]
+        if json['response'] == 'accept'
+          users = get_data(request, [ 'organizations', orgname, 'groups', 'users' ])
+          users = FFI_Yajl::Parser.parse(users, :create_additions => false)
+
+          delete_data(request, association_request_path)
+          create_data(request, [ 'organizations', orgname, 'users' ], username, '{}')
+
+          # Add the user to the users group if it isn't already there
+          if !users['users'] || !users['users'].include?(username)
+            users['users'] ||= []
+            users['users'] |= [ username ]
+            set_data(request, [ 'organizations', orgname, 'groups', 'users' ], FFI_Yajl::Encoder.encode(users, :pretty => true))
+          end
+        elsif json['response'] == 'reject'
+          delete_data(request, association_request_path)
+        else
+          raise RestErrorResponse.new(400, "response parameter was missing or set to the wrong value (must be accept or reject)")
+        end
+        json_response(200, { 'organization' => { 'name' => orgname } })
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/user_association_requests_count_endpoint.rb

@@ -1,19 +1,19 @@
-require 'ffi_yajl'
-require 'chef_zero/rest_base'
-
-module ChefZero
-  module Endpoints
-    # /users/NAME/association_requests/count
-    class UserAssociationRequestsCountEndpoint < RestBase
-      def get(request)
-        get_data(request, request.rest_path[0..-3])
-
-        username = request.rest_path[1]
-        result = list_data(request, [ 'organizations' ]).select do |org|
-          exists_data?(request, [ 'organizations', org, 'association_requests', username ])
-        end
-        json_response(200, { "value" => result.size })
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /users/NAME/association_requests/count
+    class UserAssociationRequestsCountEndpoint < RestBase
+      def get(request)
+        get_data(request, request.rest_path[0..-3])
+
+        username = request.rest_path[1]
+        result = list_data(request, [ 'organizations' ]).select do |org|
+          exists_data?(request, [ 'organizations', org, 'association_requests', username ])
+        end
+        json_response(200, { "value" => result.size })
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/user_association_requests_endpoint.rb

@@ -1,19 +1,19 @@
-require 'ffi_yajl'
-require 'chef_zero/rest_base'
-
-module ChefZero
-  module Endpoints
-    # /users/USER/association_requests
-    class UserAssociationRequestsEndpoint < RestBase
-      def get(request)
-        get_data(request, request.rest_path[0..-2])
-        username = request.rest_path[1]
-        result = list_data(request, [ 'organizations' ]).select do |org|
-          exists_data?(request, [ 'organizations', org, 'association_requests', username ])
-        end
-        result = result.map { |org| { "id" => "#{username}-#{org}", "orgname" => org } }
-        json_response(200, result)
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /users/USER/association_requests
+    class UserAssociationRequestsEndpoint < RestBase
+      def get(request)
+        get_data(request, request.rest_path[0..-2])
+        username = request.rest_path[1]
+        result = list_data(request, [ 'organizations' ]).select do |org|
+          exists_data?(request, [ 'organizations', org, 'association_requests', username ])
+        end
+        result = result.map { |org| { "id" => "#{username}-#{org}", "orgname" => org } }
+        json_response(200, result)
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/user_organizations_endpoint.rb

@@ -1,22 +1,22 @@
-require 'ffi_yajl'
-require 'chef_zero/rest_base'
-
-module ChefZero
-  module Endpoints
-    # /users/USER/organizations
-    class UserOrganizationsEndpoint < RestBase
-      def get(request)
-        username = request.rest_path[1]
-        result = list_data(request, [ 'organizations' ]).select do |orgname|
-          exists_data?(request, [ 'organizations', orgname, 'users', username ])
-        end
-        result = result.map do |orgname|
-          org = get_data(request, [ 'organizations', orgname, 'org' ])
-          org = FFI_Yajl::Parser.parse(org, :create_additions => false)
-          { "organization" => ChefData::DataNormalizer.normalize_organization(org, orgname) }
-        end
-        json_response(200, result)
-      end
-    end
-  end
-end
+require 'ffi_yajl'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /users/USER/organizations
+    class UserOrganizationsEndpoint < RestBase
+      def get(request)
+        username = request.rest_path[1]
+        result = list_data(request, [ 'organizations' ]).select do |orgname|
+          exists_data?(request, [ 'organizations', orgname, 'users', username ])
+        end
+        result = result.map do |orgname|
+          org = get_data(request, [ 'organizations', orgname, 'org' ])
+          org = FFI_Yajl::Parser.parse(org, :create_additions => false)
+          { "organization" => ChefData::DataNormalizer.normalize_organization(org, orgname) }
+        end
+        json_response(200, result)
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/version_endpoint.rb

@@ -1,12 +1,12 @@
-require 'chef_zero/rest_base'
-
-module ChefZero
-  module Endpoints
-    # /version
-    class VersionEndpoint < RestBase
-      def get(request)
-        text_response(200, "chef-zero #{ChefZero::VERSION}\n")
-      end
-    end
-  end
-end
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /version
+    class VersionEndpoint < RestBase
+      def get(request)
+        text_response(200, "chef-zero #{ChefZero::VERSION}\n")
+      end
+    end
+  end
+end

data/lib/chef_zero/log.rb

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

data/lib/chef_zero/rest_base.rb

@@ -1,242 +1,242 @@
-require 'chef_zero/rest_request'
-require 'chef_zero/rest_error_response'
-require 'chef_zero/data_store/data_not_found_error'
-require 'chef_zero/chef_data/acl_path'
-
-module ChefZero
-  class RestBase
-    def initialize(server)
-      @server = server
-    end
-
-    attr_reader :server
-
-    def data_store
-      server.data_store
-    end
-
-    def check_api_version(request)
-      version = request.api_version
-      return nil if version.nil? # Not present in headers
-
-      if version.to_i.to_s != version.to_s # Version is not an Integer
-        return json_response(406, { "username" => request.requestor }, -1, -1)
-      elsif version.to_i > MAX_API_VERSION or version.to_i < MIN_API_VERSION
-        response = {
-          "error" => "invalid-x-ops-server-api-version",
-          "message" => "Specified version #{version} not supported",
-          "min_api_version" => MIN_API_VERSION,
-          "max_api_version" => MAX_API_VERSION
-        }
-        return json_response(406, response, version, -1)
-      else
-        return nil
-      end
-    end
-
-    def call(request)
-      response = check_api_version(request)
-      return response unless response.nil?
-
-      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 && !accepts?(request, '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
-        ChefZero::Log.debug("#{e.inspect}\n#{e.backtrace.join("\n")}")
-        error(e.response_code, e.error)
-      end
-    end
-
-    def json_only
-      true
-    end
-
-    def accepts?(request, category, type)
-      # If HTTP_ACCEPT is not sent at all, assume it accepts anything
-      # This parses as per http://tools.ietf.org/html/rfc7231#section-5.3
-      return true if !request.env['HTTP_ACCEPT']
-      accepts = request.env['HTTP_ACCEPT'].split(/,\s*/).map { |x| x.split(';',2)[0].strip }
-      return accepts.include?("#{category}/#{type}") || accepts.include?("#{category}/*") || accepts.include?('*/*')
-    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
-        elsif options.include?(:data_store_exceptions)
-          raise
-        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, *options)
-      rest_path ||= request.rest_path
-      begin
-        data_store.list(rest_path)
-      rescue DataStore::DataNotFoundError
-        if options.include?(:data_store_exceptions)
-          raise
-        else
-          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, rest_path)}")
-        end
-      end
-    end
-
-    def delete_data(request, rest_path=nil, *options)
-      rest_path ||= request.rest_path
-      begin
-        data_store.delete(rest_path, *options)
-      rescue DataStore::DataNotFoundError
-        if options.include?(:data_store_exceptions)
-          raise
-        else
-          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
-        end
-      end
-
-      begin
-        acl_path = ChefData::AclPath.get_acl_data_path(rest_path)
-        data_store.delete(acl_path) if acl_path
-      rescue DataStore::DataNotFoundError
-      end
-    end
-
-    def delete_data_dir(request, rest_path, *options)
-      rest_path ||= request.rest_path
-      begin
-        data_store.delete_dir(rest_path, *options)
-      rescue DataStore::DataNotFoundError
-        if options.include?(:data_store_exceptions)
-          raise
-        else
-          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
-        end
-      end
-
-      begin
-        acl_path = ChefData::AclPath.get_acl_data_path(rest_path)
-        data_store.delete(acl_path) if acl_path
-      rescue DataStore::DataNotFoundError
-      end
-    end
-
-    def set_data(request, rest_path, data, *options)
-      rest_path ||= request.rest_path
-      begin
-        data_store.set(rest_path, data, *options, :requestor => request.requestor)
-      rescue DataStore::DataNotFoundError
-        if options.include?(:data_store_exceptions)
-          raise
-        else
-          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
-        end
-      end
-    end
-
-    def create_data_dir(request, rest_path, name, *options)
-      rest_path ||= request.rest_path
-      begin
-        data_store.create_dir(rest_path, name, *options, :requestor => request.requestor)
-      rescue DataStore::DataNotFoundError
-        if options.include?(:data_store_exceptions)
-          raise
-        else
-          raise RestErrorResponse.new(404, "Parent not found: #{build_uri(request.base_uri, request.rest_path)}")
-        end
-      rescue DataStore::DataAlreadyExistsError
-        if options.include?(:data_store_exceptions)
-          raise
-        else
-          raise RestErrorResponse.new(409, "Object already exists: #{build_uri(request.base_uri, request.rest_path + [name])}")
-        end
-      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, :requestor => request.requestor)
-      rescue DataStore::DataNotFoundError
-        if options.include?(:data_store_exceptions)
-          raise
-        else
-          raise RestErrorResponse.new(404, "Parent not found: #{build_uri(request.base_uri, request.rest_path)}")
-        end
-      rescue DataStore::DataAlreadyExistsError
-        if options.include?(:data_store_exceptions)
-          raise
-        else
-          raise RestErrorResponse.new(409, "Object already exists: #{build_uri(request.base_uri, request.rest_path + [name])}")
-        end
-      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, request_version=0, response_version=0)
-      already_json_response(response_code, FFI_Yajl::Encoder.encode(json, :pretty => true), request_version, response_version)
-    end
-
-    def text_response(response_code, text)
-      [response_code, {"Content-Type" => "text/plain"}, text]
-    end
-
-    def already_json_response(response_code, json_text, request_version=0, response_version=0)
-      header = { "min_version" => MIN_API_VERSION.to_s, "max_version" => MAX_API_VERSION.to_s,
-                 "request_version" => request_version.to_s,
-                 "response_version" => response_version.to_s }
-      [ response_code,
-        { "Content-Type" => "application/json",
-          "X-Ops-Server-API-Version" => FFI_Yajl::Encoder.encode(header) },
-        json_text ]
-    end
-
-    # To be called from inside rest endpoints
-    def build_uri(base_uri, rest_path)
-      if server.options[:single_org]
-        # Strip off /organizations/chef if we are in single org mode
-        if rest_path[0..1] != [ 'organizations', server.options[:single_org] ]
-          raise "Unexpected URL #{rest_path[0..1]} passed to build_uri in single org mode"
-        else
-          "#{base_uri}/#{rest_path[2..-1].join('/')}"
-        end
-      else
-        "#{base_uri}/#{rest_path.join('/')}"
-      end
-    end
-
-    def self.build_uri(base_uri, rest_path)
-      "#{base_uri}/#{rest_path.join('/')}"
-    end
-
-    def populate_defaults(request, response)
-      response
-    end
-  end
-end
+require 'chef_zero/rest_request'
+require 'chef_zero/rest_error_response'
+require 'chef_zero/data_store/data_not_found_error'
+require 'chef_zero/chef_data/acl_path'
+
+module ChefZero
+  class RestBase
+    def initialize(server)
+      @server = server
+    end
+
+    attr_reader :server
+
+    def data_store
+      server.data_store
+    end
+
+    def check_api_version(request)
+      version = request.api_version
+      return nil if version.nil? # Not present in headers
+
+      if version.to_i.to_s != version.to_s # Version is not an Integer
+        return json_response(406, { "username" => request.requestor }, -1, -1)
+      elsif version.to_i > MAX_API_VERSION or version.to_i < MIN_API_VERSION
+        response = {
+          "error" => "invalid-x-ops-server-api-version",
+          "message" => "Specified version #{version} not supported",
+          "min_api_version" => MIN_API_VERSION,
+          "max_api_version" => MAX_API_VERSION
+        }
+        return json_response(406, response, version, -1)
+      else
+        return nil
+      end
+    end
+
+    def call(request)
+      response = check_api_version(request)
+      return response unless response.nil?
+
+      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 && !accepts?(request, '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
+        ChefZero::Log.debug("#{e.inspect}\n#{e.backtrace.join("\n")}")
+        error(e.response_code, e.error)
+      end
+    end
+
+    def json_only
+      true
+    end
+
+    def accepts?(request, category, type)
+      # If HTTP_ACCEPT is not sent at all, assume it accepts anything
+      # This parses as per http://tools.ietf.org/html/rfc7231#section-5.3
+      return true if !request.env['HTTP_ACCEPT']
+      accepts = request.env['HTTP_ACCEPT'].split(/,\s*/).map { |x| x.split(';',2)[0].strip }
+      return accepts.include?("#{category}/#{type}") || accepts.include?("#{category}/*") || accepts.include?('*/*')
+    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
+        elsif options.include?(:data_store_exceptions)
+          raise
+        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, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.list(rest_path)
+      rescue DataStore::DataNotFoundError
+        if options.include?(:data_store_exceptions)
+          raise
+        else
+          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, rest_path)}")
+        end
+      end
+    end
+
+    def delete_data(request, rest_path=nil, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.delete(rest_path, *options)
+      rescue DataStore::DataNotFoundError
+        if options.include?(:data_store_exceptions)
+          raise
+        else
+          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
+        end
+      end
+
+      begin
+        acl_path = ChefData::AclPath.get_acl_data_path(rest_path)
+        data_store.delete(acl_path) if acl_path
+      rescue DataStore::DataNotFoundError
+      end
+    end
+
+    def delete_data_dir(request, rest_path, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.delete_dir(rest_path, *options)
+      rescue DataStore::DataNotFoundError
+        if options.include?(:data_store_exceptions)
+          raise
+        else
+          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
+        end
+      end
+
+      begin
+        acl_path = ChefData::AclPath.get_acl_data_path(rest_path)
+        data_store.delete(acl_path) if acl_path
+      rescue DataStore::DataNotFoundError
+      end
+    end
+
+    def set_data(request, rest_path, data, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.set(rest_path, data, *options, :requestor => request.requestor)
+      rescue DataStore::DataNotFoundError
+        if options.include?(:data_store_exceptions)
+          raise
+        else
+          raise RestErrorResponse.new(404, "Object not found: #{build_uri(request.base_uri, request.rest_path)}")
+        end
+      end
+    end
+
+    def create_data_dir(request, rest_path, name, *options)
+      rest_path ||= request.rest_path
+      begin
+        data_store.create_dir(rest_path, name, *options, :requestor => request.requestor)
+      rescue DataStore::DataNotFoundError
+        if options.include?(:data_store_exceptions)
+          raise
+        else
+          raise RestErrorResponse.new(404, "Parent not found: #{build_uri(request.base_uri, request.rest_path)}")
+        end
+      rescue DataStore::DataAlreadyExistsError
+        if options.include?(:data_store_exceptions)
+          raise
+        else
+          raise RestErrorResponse.new(409, "Object already exists: #{build_uri(request.base_uri, request.rest_path + [name])}")
+        end
+      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, :requestor => request.requestor)
+      rescue DataStore::DataNotFoundError
+        if options.include?(:data_store_exceptions)
+          raise
+        else
+          raise RestErrorResponse.new(404, "Parent not found: #{build_uri(request.base_uri, request.rest_path)}")
+        end
+      rescue DataStore::DataAlreadyExistsError
+        if options.include?(:data_store_exceptions)
+          raise
+        else
+          raise RestErrorResponse.new(409, "Object already exists: #{build_uri(request.base_uri, request.rest_path + [name])}")
+        end
+      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, request_version=0, response_version=0)
+      already_json_response(response_code, FFI_Yajl::Encoder.encode(json, :pretty => true), request_version, response_version)
+    end
+
+    def text_response(response_code, text)
+      [response_code, {"Content-Type" => "text/plain"}, text]
+    end
+
+    def already_json_response(response_code, json_text, request_version=0, response_version=0)
+      header = { "min_version" => MIN_API_VERSION.to_s, "max_version" => MAX_API_VERSION.to_s,
+                 "request_version" => request_version.to_s,
+                 "response_version" => response_version.to_s }
+      [ response_code,
+        { "Content-Type" => "application/json",
+          "X-Ops-Server-API-Version" => FFI_Yajl::Encoder.encode(header) },
+        json_text ]
+    end
+
+    # To be called from inside rest endpoints
+    def build_uri(base_uri, rest_path)
+      if server.options[:single_org]
+        # Strip off /organizations/chef if we are in single org mode
+        if rest_path[0..1] != [ 'organizations', server.options[:single_org] ]
+          raise "Unexpected URL #{rest_path[0..1]} passed to build_uri in single org mode"
+        else
+          "#{base_uri}/#{rest_path[2..-1].join('/')}"
+        end
+      else
+        "#{base_uri}/#{rest_path.join('/')}"
+      end
+    end
+
+    def self.build_uri(base_uri, rest_path)
+      "#{base_uri}/#{rest_path.join('/')}"
+    end
+
+    def populate_defaults(request, response)
+      response
+    end
+  end
+end