chef-server-api 0.9.18 → 0.10.0.beta.0

data/README.rdoc

@@ -15,7 +15,6 @@ chef:
 *  ruby-openid  
 *  json  
 *  erubis  
-*  extlib  
 *  stomp  
 *  ohai  
 

data/app/controllers/application.rb

@@ -45,7 +45,7 @@ class Application < Merb::Controller
       authenticator.authenticate_request(user_key)
     rescue Mixlib::Authentication::MissingAuthenticationHeader => e
       Chef::Log.debug "Authentication failed: #{e.class.name}: #{e.message}\n#{e.backtrace.join("\n")}"
-      raise Unauthorized, "#{e.class.name}: #{e.message}"
+      raise BadRequest, "#{e.class.name}: #{e.message}"
     rescue StandardError => se
       Chef::Log.debug "Authentication failed: #{se}, #{se.backtrace.join("\n")}"
       raise Unauthorized, "Failed to authenticate. Ensure that your client key is valid."

data/app/controllers/cookbooks.rb

@@ -9,9 +9,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.
@@ -23,15 +23,16 @@ require 'chef/cookbook_loader'
 require 'chef/cookbook/metadata'
 
 class Cookbooks < Application
-  
+
+  include Merb::CookbookVersionHelper
+
   provides :json
 
   before :authenticate_every
   before :params_helper
-  before :is_admin, :only => [ :update, :destroy ]
 
   attr_accessor :cookbook_name, :cookbook_version
-  
+
   def params_helper
     self.cookbook_name = params[:cookbook_name]
     self.cookbook_version = params[:cookbook_version]
@@ -39,39 +40,47 @@ class Cookbooks < Application
 
   include Chef::Mixin::Checksum
   include Merb::TarballHelper
-  
-  def index
-    cookbook_list = Chef::CookbookVersion.cdb_list_latest.keys.sort
-    response = Hash.new
-    cookbook_list.map! do |cookbook_name|
-      response[cookbook_name] = absolute_url(:cookbook, :cookbook_name => cookbook_name)
-    end
-    display response
-  end
 
-  def index_latest
-    cookbook_list = Chef::CookbookVersion.cdb_list_latest(true)
-    response = cookbook_list.inject({}) do |res, cv|
-      res[cv.name] = absolute_url(:cookbook_version, :cookbook_name => cv.name, :cookbook_version => cv.version)
+  # returns data in the format of:
+  # {"apache2" => {
+  #     :url => "http://url",
+  #     :versions => [{:url => "http://url/1.0.0", :version => "1.0.0"}, {:url => "http://url/0.0.1", :version=>"0.0.1"}]
+  #   }
+  # }
+  def index
+    cookbook_list = Chef::CookbookVersion.cdb_list
+    # cookbook_list is in the format of {"apache2" => [0.0.1, 0.0.0]} where the version numbers are DepSelector::Version objects
+    num_versions = num_versions!
+    display(cookbook_list.inject({}) {|res, (cookbook_name, versions)|
+      versions = versions.map{ |x| DepSelector::Version.new(x) }.sort.reverse.map{ |x| x.to_s }
+      res[cookbook_name] = expand_cookbook_urls(cookbook_name, versions, num_versions)
       res
-    end
-    display response
+    })
   end
 
   def index_recipes
-    all_cookbooks = Array(Chef::CookbookVersion.cdb_list_latest(true))
-    all_cookbooks.map! do |cookbook|
-      cookbook.manifest["recipes"].map { |r| "#{cookbook.name}::#{File.basename(r['name'], ".rb")}" }
+    recipes_with_versions = Chef::CookbookVersion.cdb_list(true).inject({}) do|memo, f|
+      memo[f.name] ||= {}
+      memo[f.name][f.version] = f.recipe_filenames_by_name.keys
+      memo
     end
-    all_cookbooks.flatten!
-    all_cookbooks.sort!
-    display all_cookbooks
+    display recipes_with_versions
   end
 
+  # GET /cookbooks/:cookbook_name
+  #
+  # returns data in the format of:
+  # {"apache2" => {
+  #     :url => "http://url",
+  #     :versions => [{:url => "http://url/1.0.0", :version => "1.0.0"}, {:url => "http://url/0.0.1", :version=>"0.0.1"}]
+  #   }
+  # }
   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
+    num_versions = num_versions!("all")
+    cb_versions = versions[cookbook_name].map{ |x| DepSelector::Version.new(x) }.sort.reverse.map{ |x| x.to_s }
+    display({ cookbook_name => expand_cookbook_urls(cookbook_name, cb_versions, num_versions) })
   end
 
   def show
@@ -81,7 +90,7 @@ class Cookbooks < Application
 
   def show_file
     cookbook = get_cookbook_version(cookbook_name, cookbook_version)
-    
+
     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)
 
@@ -99,9 +108,9 @@ class Cookbooks < Application
     end
 
     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}.") 
+      raise(BadRequest, "You said the cookbook was version #{params['inflated_object'].version}, but the URL says it should be #{cookbook_version}.")
     end
-    
+
     begin
       cookbook = Chef::CookbookVersion.cdb_load(cookbook_name, cookbook_version)
       cookbook.manifest = params['inflated_object'].manifest
@@ -109,29 +118,35 @@ class Cookbooks < Application
       Chef::Log.debug("Cookbook #{cookbook_name} version #{cookbook_version} does not exist")
       cookbook = params['inflated_object']
     end
-    
+
+    if cookbook.frozen_version? && params[:force].nil?
+      raise Conflict, "The cookbook #{cookbook.name} at version #{cookbook.version} is frozen. Use the 'force' option to override."
+    end
+
+    cookbook.freeze_version if params["inflated_object"].frozen_version?
+
     # 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
-    
+
     raise InternalServerError, "Error saving cookbook" unless cookbook.cdb_save
 
     display cookbook
   end
-  
+
   def destroy
     begin
       cookbook = get_cookbook_version(cookbook_name, cookbook_version)
@@ -159,6 +174,6 @@ class Cookbooks < Application
       raise
     end
   end
-  
+
 end
 

data/app/controllers/environments.rb

@@ -0,0 +1,207 @@
+#
+# Author:: Stephen Delano (<stephen@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Copyright:: Copyright (c) 2010, 2011 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/environment'
+require 'chef/cookbook_version_selector'
+
+class Environments < Application
+
+  include Merb::CookbookVersionHelper
+
+  provides :json
+
+  before :authenticate_every
+  before :is_admin, :only => [ :create, :update, :destroy ]
+
+  # GET /environments
+  def index
+    environment_list = Chef::Environment.cdb_list(true)
+    display(environment_list.inject({}) { |res, env| res[env.name] = absolute_url(:environment, env.name); res })
+  end
+
+  # GET /environments/:id
+  def show
+    begin
+      environment = Chef::Environment.cdb_load(params[:id])
+    rescue Chef::Exceptions::CouchDBNotFound => e
+      raise NotFound, "Cannot load environment #{params[:id]}"
+    end
+    environment.couchdb_rev = nil
+    display environment
+  end
+
+  # POST /environments
+  def create
+    env = params["inflated_object"]
+    exists = true
+    begin
+      Chef::Environment.cdb_load(env.name)
+    rescue Chef::Exceptions::CouchDBNotFound
+      exists = false
+    end
+    raise Conflict, "Environment already exists" if exists
+
+    env.cdb_save
+    self.status = 201
+    display({:uri => absolute_url(:environment, env.name)})
+  end
+
+  # PUT /environments/:id
+  def update
+    raise MethodNotAllowed if params[:id] == "_default"
+    begin
+      env = Chef::Environment.cdb_load(params[:id])
+    rescue Chef::Exceptions::CouchDBNotFound
+      raise NotFound, "Cannot load environment #{params[:id]}"
+    end
+
+    env.update_from!(params["inflated_object"])
+    env.cdb_save
+    env.couchdb_rev = nil
+    self.status = 200
+    display(env)
+  end
+
+  # DELETE /environments/:id
+  def destroy
+    raise MethodNotAllowed if params[:id] == "_default"
+    begin
+      env = Chef::Environment.cdb_load(params[:id])
+    rescue Chef::Exceptions::CouchDBNotFound
+      raise NotFound, "Cannot load environment #{params[:id]}"
+    end
+    env.cdb_destroy
+    display(env)
+  end
+
+  # GET /environments/:environment_id/cookbooks
+  # returns data in the format of:
+  # {"apache2" => {
+  #     :url => "http://url",
+  #     :versions => [{:url => "http://url/1.0.0", :version => "1.0.0"}, {:url => "http://url/0.0.1", :version=>"0.0.1"}]
+  #   }
+  # }
+  def list_cookbooks
+    begin
+      filtered_cookbooks = Chef::Environment.cdb_load_filtered_cookbook_versions(params[:environment_id])
+    rescue Chef::Exceptions::CouchDBNotFound
+      raise NotFound, "Cannot load environment #{params[:environment_id]}"
+    end
+    num_versions = num_versions!
+    display(filtered_cookbooks.inject({}) {|res, (cookbook_name,versions)|
+      versions.map!{|v| v.version.to_s}
+      res[cookbook_name] = expand_cookbook_urls(cookbook_name, versions, num_versions)
+      res
+    })
+  end
+
+  # GET /environments/:environment_id/cookbooks/:cookbook_id
+  # returns data in the format of:
+  # {"apache2" => {
+  #     :url => "http://url",
+  #     :versions => [{:url => "http://url/1.0.0", :version => "1.0.0"}, {:url => "http://url/0.0.1", :version=>"0.0.1"}]
+  #   }
+  # }
+  def cookbook
+    cookbook_name = params[:cookbook_id]
+    begin
+      filtered_cookbooks = Chef::Environment.cdb_load_filtered_cookbook_versions(params[:environment_id])
+    rescue Chef::Exceptions::CouchDBNotFound
+      raise NotFound, "Cannot load environment #{params[:environment_id]}"
+    end
+    raise NotFound, "Cannot load cookbook #{cookbook_name}" unless filtered_cookbooks.has_key?(cookbook_name)
+    versions = filtered_cookbooks[cookbook_name].map{|v| v.version.to_s}
+    num_versions = num_versions!("all")
+    display({ cookbook_name => expand_cookbook_urls(cookbook_name, versions, num_versions) })
+  end
+
+  # GET /environments/:environment/recipes
+  def list_recipes
+    display(Chef::Environment.cdb_load_filtered_recipe_list(params[:environment_id]))
+  end
+
+  # GET /environments/:environment_id/nodes
+  def list_nodes
+    node_list = Chef::Node.cdb_list_by_environment(params[:environment_id])
+    display(node_list.inject({}) {|r,n| r[n] = absolute_url(:node, n); r})
+  end
+
+  # GET /environments/:environment_id/roles/:role_id
+  def role
+    begin
+      role = Chef::Role.cdb_load(params[:role_id])
+    rescue Chef::Exceptions::CouchDBNotFound
+      raise NotFound, "Cannot load role #{params[:role_id]}"
+    end
+    display("run_list" => role.env_run_lists[params[:environment_id]])
+  end
+
+  # POST /environments/:environment_id/cookbook_versions
+  #
+  # Take the given run_list and return the versions of cookbooks that would
+  # be used after applying the constraints of the given environment.
+  #
+  # INPUT: 
+  #  :run_list = an Array of String's, e.g.,
+  #  ["recipe[apache2]", "recipe[runit]"]
+  #
+  # OUT:
+  #  Hash of cookbook names cookbook manifest
+  #
+  # NOTE: This method is a POST, not because it's a mutator (it's idempotent),
+  # but the run_list can likely exceed Merb's query string limit for GET
+  # of 1024 characters.
+  def cookbook_versions_for_run_list
+    begin
+      # not possible to be nil due to the route to get us to this API
+      # endpoint
+      environment_input = params[:environment_id]
+
+      run_list_input = params[:run_list]
+      raise BadRequest, "Missing param: run_list" unless run_list_input
+      raise BadRequest, "Param run_list is not an Array: #{run_list_input.class}" unless run_list_input.is_a?(Array)
+
+      # Convert the input array of strings to a RunList containing
+      # RunListItem's.
+      run_list = Chef::RunList.new
+      run_list_input.each do |run_list_item_string|
+        run_list << run_list_item_string
+      end
+
+      # Expand the run list in the scope of the specified environment.
+      names_to_cookbook_version = Chef::CookbookVersionSelector.expand_to_cookbook_versions(run_list, environment_input)
+    rescue Chef::Exceptions::CouchDBNotFound
+      raise NotFound, "Cannot load environment #{params[:environment_id]}"
+    rescue Chef::Exceptions::CookbookVersionSelection::InvalidRunListItems => e
+      raise PreconditionFailed, e.to_json
+    rescue Chef::Exceptions::CookbookVersionSelection::UnsatisfiableRunListItem => e
+      raise PreconditionFailed, e.to_json
+    end
+
+    # Convert from
+    #  name => CookbookVersion
+    # to
+    #  name => cookbook manifest
+    # and display.
+    display(names_to_cookbook_version.inject({}) do |res, (cookbook_name, cookbook_version)|
+              res[cookbook_name] = cookbook_version.generate_manifest_with_urls {|opts| absolute_url(:cookbook_file, opts) }
+              res
+            end)
+  end
+end

data/app/controllers/main.rb

@@ -1,18 +1,25 @@
 class Main < Application
 
-  before :authenticate_every
   provides :html, :json
 
   def index
-    display(
-      { 
-        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"
-      }
-    )
+    case content_type
+    when :json
+      display 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"
+    else
+      @webui_url = if Chef::Config[:chef_webui_url]
+        Chef::Config[:chef_webui_url]
+      elsif request.host =~ /(.*):4000/
+        absolute_url(:top, :host => "#{$1}:4040")
+      else
+        nil
+      end
+      render
+    end
   end
   
 end

data/app/controllers/nodes.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.
@@ -17,17 +17,20 @@
 # limitations under the License.
 #
 
-require 'chef' / 'node'
+require 'chef/node'
+require 'chef/version_class'
+require 'chef/version_constraint'
+require 'chef/cookbook_version_selector'
 
 class Nodes < Application
-  
+
   provides :json
-  
-  before :authenticate_every 
+
+  before :authenticate_every
   before :admin_or_requesting_node, :only => [ :update, :destroy, :cookbooks ]
-  
+
   def index
-    @node_list = Chef::Node.cdb_list 
+    @node_list = Chef::Node.cdb_list
     display(@node_list.inject({}) do |r,n|
       r[n] = absolute_url(:node, n); r
     end)
@@ -46,7 +49,7 @@ class Nodes < Application
   def create
     @node = params["inflated_object"]
     begin
-      Chef::Node.cdb_load(@node.name) 
+      Chef::Node.cdb_load(@node.name)
       raise Conflict, "Node already exists"
     rescue Chef::Exceptions::CouchDBNotFound
     end
@@ -62,12 +65,7 @@ class Nodes < Application
       raise NotFound, "Cannot load node #{params[:id]}"
     end
 
-    updated = params['inflated_object']
-    @node.run_list.reset!(updated.run_list)
-    @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.update_from!(params['inflated_object'])
     @node.cdb_save
     @node.couchdb_rev = nil
     display(@node)
@@ -76,7 +74,7 @@ class Nodes < Application
   def destroy
     begin
       @node = Chef::Node.cdb_load(params[:id])
-    rescue Chef::Exceptions::CouchDBNotFound => e 
+    rescue Chef::Exceptions::CouchDBNotFound => e
       raise NotFound, "Cannot load node #{params[:id]}"
     end
     @node.cdb_destroy
@@ -84,86 +82,34 @@ class Nodes < Application
     display @node
   end
 
+  # Return a hash, cookbook_name => cookbook manifest, of the cookbooks
+  # appropriate for this node, using its run_list and environment.
   def cookbooks
     begin
       @node = Chef::Node.cdb_load(params[:id])
-    rescue Chef::Exceptions::CouchDBNotFound => e 
+    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({}) do |res, cookbook|
-      version            = Gem::Version.new cookbook.version
-      newest_version     = res.has_key?(cookbook.name) ? version > Gem::Version.new(res[cookbook.name].version) : true
-      res[cookbook.name] = cookbook if newest_version
-      res
-    end
-
-    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)
-
-    # expand returns a RunListExpansion which contains recipes, default and override attrs [cb]
-    recipes = node.run_list.expand('couchdb').recipes
-
-    # walk run list and accumulate included dependencies
-    recipes.inject({}) do |included_cookbooks, recipe|
-      expand_cookbook_deps(included_cookbooks, all_cookbooks, recipe)
-      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
+    # Get the mapping of cookbook_name => CookbookVersion applicable to
+    # this node's run_list and its environment.
+    begin
+      included_cookbooks = Chef::CookbookVersionSelector.expand_to_cookbook_versions(@node.run_list, @node.chef_environment)
+    rescue Chef::Exceptions::CookbookVersionSelection::InvalidRunListItems => e
+      raise PreconditionFailed, e.to_json
+    rescue Chef::Exceptions::CookbookVersionSelection::UnsatisfiableRunListItem => e
+      raise PreconditionFailed, e.to_json
     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
+    # Convert from
+    #  name => CookbookVersion
+    # to
+    #  name => cookbook manifest
+    # and display.
+    display(included_cookbooks.inject({}) do |acc, (cookbook_name, cookbook_version)|
+              acc[cookbook_name.to_s] = cookbook_version.generate_manifest_with_urls{|opts| absolute_url(:cookbook_file, opts) }
+              acc
+            end)
   end
 
 end
-