chef-server-api 0.8.16 → 0.9.0.a3

data/Rakefile

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) + '/lib/chef-server-api/version'
+
 require 'rubygems'
 require 'rake/gempackagetask'
 
@@ -5,7 +7,6 @@ require 'merb-core'
 require 'merb-core/tasks/merb'
 
 GEM_NAME = "chef-server-api"
-CHEF_SERVER_VERSION="0.8.16"
 AUTHOR = "Opscode"
 EMAIL = "chef@opscode.com"
 HOMEPAGE = "http://wiki.opscode.com/display/chef"
@@ -13,7 +14,7 @@ SUMMARY = "A systems integration framework, built to bring the benefits of confi
 
 spec = Gem::Specification.new do |s|
   s.name = GEM_NAME
-  s.version = CHEF_SERVER_VERSION
+  s.version = ChefServerApi::VERSION
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
   s.extra_rdoc_files = ["README.rdoc", "LICENSE" ]
@@ -23,16 +24,20 @@ spec = Gem::Specification.new do |s|
   s.email = EMAIL
   s.homepage = HOMEPAGE
 
-  s.add_dependency "merb-core", "~> 1.0.0"
-  s.add_dependency "merb-slices", "~> 1.0.0"
-  s.add_dependency "merb-assets", "~> 1.0.0"
-  s.add_dependency "merb-helpers", "~> 1.0.0"
+  s.add_dependency "merb-core", "~> 1.1.0"
+  s.add_dependency "merb-slices", "~> 1.1.0"
+  s.add_dependency "merb-assets", "~> 1.1.0"
+  s.add_dependency "merb-helpers", "~> 1.1.0"
+  s.add_dependency "merb-param-protection", "~> 1.1.0"
 
   s.add_dependency "json", "<= 1.4.2"
 
   s.add_dependency "uuidtools", "~> 2.1.1"
 
   s.add_dependency "thin"
+  
+  s.bindir       = "bin"
+  s.executables  = %w( chef-server )
 
   s.require_path = 'lib'
   s.files = %w(LICENSE README.rdoc Rakefile) + Dir.glob("{config,lib,spec,app,public,stubs}/**/*")
@@ -44,12 +49,12 @@ end
 
 desc "Install the gem"
 task :install => :package do
-  sh %{gem install pkg/#{GEM_NAME}-#{CHEF_SERVER_VERSION} --no-rdoc --no-ri}
+  sh %{gem install pkg/#{GEM_NAME}-#{ChefServerApi::VERSION} --no-rdoc --no-ri}
 end
 
 desc "Uninstall the gem"
 task :uninstall do
-  sh %{gem uninstall #{GEM_NAME} -x -v #{CHEF_SERVER_VERSION} }
+  sh %{gem uninstall #{GEM_NAME} -x -v #{ChefServerApi::VERSION} }
 end
 
 desc "Create a gemspec file"
@@ -58,4 +63,3 @@ task :gemspec do
     file.puts spec.to_ruby
   end
 end
-

data/app/controllers/application.rb

@@ -1,16 +1,17 @@
 #
-#
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: Christopher Brown (<cb@opscode.com>)
-# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Author:: Christopher Walters (<cw@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008-2010 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -18,43 +19,14 @@
 # limitations under the License.
 #
 
-require "chef" / "mixin" / "checksum"
-require "chef" / "cookbook_loader"
+require "chef/mixin/checksum"
+require "chef/cookbook_loader"
 require "mixlib/authentication/signatureverification"
 
-class ChefServerApi::Application < Merb::Controller
+class Application < Merb::Controller
 
   include Chef::Mixin::Checksum
 
-  controller_for_slice
-  
-  # Generate the absolute url for a slice - takes the slice's :path_prefix into account.
-  #
-  # @param slice_name<Symbol> 
-  #   The name of the slice - in identifier_sym format (underscored).
-  # @param *args<Array[Symbol,Hash]> 
-  #   There are several possibilities regarding arguments:
-  #   - when passing a Hash only, the :default route of the current 
-  #     slice will be used
-  #   - when a Symbol is passed, it's used as the route name
-  #   - a Hash with additional params can optionally be passed
-  # 
-  # @return <String> A uri based on the requested slice.
-  #
-  # @example absolute_slice_url(:awesome, :format => 'html')
-  # @example absolute_slice_url(:forum, :posts, :format => 'xml')          
-  def absolute_slice_url(slice_name, *args)
-    options = {}
-    if args.length == 1 && args[0].respond_to?(:keys)
-      options = args[0]
-    else
-      options  = extract_options_from_args!(args) || {}
-    end
-    protocol = options.delete(:protocol) || request.protocol
-    host     = options.delete(:host) || request.host
-    protocol + "://" + host + slice_url(slice_name, *args)
-  end
-  
   def authenticate_every
     authenticator = Mixlib::Authentication::SignatureVerification.new
 
@@ -79,12 +51,12 @@ class ChefServerApi::Application < Merb::Controller
 
     auth
   end
-  
-  def is_admin 
+
+  def is_admin
     if @auth_user.admin
       true
     else
-      raise Unauthorized, "You are not allowed to take this action."
+      raise Forbidden, "You are not allowed to take this action."
     end
   end
 
@@ -92,18 +64,18 @@ class ChefServerApi::Application < Merb::Controller
     if @auth_user.admin || @auth_user.name == Chef::Config[:validation_client_name]
       true
     else
-      raise Unauthorized, "You are not allowed to take this action."
+      raise Forbidden, "You are not allowed to take this action."
     end
   end
 
-  def is_correct_node
+  def admin_or_requesting_node
     if @auth_user.admin || @auth_user.name == params[:id]
       true
     else
-      raise Unauthorized, "You are not the correct node (auth_user name: #{@auth_user.name}, params[:id]: #{params[:id]}), or are not an API administrator (admin: #{@auth_user.admin})."
+      raise Forbidden, "You are not the correct node (auth_user name: #{@auth_user.name}, params[:id]: #{params[:id]}), or are not an API administrator (admin: #{@auth_user.admin})."
     end
   end
-  
+
   # Store the URI of the current request in the session.
   #
   # We can return to this location by calling #redirect_back_or_default.
@@ -118,169 +90,14 @@ class ChefServerApi::Application < Merb::Controller
     session[:return_to] = nil
     redirect loc
   end
-  
-  def access_denied
-    case content_type
-    when :html
-      store_location
-      redirect slice_url(:openid_consumer), :message => { :error => "You don't have access to that, please login."}
-    else
-      raise Unauthorized, "You must authenticate first!"
-    end
-  end
-  
-  # Load a cookbook and return a hash with a list of all the files of a 
-  # given segment (attributes, recipes, definitions, libraries)
-  #
-  # === Parameters
-  # cookbook_id<String>:: The cookbook to load
-  # segment<Symbol>:: :attributes, :recipes, :definitions, :libraries
-  #
-  # === Returns
-  # <Hash>:: A hash consisting of the short name of the file in :name, and the full path
-  #   to the file in :file.
-  def load_cookbook_segment(cookbook, segment)
-    files_list = segment_files(segment, cookbook)
-    
-    files = Hash.new
-    files_list.each do |f|
-      full = File.expand_path(f)
-      name = File.basename(full)
-      files[name] = {
-        :name => name,
-        :file => full,
-      }
-    end
-    files
-  end
-  
-  def segment_files(segment, cookbook)
-    files_list = nil
-    case segment
-    when :attributes
-      files_list = cookbook.attribute_files
-    when :recipes
-      files_list = cookbook.recipe_files
-    when :definitions
-      files_list = cookbook.definition_files
-    when :libraries
-      files_list = cookbook.lib_files
-    when :providers
-      files_list = cookbook.provider_files
-    when :resources
-      files_list = cookbook.resource_files
-    when :files
-      files_list = cookbook.remote_files
-    when :templates
-      files_list = cookbook.template_files
-    else
-      raise ArgumentError, "segment must be one of :attributes, :recipes, :definitions, :remote_files, :template_files, :resources, :providers or :libraries"
-    end
-    files_list
-  end
-
-  def specific_cookbooks(node_name, cl)
-    valid_cookbooks = Hash.new
-    begin
-      node = Chef::Node.cdb_load(node_name)
-      recipes, default_attrs, override_attrs = node.run_list.expand('couchdb')
-    rescue Net::HTTPServerException
-      recipes = []
-    end
-    recipes.each do |recipe|
-      valid_cookbooks = expand_cookbook_deps(valid_cookbooks, cl, recipe)
-    end
-    valid_cookbooks
-  end
 
-  def expand_cookbook_deps(valid_cookbooks, cl, recipe)
-    cookbook = recipe
-    if recipe =~ /^(.+)::/
-      cookbook = $1
-    end
-    Chef::Log.debug("Node requires #{cookbook}")
-    valid_cookbooks[cookbook] = true 
-    cl.metadata[cookbook.to_sym].dependencies.each do |dep, versions|
-      expand_cookbook_deps(valid_cookbooks, cl, dep) unless valid_cookbooks[dep]
-    end
-    valid_cookbooks
-  end
-
-  def load_cookbook_files(cookbook)
-    response = {
-      :recipes => Array.new,
-      :definitions => Array.new,
-      :libraries => Array.new,
-      :attributes => Array.new,
-      :files => Array.new,
-      :templates => Array.new,
-      :resources => Array.new,
-      :providers => Array.new
-    }
-    [ :resources, :providers, :recipes, :definitions, :libraries, :attributes, :files, :templates ].each do |segment|
-      segment_files(segment, cookbook).each do |sf|
-        next if File.directory?(sf)
-        file_name = nil
-        file_url = nil
-        file_specificity = nil
-
-        if segment == :templates || segment == :files
-          mo = sf.match("cookbooks/#{cookbook.name}/#{segment}/(.+?)/(.+)")
-          unless mo
-            Chef::Log.debug("Skipping file #{sf}, as it doesn't have a proper segment.")
-            next
-          end
-          specificity = mo[1]
-          file_name = mo[2]
-          url_options = { :cookbook_id => cookbook.name.to_s, :segment => segment, :id => file_name }
-          
-          case specificity
-          when "default"
-          when /^host-(.+)$/
-            url_options[:fqdn] = $1
-          when /^(.+)-(.+)$/
-            url_options[:platform] = $1
-            url_options[:version] = $2
-          when /^(.+)$/
-            url_options[:platform] = $1
-          end
-          
-          file_specificity = specificity
-          file_url = absolute_slice_url(:cookbook_segment, url_options)
-        else
-          mo = sf.match("cookbooks/#{cookbook.name}/#{segment}/(.+)")
-          file_name = mo[1]
-          url_options = { :cookbook_id => cookbook.name.to_s, :segment => segment, :id => file_name }
-          file_url = absolute_slice_url(:cookbook_segment, url_options)
-        end
-        rs = {
-          :name => file_name, 
-          :uri => file_url, 
-          :checksum => checksum(sf)
-        }
-        rs[:specificity] = file_specificity if file_specificity
-        response[segment] << rs 
-      end
-    end
-    response
+  def access_denied
+    raise Unauthorized, "You must authenticate first!"
   end
   
-  def load_all_files(node_name=nil)
-    cl = Chef::CookbookLoader.new
-    valid_cookbooks = node_name ? specific_cookbooks(node_name, cl) : {} 
-    cookbook_list = Hash.new
-    cl.each do |cookbook|
-      if node_name
-        next unless valid_cookbooks[cookbook.name.to_s]
-      end
-      cookbook_list[cookbook.name.to_s] = load_cookbook_files(cookbook) 
-    end
-    cookbook_list
-  end
-
   def get_available_recipes
-    cl = Chef::CookbookLoader.new
-    available_recipes = cl.sort{ |a,b| a.name.to_s <=> b.name.to_s }.inject([]) do |result, element|
+    all_cookbooks_list = Chef::CookbookVersion.cdb_list(true)
+    available_recipes = all_cookbooks_list.sort{ |a,b| a.name.to_s <=> b.name.to_s }.inject([]) do |result, element|
       element.recipes.sort.each do |r| 
         if r =~ /^(.+)::default$/
           result << $1

data/app/controllers/clients.rb

@@ -19,18 +19,18 @@
 
 require 'chef/api_client'
 
-class ChefServerApi::Clients < ChefServerApi::Application
+class Clients < Application
   provides :json
 
   before :authenticate_every
   before :is_admin, :only => [ :index, :update, :destroy ]
   before :is_admin_or_validator, :only => [ :create ]
-  before :is_correct_node, :only => [ :show ]
+  before :admin_or_requesting_node, :only => [ :show ]
   
   # GET /clients
   def index
     @list = Chef::ApiClient.cdb_list(true)
-    display(@list.inject({}) { |result, element| result[element.name] = absolute_slice_url(:client, :id => element.name); result })
+    display(@list.inject({}) { |result, element| result[element.name] = absolute_url(:client, :id => element.name); result })
   end
 
   # GET /clients/:id
@@ -72,8 +72,8 @@ class ChefServerApi::Clients < ChefServerApi::Application
     @client.cdb_save
     
     self.status = 201
-    headers['Location'] = absolute_slice_url(:client, @client.name)
-    display({ :uri => absolute_slice_url(:client, @client.name), :private_key => @client.private_key })
+    headers['Location'] = absolute_url(:client, @client.name)
+    display({ :uri => absolute_url(:client, @client.name), :private_key => @client.private_key })
   end
 
   # PUT /clients/:id

data/app/controllers/cookbooks.rb

@@ -2,7 +2,8 @@
 # Author:: Adam Jacob (<adam@opscode.com>)
 # Author:: Christopher Brown (<cb@opscode.com>)
 # Author:: Christopher Walters (<cw@opscode.com>)
-# Copyright:: Copyright (c) 2008, 2009 Opscode, Inc.
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2009, 2010 Opscode, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,192 +22,115 @@
 require 'chef' / 'cookbook_loader'
 require 'chef' / 'cookbook' / 'metadata'
 
-class ChefServerApi::Cookbooks < ChefServerApi::Application
+class Cookbooks < Application
   
   provides :json
 
   before :authenticate_every
+  before :params_helper
+  
+  attr_accessor :cookbook_name, :cookbook_version
+  
+  def params_helper
+    self.cookbook_name = params[:cookbook_name]
+    self.cookbook_version = params[:cookbook_version]
+  end
 
   include Chef::Mixin::Checksum
-  include Merb::ChefServerApi::TarballHelper
+  include Merb::TarballHelper
   
   def index
-    cl = Chef::CookbookLoader.new
-    cookbook_list = Hash.new
-    cl.each do |cookbook|
-      cookbook_list[cookbook.name] = absolute_slice_url(:cookbook, :id => cookbook.name.to_s) 
+    cookbook_list = Chef::CookbookVersion.cdb_list
+    response = Hash.new
+    cookbook_list.each do |cookbook_name|
+      cookbook_name =~ /^(.+)-(\d+\.\d+\.\d+)$/
+      response[$1] = absolute_url(:cookbook, :cookbook_name => $1)
     end
-    display cookbook_list 
+    display response 
   end
 
-  def show
-    cl = Chef::CookbookLoader.new
-    begin
-      cookbook = cl[params[:id]]
-    rescue ArgumentError => e
-      raise NotFound, "Cannot find a cookbook named #{params[:id]}"
-    end
-    results = load_cookbook_files(cookbook)
-    results[:name] = cookbook.name.to_s
-    results[:metadata] = cl.metadata[cookbook.name.to_sym]
-    display results 
-  end
- 
-  def show_segment
-    cl = Chef::CookbookLoader.new
-    begin
-      cookbook = cl[params[:cookbook_id]]
-    rescue ArgumentError => e
-      raise NotFound, "Cannot find a cookbook named #{params[:cookbook_id]}" 
-    end
-    cookbook_files = load_cookbook_files(cookbook)
-    raise NotFound unless cookbook_files.has_key?(params[:segment].to_sym)
-
-    if params[:id]
-      case params[:segment]
-      when "templates","files"
-        if params[:recursive]
-          serve_directory_preferred(cookbook, params[:segment], cookbook_files[params[:segment].to_sym])
-        else
-          serve_segment_preferred(cookbook, params[:segment], cookbook_files[params[:segment].to_sym])
-        end
-      else
-        serve_segment_file(cookbook, params[:segment], cookbook_files[params[:segment].to_sym])
-      end
-    else
-      display cookbook_files[params[:segment].to_sym]
-    end
+  def show_versions
+    versions = Chef::CookbookVersion.cdb_by_name(cookbook_name)
+    raise NotFound, "Cannot find a cookbook named #{cookbook_name}" unless versions && versions.size > 0
+    display versions
   end
 
-  def serve_segment_preferred(cookbook, segment, files)
+  def show
+    cookbook = get_cookbook_version(cookbook_name, cookbook_version)
+    display cookbook.generate_manifest_with_urls { |opts| absolute_url(:cookbook_file, opts) }
+  end
 
-    to_send = nil
+  def show_file
+    cookbook = get_cookbook_version(cookbook_name, cookbook_version)
     
-    preferences.each do |pref|
-      unless to_send
-        Chef::Log.debug("Looking for a file with name `#{params[:id]}' and specificity #{pref}")
-        to_send = files.detect do |file| 
-          Chef::Log.debug("#{pref.inspect} #{file.inspect}")
-          file[:name] == params[:id] && file[:specificity] == pref
-          
-        end
-      end
-    end
+    checksum = params[:checksum]
+    raise NotFound, "Cookbook #{cookbook_name} version #{cookbook_version} does not contain a file with checksum #{checksum}" unless cookbook.checksums.keys.include?(checksum)
 
-    raise NotFound, "Cannot find a suitable #{segment} file for #{params[:id]}!" unless to_send 
-    current_checksum = to_send[:checksum] 
-    Chef::Log.debug("#{to_send[:name]} Client Checksum: #{params[:checksum]}, Server Checksum: #{current_checksum}") 
-    if current_checksum == params[:checksum]
-      raise NotModified, "File #{to_send[:name]} has not changed"
-    else
-      file_name = nil
-      segment_files(segment.to_sym, cookbook).each do |f|
-        if f =~ /#{to_send[:specificity]}\/#{to_send[:name]}$/
-          file_name = File.expand_path(f)
-          break 
-        end
-      end
-      raise NotFound, "Cannot find the real file for #{to_send[:specificity]} #{to_send[:name]} - this is a 42 error (shouldn't ever happen)" unless file_name
-      send_file(file_name)
-    end
-  end
-  
-  def serve_directory_preferred(cookbook, segment, files)
-    preferred_dir_contents = []
-    preferences.each do |preference|
-      preferred_dir_contents = files.select { |file| file[:name] =~ /^#{params[:id]}/ && file[:specificity] == preference  }
-      break unless preferred_dir_contents.empty?
-    end
-    
-    raise NotFound, "Cannot find a suitable directory for #{params[:id]}" if preferred_dir_contents.empty?
-    
-    display preferred_dir_contents.map { |file| file[:name].sub(/^#{params[:id]}/, '') }
-  end
-  
-  def preferences
-    ["host-#{params[:fqdn]}",
-    "#{params[:platform]}-#{params[:version]}",
-    "#{params[:platform]}",
-    "default"]
+    filename = checksum_location(checksum)
+    raise InternalServerError, "File with checksum #{checksum} not found in the repository (this should not happen)" unless File.exists?(filename)
+
+    send_file(filename)
   end
 
-  def serve_segment_file(cookbook, segment, files)
-    to_send = files.detect { |f| f[:name] == params[:id] } 
-    raise NotFound, "Cannot find a suitable #{segment} file!" unless to_send 
-    current_checksum = to_send[:checksum] 
-    Chef::Log.debug("#{to_send[:name]} Client Checksum: #{params[:checksum]}, Server Checksum: #{current_checksum}") 
-    if current_checksum == params[:checksum]
-      raise NotModified, "File #{to_send[:name]} has not changed"
-    else
-      file_name = nil
-      segment_files(segment.to_sym, cookbook).each do |f|
-        next unless File.basename(f) == to_send[:name]
-        file_name = File.expand_path(f)
-      end
-      raise NotFound, "Cannot find the real file for #{to_send[:name]} - this is a 42 error (shouldn't ever happen)" unless file_name
-      send_file(file_name)
+  def update
+    raise(BadRequest, "You didn't pass me a valid object!") unless params.has_key?('inflated_object')
+    raise(BadRequest, "You didn't pass me a Chef::CookbookVersion object!") unless params['inflated_object'].kind_of?(Chef::CookbookVersion)
+    unless params["inflated_object"].name == cookbook_name
+      raise(BadRequest, "You said the cookbook was named #{params['inflated_object'].name}, but the URL says it should be #{cookbook_name}.")
     end
-  end
-  
-  def create
-    # validate name and file parameters and throw an error if a cookbook with the same name already exists
-    raise BadRequest, "missing required parameter: name" unless params[:name]
-    desired_name = params[:name]
-    raise BadRequest, "invalid parameter: name must be at least one character long and contain only letters, numbers, periods (.), underscores (_), and hyphens (-)" unless desired_name =~ /\A[\w.-]+\Z/
-    begin
-      validate_file_parameter(desired_name, params[:file])
-    rescue FileParameterException => te
-      raise BadRequest, te.message
+
+    unless params["inflated_object"].version == cookbook_version
+      raise(BadRequest, "You said the cookbook was version #{params['inflated_object'].version}, but the URL says it should be #{cookbook_version}.") 
     end
     
     begin
-      Chef::CookbookLoader.new[desired_name]
-      raise BadRequest, "Cookbook with the name #{desired_name} already exists"
-    rescue ArgumentError
+      cookbook = Chef::CookbookVersion.cdb_load(cookbook_name, cookbook_version)
+      cookbook.manifest = params['inflated_object'].manifest
+    rescue Chef::Exceptions::CouchDBNotFound => e
+      Chef::Log.debug("Cookbook #{cookbook_name} version #{cookbook_version} does not exist")
+      cookbook = params['inflated_object']
     end
     
-    expand_tarball_and_put_in_repository(desired_name, params[:file][:tempfile])
-    
-    # construct successful response
-    self.status = 201
-    location = absolute_slice_url(:cookbook, :id => desired_name)
-    headers['Location'] = location
-    result = { 'uri' => location }
-    display result
-  end
-  
-  def get_tarball
-    cookbook_name = params[:cookbook_id]
-    expected_location = cookbook_location(cookbook_name)
-    raise NotFound, "Cannot find cookbook named #{cookbook_name} at #{expected_location}. Note: Tarball generation only applies to cookbooks under the first directory in the server's Chef::Config.cookbook_path variable and does to apply overrides." unless File.directory? expected_location
+    # ensure that all checksums referred to by the manifest have been uploaded.
+    Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |segment|
+      next unless cookbook.manifest[segment]
+      cookbook.manifest[segment].each do |manifest_record|
+        checksum = manifest_record[:checksum]
+        path = manifest_record[:path]
+        
+        begin
+          checksum_obj = Chef::Checksum.cdb_load(checksum)
+        rescue Chef::Exceptions::CouchDBNotFound => cdbx
+          checksum_obj = nil
+        end
+        
+        raise BadRequest, "Manifest has checksum #{checksum} (path #{path}) but it hasn't yet been uploaded" unless checksum_obj
+      end
+    end
     
-    send_file(get_or_create_cookbook_tarball_location(cookbook_name))
+    raise InternalServerError, "Error saving cookbook" unless cookbook.cdb_save
+
+    display cookbook
   end
   
-  def update
-    cookbook_name = params[:cookbook_id]
-    cookbook_path = cookbook_location(cookbook_name)
-    raise NotFound, "Cannot find cookbook named #{cookbook_name}" unless File.directory? cookbook_path
+  def destroy
     begin
-      validate_file_parameter(cookbook_name, params[:file])
-    rescue FileParameterException => te
-      raise BadRequest, te.message
+      cookbook = get_cookbook_version(cookbook_name, cookbook_version)
+    rescue ArgumentError => e
+      raise NotFound, "Cannot find a cookbook named #{cookbook_name} with version #{cookbook_version}"
     end
-    
-    expand_tarball_and_put_in_repository(cookbook_name, params[:file][:tempfile])
-    
-    display Hash.new
+
+    display cookbook.cdb_destroy
   end
-  
-  def destroy
-    cookbook_name = params[:id]
-    cookbook_path = cookbook_location(cookbook_name)
-    raise NotFound, "Cannot find cookbook named #{cookbook_name}" unless File.directory? cookbook_path
 
-    FileUtils.rm_rf(cookbook_path)
-    FileUtils.rm_f(cookbook_tarball_location(cookbook_name))
+  private
 
-    display Hash.new
+  def get_cookbook_version(name, version)
+    begin
+      Chef::CookbookVersion.cdb_load(name, version)
+    rescue Chef::Exceptions::CouchDBNotFound => e
+      raise NotFound, "Cannot find a cookbook named #{name} with version #{version}"
+    end
   end
   
 end