chef-zero 0.9

data/lib/chef_zero/data_normalizer.rb

@@ -0,0 +1,129 @@
+require 'chef_zero'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  class DataNormalizer
+    def self.normalize_client(client, name)
+      client['name'] ||= name
+      client['admin'] ||= false
+      client['public_key'] ||= PUBLIC_KEY
+      client['validator'] ||= false
+      client['json_class'] ||= "Chef::ApiClient"
+      client['chef_type'] ||= "client"
+      client
+    end
+
+    def self.normalize_user(user, name)
+      user['name'] ||= name
+      user['admin'] ||= false
+      user['public_key'] ||= PUBLIC_KEY
+      user
+    end
+
+    def self.normalize_data_bag_item(data_bag_item, data_bag_name, id, method)
+      if method == 'DELETE'
+        # TODO SERIOUSLY, WHO DOES THIS MANY EXCEPTIONS IN THEIR INTERFACE
+        if !(data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data'])
+          data_bag_item['id'] ||= id
+          data_bag_item = { 'raw_data' => data_bag_item }
+          data_bag_item['chef_type'] ||= 'data_bag_item'
+          data_bag_item['json_class'] ||= 'Chef::DataBagItem'
+          data_bag_item['data_bag'] ||= data_bag_name
+          data_bag_item['name'] ||= "data_bag_item_#{data_bag_name}_#{id}"
+        end
+      else
+        # If it's not already wrapped with raw_data, wrap it.
+        if data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data']
+          data_bag_item = data_bag_item['raw_data']
+        end
+        # Argh.  We don't do this on GET, but we do on PUT and POST????
+        if %w(PUT POST).include?(method)
+          data_bag_item['chef_type'] ||= 'data_bag_item'
+          data_bag_item['data_bag'] ||= data_bag_name
+        end
+        data_bag_item['id'] ||= id
+      end
+      data_bag_item
+    end
+
+    def self.normalize_environment(environment, name)
+      environment['name'] ||= name
+      environment['description'] ||= ''
+      environment['cookbook_versions'] ||= {}
+      environment['json_class'] ||= "Chef::Environment"
+      environment['chef_type'] ||= "environment"
+      environment['default_attributes'] ||= {}
+      environment['override_attributes'] ||= {}
+      environment
+    end
+
+    def self.normalize_cookbook(cookbook, name, version, base_uri, method)
+      # TODO I feel dirty
+      if method != 'PUT'
+        cookbook.each_pair do |key, value|
+          if value.is_a?(Array)
+            value.each do |file|
+              if file.is_a?(Hash) && file.has_key?('checksum')
+                file['url'] ||= RestBase::build_uri(base_uri, ['file_store', file['checksum']])
+              end
+            end
+          end
+        end
+      end
+      cookbook['name'] ||= "#{name}-#{version}"
+      # TODO this feels wrong, but the real chef server doesn't expand this default
+#      cookbook['version'] ||= version
+      cookbook['cookbook_name'] ||= name
+      cookbook['json_class'] ||= 'Chef::CookbookVersion'
+      cookbook['chef_type'] ||= 'cookbook_version'
+      cookbook['frozen?'] ||= false
+      cookbook['metadata'] ||= {}
+      cookbook['metadata']['version'] ||= version
+      cookbook['metadata']['name'] ||= name
+      cookbook
+    end
+
+    def self.normalize_node(node, name)
+      node['name'] ||= name
+      node['json_class'] ||= 'Chef::Node'
+      node['chef_type'] ||= 'node'
+      node['chef_environment'] ||= '_default'
+      node['override'] ||= {}
+      node['normal'] ||= {}
+      node['default'] ||= {}
+      node['automatic'] ||= {}
+      node['run_list'] ||= []
+      node['run_list'] = normalize_run_list(node['run_list'])
+      node
+    end
+
+    def self.normalize_role(role, name)
+      role['name'] ||= name
+      role['description'] ||= ''
+      role['json_class'] ||= 'Chef::Role'
+      role['chef_type'] ||= 'role'
+      role['default_attributes'] ||= {}
+      role['override_attributes'] ||= {}
+      role['run_list'] ||= []
+      role['run_list'] = normalize_run_list(role['run_list'])
+      role['env_run_lists'] ||= {}
+      role['env_run_lists'].each_pair do |env, run_list|
+        role['env_run_lists'][env] = normalize_run_list(run_list)
+      end
+      role
+    end
+
+    def self.normalize_run_list(run_list)
+      run_list.map{|item|
+        case item
+        when /^recipe\[.*\]$/
+          item # explicit recipe
+        when /^role\[.*\]$/
+          item # explicit role
+        else
+          "recipe[#{item}]"
+        end
+      }.uniq
+    end
+  end
+end

data/lib/chef_zero/endpoints/actor_endpoint.rb

@@ -0,0 +1,68 @@
+require 'json'
+require 'chef_zero/endpoints/rest_object_endpoint'
+require 'chef_zero/data_normalizer'
+
+module ChefZero
+  module Endpoints
+    # /clients/* and /users/*
+    class ActorEndpoint < RestObjectEndpoint
+      def put(request)
+        # Find out if we're updating the public key.
+        request_body = JSON.parse(request.body, :create_additions => false)
+        if request_body['public_key'].nil?
+          # If public_key is null, then don't overwrite it.  Weird patchiness.
+          body_modified = true
+          request_body.delete('public_key')
+        else
+          updating_public_key = true
+        end
+
+        # Generate private_key if requested.
+        if request_body.has_key?('private_key')
+          body_modified = true
+          if request_body['private_key']
+            private_key, public_key = server.gen_key_pair
+            updating_public_key = true
+            request_body['public_key'] = public_key
+          end
+          request_body.delete('private_key')
+        end
+
+        # Save request
+        request.body = JSON.pretty_generate(request_body) if body_modified
+
+        # PUT /clients is patchy
+        request.body = patch_request_body(request)
+
+        result = super(request)
+
+        # Inject private_key into response, delete public_key/password if applicable
+        if result[0] == 200
+          response = JSON.parse(result[2], :create_additions => false)
+          response['private_key'] = private_key if private_key
+          response.delete('public_key') if !updating_public_key && request.rest_path[0] == 'users'
+          response.delete('password')
+          # For PUT /clients, a rename returns 201.
+          if request_body['name'] && request.rest_path[1] != request_body['name']
+            json_response(201, response)
+          else
+            json_response(200, response)
+          end
+        else
+          result
+        end
+      end
+
+      def populate_defaults(request, response_json)
+        response = JSON.parse(response_json, :create_additions => false)
+        if request.rest_path[0] == 'clients'
+          response = DataNormalizer.normalize_client(response, request.rest_path[1])
+        else
+          response = DataNormalizer.normalize_user(response, request.rest_path[1])
+        end
+        JSON.pretty_generate(response)
+      end
+    end
+  end
+end
+

data/lib/chef_zero/endpoints/actors_endpoint.rb

@@ -0,0 +1,32 @@
+require 'json'
+require 'chef_zero/endpoints/rest_list_endpoint'
+
+module ChefZero
+  module Endpoints
+    # /clients or /users
+    class ActorsEndpoint < RestListEndpoint
+      def post(request)
+        # First, find out if the user actually posted a public key.  If not, make
+        # one.
+        request_body = JSON.parse(request.body, :create_additions => false)
+        public_key = request_body['public_key']
+        if !public_key
+          private_key, public_key = server.gen_key_pair
+          request_body['public_key'] = public_key
+          request.body = JSON.pretty_generate(request_body)
+        end
+
+        result = super(request)
+        if result[0] == 201
+          # If we generated a key, stuff it in the response.
+          response = JSON.parse(result[2], :create_additions => false)
+          response['private_key'] = private_key if private_key
+          response['public_key'] = public_key
+          json_response(201, response)
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/authenticate_user_endpoint.rb

@@ -0,0 +1,21 @@
+require 'json'
+require 'chef_zero/rest_base'
+
+module ChefZero
+  module Endpoints
+    # /authenticate_user
+    class AuthenticateUserEndpoint < RestBase
+      def post(request)
+        request_json = JSON.parse(request.body, :create_additions => false)
+        name = request_json['name']
+        password = request_json['password']
+        user = data['users'][name]
+        verified = user && JSON.parse(user, :create_additions => false)['password'] == password
+        json_response(200, {
+          'name' => name,
+          'verified' => !!verified
+        })
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/cookbook_endpoint.rb

@@ -0,0 +1,39 @@
+require 'chef_zero/endpoints/cookbooks_base'
+
+module ChefZero
+  module Endpoints
+    # /cookbooks/NAME
+    class CookbookEndpoint < CookbooksBase
+      def get(request)
+        filter = request.rest_path[1]
+        case filter
+        when '_latest'
+          result = {}
+          filter_cookbooks(data['cookbooks'], {}, 1) do |name, versions|
+            if versions.size > 0
+              result[name] = build_uri(request.base_uri, ['cookbooks', name, versions[0]])
+            end
+          end
+          json_response(200, result)
+        when '_recipes'
+          result = []
+          filter_cookbooks(data['cookbooks'], {}, 1) do |name, versions|
+            if versions.size > 0
+              cookbook = JSON.parse(data['cookbooks'][name][versions[0]], :create_additions => false)
+              result += recipe_names(name, cookbook)
+            end
+          end
+          json_response(200, result.sort)
+        else
+          cookbook_list = { filter => get_data(request, request.rest_path) }
+          json_response(200, format_cookbooks_list(request, cookbook_list))
+        end
+      end
+
+      def latest_version(versions)
+        sorted = versions.sort_by { |version| Chef::Version.new(version) }
+        sorted[-1]
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/cookbook_version_endpoint.rb

@@ -0,0 +1,106 @@
+require 'json'
+require 'chef_zero/endpoints/rest_object_endpoint'
+require 'chef_zero/rest_error_response'
+require 'chef_zero/data_normalizer'
+
+module ChefZero
+  module Endpoints
+    # /cookbooks/NAME/VERSION
+    class CookbookVersionEndpoint < RestObjectEndpoint
+      def get(request)
+        if request.rest_path[2] == "_latest" || request.rest_path[2] == "latest"
+          request.rest_path[2] = latest_version(get_data(request, request.rest_path[0..1]).keys)
+        end
+        super(request)
+      end
+
+      def put(request)
+        name = request.rest_path[1]
+        version = request.rest_path[2]
+        data['cookbooks'][name] = {} if !data['cookbooks'][name]
+        existing_cookbook = data['cookbooks'][name][version]
+
+        # Honor frozen
+        if existing_cookbook
+          existing_cookbook_json = JSON.parse(existing_cookbook, :create_additions => false)
+          if existing_cookbook_json['frozen?']
+            if request.query_params['force'] != "true"
+              raise RestErrorResponse.new(409, "The cookbook #{name} at version #{version} is frozen. Use the 'force' option to override.")
+            end
+            # For some reason, you are forever unable to modify "frozen?" on a frozen cookbook.
+            request_body = JSON.parse(request.body, :create_additions => false)
+            if !request_body['frozen?']
+              request_body['frozen?'] = true
+              request.body = JSON.pretty_generate(request_body)
+            end
+          end
+        end
+
+        # Set the cookbook
+        data['cookbooks'][name][version] = request.body
+
+        # If the cookbook was updated, check for deleted files and clean them up
+        if existing_cookbook
+          missing_checksums = get_checksums(existing_cookbook) - get_checksums(request.body)
+          if missing_checksums.size > 0
+            hoover_unused_checksums(missing_checksums)
+          end
+        end
+
+        already_json_response(existing_cookbook ? 200 : 201, populate_defaults(request, data['cookbooks'][name][version]))
+      end
+
+      def delete(request)
+        if request.rest_path[2] == "_latest" || request.rest_path[2] == "latest"
+          request.rest_path[2] = latest_version(get_data(request, request.rest_path[0..1]).keys)
+        end
+
+        deleted_cookbook = get_data(request, request.rest_path)
+        response = super(request)
+        cookbook_name = request.rest_path[1]
+        data['cookbooks'].delete(cookbook_name) if data['cookbooks'][cookbook_name].size == 0
+
+        # Hoover deleted files, if they exist
+        hoover_unused_checksums(get_checksums(deleted_cookbook))
+        response
+      end
+
+      def get_checksums(cookbook)
+        result = []
+        JSON.parse(cookbook, :create_additions => false).each_pair do |key, value|
+          if value.is_a?(Array)
+            value.each do |file|
+              if file.is_a?(Hash) && file.has_key?('checksum')
+                result << file['checksum']
+              end
+            end
+          end
+        end
+        result
+      end
+
+      def hoover_unused_checksums(deleted_checksums)
+        data['cookbooks'].each_pair do |cookbook_name, versions|
+          versions.each_pair do |cookbook_version, cookbook|
+            deleted_checksums = deleted_checksums - get_checksums(cookbook)
+          end
+        end
+        deleted_checksums.each do |checksum|
+          data['file_store'].delete(checksum)
+        end
+      end
+
+      def populate_defaults(request, response_json)
+        # Inject URIs into each cookbook file
+        cookbook = JSON.parse(response_json, :create_additions => false)
+        cookbook = DataNormalizer.normalize_cookbook(cookbook, request.rest_path[1], request.rest_path[2], request.base_uri, request.method)
+        JSON.pretty_generate(cookbook)
+      end
+
+      def latest_version(versions)
+        sorted = versions.sort_by { |version| Chef::Version.new(version) }
+        sorted[-1]
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/cookbooks_base.rb

@@ -0,0 +1,59 @@
+require 'json'
+require 'chef/exceptions' # Needed so Chef::Version/VersionConstraint load
+require 'chef/version_class'
+require 'chef/version_constraint'
+require 'chef_zero/rest_base'
+require 'chef_zero/data_normalizer'
+
+module ChefZero
+  module Endpoints
+    # Common code for endpoints that return cookbook lists
+    class CookbooksBase < RestBase
+      def format_cookbooks_list(request, cookbooks_list, constraints = {}, num_versions = nil)
+        results = {}
+        filter_cookbooks(cookbooks_list, constraints, num_versions) do |name, versions|
+          versions_list = versions.map do |version|
+            {
+              'url' => build_uri(request.base_uri, ['cookbooks', name, version]),
+              'version' => version
+            }
+          end
+          results[name] = {
+            'url' => build_uri(request.base_uri, ['cookbooks', name]),
+            'versions' => versions_list
+          }
+        end
+        results
+      end
+
+      def filter_cookbooks(cookbooks_list, constraints = {}, num_versions = nil)
+        cookbooks_list.keys.sort.each do |name|
+          constraint = Chef::VersionConstraint.new(constraints[name])
+          versions = []
+          cookbooks_list[name].keys.sort_by { |version| Chef::Version.new(version) }.reverse.each do |version|
+            break if num_versions && versions.size >= num_versions
+            if constraint.include?(version)
+              versions << version
+            end
+          end
+          yield [name, versions]
+        end
+      end
+
+      def recipe_names(cookbook_name, cookbook)
+        result = []
+        if cookbook['recipes']
+          cookbook['recipes'].each do |recipe|
+            if recipe['path'] == "recipes/#{recipe['name']}" && recipe['name'][-3..-1] == '.rb'
+              if recipe['name'] == 'default.rb'
+                result << cookbook_name
+              end
+              result << "#{cookbook_name}::#{recipe['name'][0..-4]}"
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end