chef-server-api 0.8.16 → 0.9.0.a3

data/app/controllers/{data.rb → data_bags.rb}

@@ -19,7 +19,7 @@
 
 require 'chef/data_bag'
 
-class ChefServerApi::Data < ChefServerApi::Application
+class DataBags < Application
   
   provides :json
   
@@ -28,7 +28,7 @@ class ChefServerApi::Data < ChefServerApi::Application
   
   def index
     @bag_list = Chef::DataBag.cdb_list(false)
-    display(@bag_list.inject({}) { |r,b| r[b] = absolute_slice_url(:datum, :id => b); r })
+    display(@bag_list.inject({}) { |r,b| r[b] = absolute_url(:datum, :id => b); r })
     
   end
 
@@ -38,7 +38,7 @@ class ChefServerApi::Data < ChefServerApi::Application
     rescue Chef::Exceptions::CouchDBNotFound => e
       raise NotFound, "Cannot load data bag #{params[:id]}"
     end
-    display(@data_bag.list.inject({}) { |res, i| res[i] = absolute_slice_url(:data_bag_item, :data_bag_id => @data_bag.name, :id => i); res })
+    display(@data_bag.list.inject({}) { |res, i| res[i] = absolute_url(:data_bag_item, :data_bag_id => @data_bag.name, :id => i); res })
   end
 
   def create
@@ -58,7 +58,7 @@ class ChefServerApi::Data < ChefServerApi::Application
     raise Conflict, "Data bag already exists" if exists
     self.status = 201
     @data_bag.cdb_save
-    display({ :uri => absolute_slice_url(:datum, :id => @data_bag.name) })
+    display({ :uri => absolute_url(:datum, :id => @data_bag.name) })
   end
 
   def destroy

data/app/controllers/data_item.rb

@@ -21,7 +21,7 @@
 require 'chef/data_bag'
 require 'chef/data_bag_item'
 
-class ChefServerApi::DataItem < ChefServerApi::Application
+class DataItem < Application
   
   provides :json
   

data/app/controllers/exceptions.rb

@@ -17,7 +17,7 @@
 # limitations under the License.
 #
 
-class Exceptions < ChefServerApi::Application
+class Exceptions < Application
   
   provides :json
  

data/app/controllers/main.rb

@@ -1,4 +1,4 @@
-class ChefServerApi::Main < ChefServerApi::Application
+class Main < Application
 
   before :authenticate_every
   provides :html, :json
@@ -6,11 +6,11 @@ class ChefServerApi::Main < ChefServerApi::Application
   def index
     display(
       { 
-        absolute_slice_url(:nodes) => "Manage Nodes",
-        absolute_slice_url(:roles) => "Manage Roles",
-        absolute_slice_url(:cookbooks) => "Manage Cookbooks",
-        absolute_slice_url(:data) => "Manage Data Bags",
-        absolute_slice_url(:search) => "Search"
+        absolute_url(:nodes) => "Manage Nodes",
+        absolute_url(:roles) => "Manage Roles",
+        absolute_url(:cookbooks) => "Manage Cookbooks",
+        absolute_url(:data) => "Manage Data Bags",
+        absolute_url(:search) => "Search"
       }
     )
   end

data/app/controllers/nodes.rb

@@ -19,17 +19,17 @@
 
 require 'chef' / 'node'
 
-class ChefServerApi::Nodes < ChefServerApi::Application
+class Nodes < Application
   
   provides :json
   
   before :authenticate_every 
-  before :is_correct_node, :only => [ :update, :destroy, :cookbooks ]
+  before :admin_or_requesting_node, :only => [ :update, :destroy, :cookbooks ]
   
   def index
     @node_list = Chef::Node.cdb_list 
     display(@node_list.inject({}) do |r,n|
-      r[n] = absolute_slice_url(:node, n); r
+      r[n] = absolute_url(:node, n); r
     end)
   end
 
@@ -40,9 +40,6 @@ class ChefServerApi::Nodes < ChefServerApi::Application
       raise NotFound, "Cannot load node #{params[:id]}"
     end
     @node.couchdb_rev = nil
-    recipes, default, override = @node.run_list.expand("couchdb")
-    @node.default_attrs = default
-    @node.override_attrs = override
     display @node
   end
 
@@ -55,7 +52,7 @@ class ChefServerApi::Nodes < ChefServerApi::Application
     end
     self.status = 201
     @node.cdb_save
-    display({ :uri => absolute_slice_url(:node, @node.name) })
+    display({ :uri => absolute_url(:node, @node.name) })
   end
 
   def update
@@ -67,7 +64,8 @@ class ChefServerApi::Nodes < ChefServerApi::Application
 
     updated = params['inflated_object']
     @node.run_list.reset!(updated.run_list)
-    @node.attribute = updated.attribute
+    @node.automatic_attrs = updated.automatic_attrs
+    @node.normal_attrs = updated.normal_attrs
     @node.override_attrs = updated.override_attrs
     @node.default_attrs = updated.default_attrs
     @node.cdb_save
@@ -92,9 +90,73 @@ class ChefServerApi::Nodes < ChefServerApi::Application
     rescue Chef::Exceptions::CouchDBNotFound => e 
       raise NotFound, "Cannot load node #{params[:id]}"
     end
-   
+
     display(load_all_files(params[:id]))
   end
-  
+
+  private
+
+  def load_all_files(node_name)
+    all_cookbooks = Chef::CookbookVersion.cdb_list(true).inject({}) {|hsh,record| hsh[record.name] = record ; hsh}
+
+    included_cookbooks = cookbooks_for_node(node_name, all_cookbooks)
+    nodes_cookbooks = Hash.new
+    included_cookbooks.each do |cookbook_name, cookbook|
+      next unless cookbook
+
+      nodes_cookbooks[cookbook_name.to_s] = cookbook.generate_manifest_with_urls{|opts| absolute_url(:cookbook_file, opts) }
+    end
+
+    nodes_cookbooks
+  end
+
+  # returns name -> CookbookVersion for all cookbooks included on the given node.
+  def cookbooks_for_node(node_name, all_cookbooks)
+    # get node's explicit dependencies
+    node = Chef::Node.cdb_load(node_name)
+    run_list_items, default_attrs, override_attrs = node.run_list.expand('couchdb')
+
+    # walk run list and accumulate included dependencies
+    run_list_items.inject({}) do |included_cookbooks, run_list_item|
+      expand_cookbook_deps(included_cookbooks, all_cookbooks, run_list_item)
+      included_cookbooks
+    end
+  end
+
+  # Accumulates transitive cookbook dependencies no more than once in included_cookbooks
+  #   included_cookbooks == hash of name -> CookbookVersion, which is used for returning
+  #                         result as well as for tracking which cookbooks we've already
+  #                         recursed into
+  #   all_cookbooks    == hash of name -> CookbookVersion, all cookbooks available
+  #   run_list_items   == name of cookbook to include
+  def expand_cookbook_deps(included_cookbooks, all_cookbooks, run_list_item)
+    # determine the run list item's parent cookbook, which might be run_list_item in the default case
+    cookbook_name = (run_list_item[/^(.+)::/, 1] || run_list_item.to_s)
+    Chef::Log.debug("Node requires #{cookbook_name}")
+
+    # include its dependencies
+    included_cookbooks[cookbook_name] = all_cookbooks[cookbook_name]
+    if !all_cookbooks[cookbook_name]
+      return false
+      # NOTE [dan/cw] We don't think changing this to an exception breaks stuff.
+      # Chef::Log.warn "#{__FILE__}:#{__LINE__}: in expand_cookbook_deps, cookbook/role #{cookbook_name} could not be found, ignoring it in cookbook expansion"
+      # return included_cookbooks
+    end
+
+    # TODO: 5/27/2010 cw: implement dep_version_constraints according to
+    # http://wiki.opscode.com/display/chef/Metadata#Metadata-depends,
+    all_cookbooks[cookbook_name].metadata.dependencies.each do |depname, dep_version_constraints|
+      # recursively expand dependencies into included_cookbooks unless
+      # we've already done it
+      unless included_cookbooks[depname]
+        unless expand_cookbook_deps(included_cookbooks, all_cookbooks, depname)
+          raise PreconditionFailed, "cookbook #{cookbook_name} depends on cookbook #{depname}, but #{depname} does not exist"
+
+        end
+      end
+    end
+    true
+  end
+
 end
 

data/app/controllers/roles.rb

@@ -1,6 +1,6 @@
 require 'chef/role'
 
-class ChefServerApi::Roles < ChefServerApi::Application
+class Roles < Application
   provides :json
 
   before :authenticate_every
@@ -9,7 +9,7 @@ class ChefServerApi::Roles < ChefServerApi::Application
   # GET /roles
   def index
     @role_list = Chef::Role.cdb_list(true)
-    display(@role_list.inject({}) { |r,role| r[role.name] = absolute_slice_url(:role, role.name); r })
+    display(@role_list.inject({}) { |r,role| r[role.name] = absolute_url(:role, role.name); r })
   end
 
   # GET /roles/:id
@@ -37,7 +37,7 @@ class ChefServerApi::Roles < ChefServerApi::Application
     @role.cdb_save
     
     self.status = 201
-    display({ :uri => absolute_slice_url(:role, :id => @role.name)  })
+    display({ :uri => absolute_url(:role, :id => @role.name)  })
   end
 
   # PUT /roles/:id

data/app/controllers/sandboxes.rb

@@ -0,0 +1,179 @@
+#
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 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.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/sandbox'
+require 'chef/checksum'
+
+# Sandboxes are used to upload files to the server (e.g., cookbook upload).
+class Sandboxes < Application
+  
+  provides :json
+
+  before :authenticate_every
+
+  include Chef::Mixin::Checksum
+  include Merb::TarballHelper
+  
+  def index
+    couch_sandbox_list = Chef::Sandbox::cdb_list(true)
+    
+    sandbox_list = Hash.new
+    couch_sandbox_list.each do |sandbox|
+      sandbox_list[sandbox.guid] = absolute_url(:sandbox, :sandbox_id => sandbox.guid)
+    end
+    display sandbox_list
+  end
+
+  def show
+    begin
+      sandbox = Chef::Sandbox.cdb_load(params[:sandbox_id])
+    rescue Chef::Exceptions::CouchDBNotFound => e
+      raise NotFound, "Cannot find a sandbox named #{params[:sandbox_id]}"
+    end
+
+    display sandbox
+  end
+ 
+  def create
+    checksums = params[:checksums]
+    
+    raise BadRequest, "missing required parameter: checksums" unless checksums
+    raise BadRequest, "required parameter checksums is not a hash: #{checksums.class.name}" unless checksums.is_a?(Hash)
+
+    new_sandbox = Chef::Sandbox.new
+    result_checksums = Hash.new
+    
+    all_existing_checksums = Chef::Checksum.cdb_all_checksums
+    checksums.keys.each do |checksum|
+      if all_existing_checksums[checksum]
+        result_checksums[checksum] = {
+          :needs_upload => false
+        }
+      else
+        result_checksums[checksum] = {
+          :url => absolute_url(:sandbox_checksum, :sandbox_id => new_sandbox.guid, :checksum => checksum),
+          :needs_upload => true
+        }
+        new_sandbox.checksums << checksum
+      end
+    end
+    
+    FileUtils.mkdir_p(sandbox_location(new_sandbox.guid))
+    
+    new_sandbox.cdb_save
+    
+    # construct successful response
+    self.status = 201
+    location = absolute_url(:sandbox, :sandbox_id => new_sandbox.guid)
+    headers['Location'] = location
+    result = { 'uri' => location, 'checksums' => result_checksums, 'sandbox_id' => new_sandbox.guid }
+    #result = { 'uri' => location }
+    
+    display result
+  end
+  
+  def upload_checksum
+    sandbox_guid = params[:sandbox_id]
+    checksum = params[:checksum]
+    
+    existing_sandbox = Chef::Sandbox.cdb_load(sandbox_guid)
+    raise NotFound, "cannot find sandbox with guid #{sandbox_guid}" unless existing_sandbox  
+    raise NotFound, "checksum #{checksum} isn't a part of sandbox #{sandbox_guid}" unless existing_sandbox.checksums.member?(checksum)
+
+    Tempfile.open("sandbox") do |src|
+      src.write(self.request.env["rack.input"].string) 
+      src.close
+
+      observed_checksum = Chef::Cache::Checksum.generate_md5_checksum_for_file(src.path)
+      
+      raise BadRequest, "Checksum did not match: expected #{checksum}, observed #{observed_checksum}" unless observed_checksum == checksum
+    
+      dest = sandbox_checksum_location(sandbox_guid, checksum)
+      Chef::Log.info("upload_checksum: move #{src} to #{dest}")
+      FileUtils.mv(src.path, dest)
+    end
+    
+    url = absolute_url(:sandbox_checksum, :sandbox_id => sandbox_guid, :checksum => checksum)
+    result = { 'uri' => url }
+    display result
+  end
+  
+  def update
+    # look up the sandbox by its guid
+    existing_sandbox = Chef::Sandbox.cdb_load(params[:sandbox_id])
+    raise NotFound, "cannot find sandbox with guid #{sandbox_id}" unless existing_sandbox
+    
+    raise BadRequest, "cannot update sandbox #{sandbox_id}: already complete" if existing_sandbox.is_completed
+
+    if params[:is_completed]
+      existing_sandbox.is_completed = (params[:is_completed] == true)
+
+      if existing_sandbox.is_completed
+        # Check if files were uploaded to sandbox directory before we 
+        # commit the sandbox. Fail if any weren't.
+        existing_sandbox.checksums.each do |checksum|
+          checksum_filename = sandbox_checksum_location(existing_sandbox.guid, checksum)
+          if !File.exists?(checksum_filename)
+            raise BadRequest, "cannot update sandbox #{params[:sandbox_id]}: checksum #{checksum} was not uploaded"
+          end
+        end
+        
+        # If we've gotten here all the files have been uploaded.
+        # Track the steps to undo everything we've done. If any steps fail,
+        # we will undo the successful steps that came before it
+        begin
+          undo_steps = Array.new
+          existing_sandbox.checksums.each do |checksum|
+            checksum_filename_in_sandbox = sandbox_checksum_location(existing_sandbox.guid, checksum)
+            checksum_filename_final = checksum_location(checksum)
+            FileUtils.mkdir_p File.dirname(checksum_filename_final)
+            
+            Chef::Log.info("sandbox finalization: move #{checksum_filename_in_sandbox} to #{checksum_filename_final}")
+            File.rename(checksum_filename_in_sandbox, checksum_filename_final)
+            
+            # mark the checksum as successfully updated
+            Chef::Checksum.new(checksum).cdb_save
+            
+            undo_steps << proc {
+              Chef::Log.warn("sandbox finalization undo: moving #{checksum_filename_final} back to #{checksum_filename_in_sandbox}")
+              File.rename(checksum_filename_final, checksum_filename_in_sandbox)
+            }
+          end
+        rescue
+          # undo the successful moves we did before
+          Chef::Log.error("sandbox finalization: got exception moving files, undoing previous changes: #{$!} -- #{$!.backtrace.join("\n")}")
+          undo_steps.each do |undo_step|
+            undo_step.call
+          end
+          raise
+        end
+        
+      end
+    end
+    
+    existing_sandbox.cdb_save
+
+    display existing_sandbox
+  end
+  
+  def destroy
+    raise NotFound, "Destroy not implemented"
+  end
+  
+end
+

data/app/controllers/search.rb

@@ -7,9 +7,9 @@
 # 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.
@@ -19,15 +19,15 @@
 
 require 'chef/solr/query'
 
-class ChefServerApi::Search < ChefServerApi::Application
+class Search < Application
   provides :json
- 
+
   before :authenticate_every
   before :is_admin, :only => [:reindex]
-  
+
   def index
     indexes = valid_indexes
-    display(indexes.inject({}) { |r,i| r[i] = absolute_slice_url(:search, i); r })    
+    display(indexes.inject({}) { |r,i| r[i] = absolute_url(:search, i); r })
   end
 
   def valid_indexes
@@ -40,7 +40,7 @@ class ChefServerApi::Search < ChefServerApi::Application
       raise NotFound, "I don't know how to search for #{params[:id]} data objects."
     end
 
-    query = Chef::Solr::Query.new(Chef::Config[:solr_url], Chef::Config[:couchdb_database])
+    query = Chef::Solr::Query.new(Chef::Config[:solr_url])
     params[:q]     ||= "*:*"
     params[:sort]  ||= nil
     params[:start] ||= 0
@@ -52,7 +52,7 @@ class ChefServerApi::Search < ChefServerApi::Application
       "total" => total
     })
   end
-  
+
   def reindex
     display(Chef::Solr.new.rebuild_index)
   end