microwave 0.1004.5 → 0.1004.6

data/lib/chef.rb

@@ -36,6 +36,5 @@ require 'chef/handler/json_file'
 
 require 'chef/monkey_patches/tempfile'
 require 'chef/monkey_patches/dir'
-require 'chef/monkey_patches/string'
 require 'chef/monkey_patches/numeric'
 require 'chef/monkey_patches/object'

data/lib/chef/client.rb

@@ -236,25 +236,6 @@ class Chef
       @node
     end
 
-    # Sync_cookbooks eagerly loads all files except files and
-    # templates.  It returns the cookbook_hash -- the return result
-    # from /environments/#{node.chef_environment}/cookbook_versions,
-    # which we will use for our run_context.
-    #
-    # === Returns
-    # Hash:: The hash of cookbooks with download URLs as given by the server
-    def sync_cookbooks
-      Chef::Log.debug("Synchronizing cookbooks")
-      cookbook_hash = rest.post_rest("environments/#{@node.chef_environment}/cookbook_versions",
-                                     {:run_list => @expanded_run_list_with_versions})
-      Chef::CookbookVersion.sync_cookbooks(cookbook_hash)
-
-      # register the file cache path in the cookbook path so that CookbookLoader actually picks up the synced cookbooks
-      Chef::Config[:cookbook_path] = File.join(Chef::Config[:file_cache_path], "cookbooks")
-
-      cookbook_hash
-    end
-
     # Converges the node.
     #
     # === Returns

data/lib/chef/config.rb

@@ -25,46 +25,10 @@ class Chef
 
     extend Mixlib::Config
 
-    # Manages the chef secret session key
-    # === Returns
-    # <newkey>:: A new or retrieved session key
-    #
-    def self.manage_secret_key
-      newkey = nil
-      if Chef::FileCache.has_key?("chef_server_cookie_id")
-        newkey = Chef::FileCache.load("chef_server_cookie_id")
-      else
-        chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
-        newkey = ""
-        40.times { |i| newkey << chars[rand(chars.size-1)] }
-        Chef::FileCache.store("chef_server_cookie_id", newkey)
-      end
-      newkey
-    end
-
     def self.inspect
       configuration.inspect
     end
 
-    # Override the config dispatch to set the value of multiple server options simultaneously
-    #
-    # === Parameters
-    # url<String>:: String to be set for all of the chef-server-api URL's
-    #
-    config_attr_writer :chef_server_url do |url|
-      configure do |c|
-        [ :registration_url,
-          :template_url,
-          :remotefile_url,
-          :search_url,
-          :chef_server_url,
-          :role_url ].each do |u|
-            c[u] = url
-        end
-      end
-      url
-    end
-
     # Override the config dispatch to set the value of log_location configuration option
     #
     # === Parameters
@@ -84,50 +48,35 @@ class Chef
     # Turn on "path sanity" by default. See also: http://wiki.opscode.com/display/chef/User+Environment+PATH+Sanity
     enforce_path_sanity(true)
 
-    # The number of times the client should retry when registering with the server
-    client_registration_retries 5
-
     # Where the cookbooks are located. Meaning is somewhat context dependent between
     # chef-client, and chef-solo.
-    cookbook_path [ "/var/chef/cookbooks", "/var/chef/site-cookbooks" ]
+    cookbook_path [ "#{ENV['HOME']}/cookbooks" ] + $:.reject {|x| x.match(/\/cookbooks$/) ? nil : x }
 
     # Where cookbook files are stored on the server (by content checksum)
-    checksum_path "/var/chef/checksums"
+    checksum_path "#{ENV['HOME']}/.microwave/checksums"
 
     # Where chef's cache files should be stored
-    file_cache_path "/var/chef/cache"
+    file_cache_path "#{ENV['HOME']}/.microwave/cache"
 
     # Where backups of chef-managed files should go
-    file_backup_path "/var/chef/backup"
+    file_backup_path "#{ENV['HOME']}/.microwave/backup"
 
-    http_retry_count 5
-    http_retry_delay 5
     interval nil
     log_level :info
     log_location STDOUT
     verbose_logging nil
     node_name nil
-    node_path "/var/chef/node"
+    node_path "#{ENV['HOME']}/nodes"
 
     pid_file nil
 
-    rest_timeout 300
     run_command_stderr_timeout 120
     run_command_stdout_timeout 120
     solo  false
     splay nil
 
-    # Set these to enable SSL authentication / mutual-authentication
-    # with the server
-    ssl_client_cert nil
-    ssl_client_key nil
-    ssl_verify_mode :verify_none
-    ssl_ca_path nil
-    ssl_ca_file nil
-
-
     # Where should chef-solo look for role files?
-    role_path "/var/chef/roles"
+    role_path [ "#{ENV['HOME']}/roles" ]
 
     # Report Handlers
     report_handlers []
@@ -138,7 +87,7 @@ class Chef
     # Checksum Cache
     # Uses Moneta on the back-end
     cache_type "BasicFile"
-    cache_options({ :path => "/var/chef/cache/checksums", :skip_expires => true })
+    cache_options({ :path => "#{ENV['HOME']}/.microwave/cache/checksums", :skip_expires => true })
 
     # Those lists of regular expressions define what chef considers a
     # valid user and group name

data/lib/chef/cookbook/cookbook_version_loader.rb

@@ -45,7 +45,6 @@ class Chef
 
       def load_cookbooks
         load_as(:attribute_filenames, 'attributes', '*.rb')
-        load_as(:definition_filenames, 'definitions', '*.rb')
         load_as(:recipe_filenames, 'recipes', '*.rb')
         load_as(:library_filenames, 'libraries', '*.rb')
         load_recursively_as(:template_filenames, "templates", "*")
@@ -58,8 +57,6 @@ class Chef
 
         if File.exists?(File.join(@cookbook_path, "metadata.rb"))
           @metadata_filenames << File.join(@cookbook_path, "metadata.rb")
-        elsif File.exists?(File.join(@cookbook_path, "metadata.json"))
-          @metadata_filenames << File.join(@cookbook_path, "metadata.json")
         end
 
         if empty?
@@ -94,8 +91,6 @@ class Chef
           case metadata_file
           when /\.rb$/
             apply_ruby_metadata(metadata_file)
-          when /\.json$/
-            apply_json_metadata(metadata_file)
           else
             raise RuntimeError, "Invalid metadata file: #{metadata_file} for cookbook: #{cookbook_version}"
           end
@@ -159,15 +154,6 @@ class Chef
         end
       end
 
-      def apply_json_metadata(file)
-        begin
-          @metadata.from_json(IO.read(file))
-        rescue JSON::ParserError
-          Chef::Log.error("Couldn't parse cookbook metadata JSON for #@cookbook_name in " + file)
-          raise
-        end
-      end
-
     end
   end
 end

data/lib/chef/cookbook_version.rb

@@ -22,7 +22,6 @@
 require 'chef/log'
 require 'chef/client'
 require 'chef/node'
-require 'chef/resource_definition_list'
 require 'chef/recipe'
 require 'chef/cookbook/file_vendor'
 require 'chef/checksum'
@@ -92,7 +91,7 @@ class Chef
   class CookbookVersion
     include Comparable
 
-    COOKBOOK_SEGMENTS = [ :resources, :providers, :recipes, :definitions, :libraries, :attributes, :files, :templates, :root_files ]
+    COOKBOOK_SEGMENTS = [ :resources, :providers, :recipes, :libraries, :attributes, :files, :templates, :root_files ]
 
     attr_accessor :root_dir
     attr_accessor :definition_filenames
@@ -149,25 +148,6 @@ class Chef
       reset_cache_validity
     end
 
-    # Synchronizes all the cookbooks from the chef-server.
-    #
-    # === Returns
-    # true:: Always returns true
-    def self.sync_cookbooks(cookbook_hash)
-      Chef::Log.info("Loading cookbooks [#{cookbook_hash.keys.sort.join(', ')}]")
-      Chef::Log.debug("Cookbooks detail: #{cookbook_hash.inspect}")
-
-      clear_obsoleted_cookbooks(cookbook_hash)
-
-      # Synchronize each of the node's cookbooks, and add to the
-      # valid_cache_entries hash.
-      cookbook_hash.values.each do |cookbook|
-        sync_cookbook_file_cache(cookbook)
-      end
-
-      true
-    end
-
     # Iterates over cached cookbooks' files, removing files belonging to
     # cookbooks that don't appear in +cookbook_hash+
     def self.clear_obsoleted_cookbooks(cookbook_hash)
@@ -181,67 +161,6 @@ class Chef
       end
     end
 
-    # Update the file caches for a given cache segment.  Takes a segment name
-    # and a hash that matches one of the cookbooks/_attribute_files style
-    # remote file listings.
-    #
-    # === Parameters
-    # cookbook<Chef::Cookbook>:: The cookbook to update
-    # valid_cache_entries<Hash>:: Out-param; Added to this hash are the files that
-    # were referred to by this cookbook
-    def self.sync_cookbook_file_cache(cookbook)
-      Chef::Log.debug("Synchronizing cookbook #{cookbook.name}")
-
-      # files and templates are lazily loaded, and will be done later.
-      eager_segments = COOKBOOK_SEGMENTS.dup
-      eager_segments.delete(:files)
-      eager_segments.delete(:templates)
-
-      eager_segments.each do |segment|
-        segment_filenames = Array.new
-        cookbook.manifest[segment].each do |manifest_record|
-          # segment = cookbook segment
-          # remote_list = list of file hashes
-          #
-          # We need the list of known good attribute files, so we can delete any that are
-          # just laying about.
-
-          cache_filename = File.join("cookbooks", cookbook.name, manifest_record['path'])
-          valid_cache_entries[cache_filename] = true
-
-          current_checksum = nil
-          if cache.has_key?(cache_filename)
-            current_checksum = checksum_cookbook_file(cache.load(cache_filename, false))
-          end
-
-          # If the checksums are different between on-disk (current) and on-server
-          # (remote, per manifest), do the update. This will also execute if there
-          # is no current checksum.
-          if current_checksum != manifest_record['checksum']
-            raw_file = chef_server_rest.get_rest(manifest_record[:url], true)
-
-            Chef::Log.info("Storing updated #{cache_filename} in the cache.")
-            cache.move_to(raw_file.path, cache_filename)
-          else
-            Chef::Log.debug("Not storing #{cache_filename}, as the cache is up to date.")
-          end
-
-          # make the segment filenames a full path.
-          full_path_cache_filename = cache.load(cache_filename, false)
-          segment_filenames << full_path_cache_filename
-        end
-
-        # replace segment filenames with a full-path one.
-        if segment.to_sym == :recipes
-          cookbook.recipe_filenames = segment_filenames
-        elsif segment.to_sym == :attributes
-          cookbook.attribute_filenames = segment_filenames
-        else
-          cookbook.segment_filenames(segment).replace(segment_filenames)
-        end
-      end
-    end
-
     def self.cleanup_file_cache
     end
 
@@ -423,8 +342,6 @@ class Chef
         @recipe_filenames
       when :libraries
         @library_filenames
-      when :definitions
-        @definition_filenames
       when :attributes
         @attribute_filenames
       when :files
@@ -618,58 +535,10 @@ class Chef
       rendered_manifest
     end
 
-    def metadata_json_file
-      File.join(root_dir, "metadata.json")
-    end
-
     def metadata_rb_file
       File.join(root_dir, "metadata.rb")
     end
 
-    def reload_metadata!
-      if File.exists?(metadata_json_file)
-        metadata.from_json(IO.read(metadata_json_file))
-      end
-    end
-
-    def destroy
-      chef_server_rest.delete_rest("cookbooks/#{name}/#{version}")
-      self
-    end
-
-    def self.load(name, version="_latest")
-      version = "_latest" if version == "latest"
-      chef_server_rest.get_rest("cookbooks/#{name}/#{version}")
-    end
-
-    def self.list
-      chef_server_rest.get_rest('cookbooks')
-    end
-
-    ##
-    # Given a +cookbook_name+, get a list of all versions that exist on the
-    # server.
-    # ===Returns
-    # [String]::  Array of cookbook versions, which are strings like 'x.y.z'
-    # nil::       if the cookbook doesn't exist. an error will also be logged.
-    def self.available_versions(cookbook_name)
-      chef_server_rest.get_rest("cookbooks/#{cookbook_name}")[cookbook_name]["versions"].map do |cb|
-        cb["version"]
-      end
-    rescue Net::HTTPServerException => e
-      if e.to_s =~ /^404/
-        Chef::Log.error("Cannot find a cookbook named #{cookbook_name}")
-        nil
-      else
-        raise
-      end
-    end
-
-    # Get the newest version of all cookbooks
-    def self.latest_cookbooks
-      chef_server_rest.get_rest('cookbooks/_latest')
-    end
-
     def <=>(o)
       raise Chef::Exceptions::CookbookVersionNameMismatch if self.name != o.name
       # FIXME: can we change the interface to the Metadata class such
@@ -691,7 +560,6 @@ class Chef
     def generate_manifest
       manifest = Mash.new({
         :recipes => Array.new,
-        :definitions => Array.new,
         :libraries => Array.new,
         :attributes => Array.new,
         :files => Array.new,

data/lib/chef/environment.rb

@@ -207,42 +207,6 @@ class Chef
       environment
     end
 
-    def self.list(inflate=false)
-      if inflate
-        # TODO: index the environments and use search to inflate - don't inflate for now :(
-        chef_server_rest.get_rest("environments")
-      else
-        chef_server_rest.get_rest("environments")
-      end
-    end
-
-    def self.load(name)
-      chef_server_rest.get_rest("environments/#{name}")
-    end
-
-    def destroy
-      chef_server_rest.delete_rest("environments/#{@name}")
-    end
-
-    def save
-      begin
-        chef_server_rest.put_rest("environments/#{@name}", self)
-      rescue Net::HTTPServerException => e
-        raise e unless e.response.code == "404"
-        chef_server_rest.post_rest("environments", self)
-      end
-      self
-    end
-
-    def create
-      chef_server_rest.post_rest("environments", self)
-      self
-    end
-
-    def self.load_filtered_recipe_list(environment)
-      chef_server_rest.get_rest("environments/#{environment}/recipes")
-    end
-
     def to_s
       @name
     end

data/lib/chef/handler/json_file.rb

@@ -27,7 +27,7 @@ class Chef
 
       def initialize(config={})
         @config = config
-        @config[:path] ||= "/var/chef/reports"
+        @config[:path] ||= "#{ENV['HOME']}/.microwave/reports"
         @config
       end
 

data/lib/chef/mixin/recipe_definition_dsl_core.rb

@@ -34,43 +34,27 @@ class Chef
       include Chef::Mixin::Language
       
       def method_missing(method_symbol, *args, &block)
-        # If we have a definition that matches, we want to use that instead.  This should
-        # let you do some really crazy over-riding of "native" types, if you really want
-        # to. 
-        if run_context.definitions.has_key?(method_symbol)
-          # This dupes the high level object, but we still need to dup the params
-          new_def = run_context.definitions[method_symbol].dup
-          new_def.params = new_def.params.dup
-          new_def.node = run_context.node
-          # This sets up the parameter overrides
-          new_def.instance_eval(&block) if block
-          new_recipe = Chef::Recipe.new(cookbook_name, @recipe_name, run_context)
-          new_recipe.params = new_def.params
-          new_recipe.params[:name] = args[0]
-          new_recipe.instance_eval(&new_def.recipe)
-        else
-          # Otherwise, we're rocking the regular resource call route.
-          method_name = method_symbol.to_s
-          rname = convert_to_class_name(method_name)
+        # Otherwise, we're rocking the regular resource call route.
+        method_name = method_symbol.to_s
+        rname = convert_to_class_name(method_name)
 
-          super unless Chef::Resource.const_defined?(rname)
-          raise ArgumentError, "You must supply a name when declaring a #{method_name} resource" unless args.size > 0
+        super unless Chef::Resource.const_defined?(rname)
+        raise ArgumentError, "You must supply a name when declaring a #{method_name} resource" unless args.size > 0
 
-          # If we have a resource like this one, we want to steal its state
-          args << run_context
-          resource = Chef::Resource.const_get(rname).new(*args)
-          resource.load_prior_resource
-          resource.cookbook_name = cookbook_name
-          resource.recipe_name = @recipe_name
-          resource.params = @params
-          resource.source_line = caller[0]
-          # Determine whether this resource is being created in the context of an enclosing Provider
-          resource.enclosing_provider = self.is_a?(Chef::Provider) ? self : nil
-          resource.instance_eval(&block) if block
+        # If we have a resource like this one, we want to steal its state
+        args << run_context
+        resource = Chef::Resource.const_get(rname).new(*args)
+        resource.load_prior_resource
+        resource.cookbook_name = cookbook_name
+        resource.recipe_name = @recipe_name
+        resource.params = @params
+        resource.source_line = caller[0]
+        # Determine whether this resource is being created in the context of an enclosing Provider
+        resource.enclosing_provider = self.is_a?(Chef::Provider) ? self : nil
+        resource.instance_eval(&block) if block
 
-          run_context.resource_collection.insert(resource)
-          resource
-        end
+        run_context.resource_collection.insert(resource)
+        resource
       end
       
     end