chef-zero 1.4.0.alpha-x86-mingw32

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,25 @@
+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']
+        begin
+          user = data_store.get(['users', name])
+          verified = JSON.parse(user, :create_additions => false)['password'] == password
+        rescue DataStore::DataNotFoundError
+          verified = false
+        end
+        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(all_cookbooks_list, {}, 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(all_cookbooks_list, {}, 1) do |name, versions|
+            if versions.size > 0
+              cookbook = JSON.parse(get_data(request, ['cookbooks', name, versions[0]]), :create_additions => false)
+              result += recipe_names(name, cookbook)
+            end
+          end
+          json_response(200, result.sort)
+        else
+          cookbook_list = { filter => list_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| Gem::Version.new(version.dup) }
+        sorted[-1]
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/cookbook_version_endpoint.rb

@@ -0,0 +1,110 @@
+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(list_data(request, request.rest_path[0..1]))
+        end
+        super(request)
+      end
+
+      def put(request)
+        name = request.rest_path[1]
+        version = request.rest_path[2]
+        existing_cookbook = get_data(request, request.rest_path, :nil)
+        
+        # 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
+        set_data(request, ['cookbooks', name, version], request.body, :create_dir, :create)
+
+        # 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, request.body))
+      end
+
+      def delete(request)
+        if request.rest_path[2] == "_latest" || request.rest_path[2] == "latest"
+          request.rest_path[2] = latest_version(list_data(request, request.rest_path[0..1]))
+        end
+
+        deleted_cookbook = get_data(request)
+
+        response = super(request)
+        cookbook_name = request.rest_path[1]
+        delete_data_dir(request, ['cookbooks', cookbook_name]) if list_data(request, ['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.uniq
+      end
+
+      private
+
+      def hoover_unused_checksums(deleted_checksums)
+        data_store.list(['cookbooks']).each do |cookbook_name|
+          data_store.list(['cookbooks', cookbook_name]).each do |version|
+            cookbook = data_store.get(['cookbooks', cookbook_name, version])
+            deleted_checksums = deleted_checksums - get_checksums(cookbook)
+          end
+        end
+        deleted_checksums.each do |checksum|
+          # There can be a race here if multiple cookbooks are uploading.
+          data_store.delete(['file_store', 'checksums', 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| Gem::Version.new(version.dup) }
+        sorted[-1]
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/cookbooks_base.rb

@@ -0,0 +1,65 @@
+require 'json'
+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 all_cookbooks_list
+        result = {}
+        # Race conditions exist here (if someone deletes while listing).  I don't care.
+        data_store.list(['cookbooks']).each do |name|
+          result[name] = data_store.list(['cookbooks', name])
+        end
+        result
+      end
+
+      def filter_cookbooks(cookbooks_list, constraints = {}, num_versions = nil)
+        cookbooks_list.keys.sort.each do |name|
+          constraint = Gem::Requirement.new(constraints[name])
+          versions = []
+          cookbooks_list[name].sort_by { |version| Gem::Version.new(version.dup) }.reverse.each do |version|
+            break if num_versions && versions.size >= num_versions
+            if constraint.satisfied_by?(Gem::Version.new(version.dup))
+              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

data/lib/chef_zero/endpoints/cookbooks_endpoint.rb

@@ -0,0 +1,19 @@
+require 'chef_zero/endpoints/cookbooks_base'
+
+module ChefZero
+  module Endpoints
+    # /cookbooks
+    class CookbooksEndpoint < CookbooksBase
+      def get(request)
+        if request.query_params['num_versions'] == 'all'
+          num_versions = nil
+        elsif request.query_params['num_versions']
+          num_versions = request.query_params['num_versions'].to_i
+        else
+          num_versions = 1
+        end
+        json_response(200, format_cookbooks_list(request, all_cookbooks_list, {}, num_versions))
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/data_bag_endpoint.rb

@@ -0,0 +1,45 @@
+require 'json'
+require 'chef_zero/endpoints/rest_list_endpoint'
+require 'chef_zero/endpoints/data_bag_item_endpoint'
+require 'chef_zero/rest_error_response'
+
+module ChefZero
+  module Endpoints
+    # /data/NAME
+    class DataBagEndpoint < RestListEndpoint
+      def initialize(server)
+        super(server, 'id')
+      end
+
+      def post(request)
+        key = JSON.parse(request.body, :create_additions => false)[identity_key]
+        response = super(request)
+        if response[0] == 201
+          already_json_response(201, DataBagItemEndpoint::populate_defaults(request, request.body, request.rest_path[1], key))
+        else
+          response
+        end
+      end
+
+      def get_key(contents)
+        data_bag_item = JSON.parse(contents, :create_additions => false)
+        if data_bag_item['json_class'] == 'Chef::DataBagItem' && data_bag_item['raw_data']
+          data_bag_item['raw_data']['id']
+        else
+          data_bag_item['id']
+        end
+      end
+
+      def delete(request)
+        key = request.rest_path[1]
+        delete_data_dir(request, request.rest_path, :recursive)
+        json_response(200, {
+          'chef_type' => 'data_bag',
+          'json_class' => 'Chef::DataBag',
+          'name' => key
+        })
+      end
+    end
+  end
+end
+

data/lib/chef_zero/endpoints/data_bag_item_endpoint.rb

@@ -0,0 +1,25 @@
+require 'json'
+require 'chef_zero/endpoints/rest_object_endpoint'
+require 'chef_zero/endpoints/data_bag_item_endpoint'
+require 'chef_zero/data_normalizer'
+
+module ChefZero
+  module Endpoints
+    # /data/NAME/NAME
+    class DataBagItemEndpoint < RestObjectEndpoint
+      def initialize(server)
+        super(server, 'id')
+      end
+
+      def populate_defaults(request, response_json)
+        DataBagItemEndpoint::populate_defaults(request, response_json, request.rest_path[1], request.rest_path[2])
+      end
+
+      def self.populate_defaults(request, response_json, data_bag, data_bag_item)
+        response = JSON.parse(response_json, :create_additions => false)
+        response = DataNormalizer.normalize_data_bag_item(response, data_bag, data_bag_item, request.method)
+        JSON.pretty_generate(response)
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/data_bags_endpoint.rb

@@ -0,0 +1,22 @@
+require 'json'
+require 'chef_zero/endpoints/rest_list_endpoint'
+
+module ChefZero
+  module Endpoints
+    # /data
+    class DataBagsEndpoint < RestListEndpoint
+      def post(request)
+        contents = request.body
+        name = JSON.parse(contents, :create_additions => false)[identity_key]
+        if name.nil?
+          error(400, "Must specify '#{identity_key}' in JSON")
+        elsif exists_data_dir?(request, ['data', name])
+          error(409, "Object already exists")
+        else
+          data_store.create_dir(['data'], name, :recursive)
+          json_response(201, {"uri" => "#{build_uri(request.base_uri, request.rest_path + [name])}"})
+        end
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/environment_cookbook_endpoint.rb

@@ -0,0 +1,24 @@
+require 'json'
+require 'chef_zero/endpoints/cookbooks_base'
+
+module ChefZero
+  module Endpoints
+    # /environments/NAME/cookbooks/NAME
+    class EnvironmentCookbookEndpoint < CookbooksBase
+      def get(request)
+        cookbook_name = request.rest_path[3]
+        environment = JSON.parse(get_data(request, request.rest_path[0..1]), :create_additions => false)
+        constraints = environment['cookbook_versions'] || {}
+        cookbook_versions = list_data(request, request.rest_path[2..3])
+        if request.query_params['num_versions'] == 'all'
+          num_versions = nil
+        elsif request.query_params['num_versions']
+          num_versions = request.query_params['num_versions'].to_i
+        else
+          num_versions = nil
+        end
+        json_response(200, format_cookbooks_list(request, { cookbook_name => cookbook_versions }, constraints, num_versions))
+      end
+    end
+  end
+end

data/lib/chef_zero/endpoints/environment_cookbook_versions_endpoint.rb

@@ -0,0 +1,109 @@
+require 'json'
+require 'chef_zero/rest_base'
+require 'chef_zero/rest_error_response'
+
+module ChefZero
+  module Endpoints
+    # /environments/NAME/cookbook_versions
+    class EnvironmentCookbookVersionsEndpoint < RestBase
+      def post(request)
+        cookbook_names = list_data(request, ['cookbooks'])
+
+        # Get the list of cookbooks and versions desired by the runlist
+        desired_versions = {}
+        run_list = JSON.parse(request.body, :create_additions => false)['run_list']
+        run_list.each do |run_list_entry|
+          if run_list_entry =~ /(.+)(::.+)?\@(.+)/
+            raise RestErrorResponse.new(412, "No such cookbook: #{$1}") if !cookbook_names.include?($1)
+            raise RestErrorResponse.new(412, "No such cookbook version for cookbook #{$1}: #{$3}") if !list_data(request, ['cookbooks', $1]).include?($3)
+            desired_versions[$1] = [ $3 ]
+          else
+            desired_cookbook = run_list_entry.split('::')[0]
+            raise RestErrorResponse.new(412, "No such cookbook: #{desired_cookbook}") if !cookbook_names.include?(desired_cookbook)
+            desired_versions[desired_cookbook] = list_data(request, ['cookbooks', desired_cookbook])
+          end
+        end
+
+        # Filter by environment constraints
+        environment = JSON.parse(get_data(request, request.rest_path[0..1]), :create_additions => false)
+        environment_constraints = environment['cookbook_versions'] || {}
+
+        desired_versions.each_key do |name|
+          desired_versions = filter_by_constraint(desired_versions, name, environment_constraints[name])
+        end
+
+        # Depsolve!
+        solved = depsolve(request, desired_versions.keys, desired_versions, environment_constraints)
+        if !solved
+          return raise RestErrorResponse.new(412, "Unsolvable versions!")
+        end
+
+        result = {}
+        solved.each_pair do |name, versions|
+          cookbook = JSON.parse(get_data(request, ['cookbooks', name, versions[0]]), :create_additions => false)
+          result[name] = DataNormalizer.normalize_cookbook(cookbook, name, versions[0], request.base_uri, 'MIN')
+        end
+        json_response(200, result)
+      end
+
+      def depsolve(request, unsolved, desired_versions, environment_constraints)
+        return nil if desired_versions.values.any? { |versions| versions.empty? }
+
+        # If everything is already
+        solve_for = unsolved[0]
+        return desired_versions if !solve_for
+
+        # Go through each desired version of this cookbook, starting with the latest,
+        # until we find one we can solve successfully with
+        sort_versions(desired_versions[solve_for]).each do |desired_version|
+          new_desired_versions = desired_versions.clone
+          new_desired_versions[solve_for] = [ desired_version ]
+          new_unsolved = unsolved[1..-1]
+
+          # Pick this cookbook, and add dependencies
+          cookbook_obj = JSON.parse(get_data(request, ['cookbooks', solve_for, desired_version]), :create_additions => false)
+          cookbook_metadata = cookbook_obj['metadata'] || {}
+          cookbook_dependencies = cookbook_metadata['dependencies'] || {}
+          dep_not_found = false
+          cookbook_dependencies.each_pair do |dep_name, dep_constraint|
+            # If the dep is not already in the list, add it to the list to solve
+            # and bring in all environment-allowed cookbook versions to desired_versions
+            if !new_desired_versions.has_key?(dep_name)
+              new_unsolved = new_unsolved + [dep_name]
+              # If the dep is missing, we will try other versions of the cookbook that might not have the bad dep.
+              if !exists_data_dir?(request, ['cookbooks', dep_name])
+                dep_not_found = true
+                break
+              end
+              new_desired_versions[dep_name] = list_data(request, ['cookbooks', dep_name])
+              new_desired_versions = filter_by_constraint(new_desired_versions, dep_name, environment_constraints[dep_name])
+            end
+            new_desired_versions = filter_by_constraint(new_desired_versions, dep_name, dep_constraint)
+          end
+
+          next if dep_not_found
+
+          # Depsolve children with this desired version!  First solution wins.
+          result = depsolve(request, new_unsolved, new_desired_versions, environment_constraints)
+          return result if result
+        end
+        return nil
+      end
+
+      def sort_versions(versions)
+        result = versions.sort_by { |version| Gem::Version.new(version.dup) }
+        result.reverse
+      end
+
+      def filter_by_constraint(versions, cookbook_name, constraint)
+        return versions if !constraint
+        constraint = Gem::Requirement.new(constraint)
+        new_versions = versions[cookbook_name]
+        new_versions = new_versions.select { |version| constraint.satisfied_by?(Gem::Version.new(version.dup)) }
+        result = versions.clone
+        result[cookbook_name] = new_versions
+        result
+      end
+    end
+  end
+end