TrueCar-chef 0.10.0.beta.3

data/lib/chef/exceptions.rb

@@ -0,0 +1,153 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright 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.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Chef
+  # == Chef::Exceptions
+  # Chef's custom exceptions are all contained within the Chef::Exceptions
+  # namespace.
+  class Exceptions
+    class Application < RuntimeError; end
+    class Cron < RuntimeError; end
+    class Env < RuntimeError; end
+    class Exec < RuntimeError; end
+    class ErlCall < RuntimeError; end
+    class FileNotFound < RuntimeError; end
+    class Package < RuntimeError; end
+    class Service < RuntimeError; end
+    class Route < RuntimeError; end
+    class SearchIndex < RuntimeError; end
+    class Override < RuntimeError; end
+    class UnsupportedAction < RuntimeError; end
+    class MissingLibrary < RuntimeError; end
+    class MissingRole < RuntimeError; end
+    class CannotDetermineNodeName < RuntimeError; end
+    class User < RuntimeError; end
+    class Group < RuntimeError; end
+    class Link < RuntimeError; end
+    class Mount < RuntimeError; end
+    class CouchDBNotFound < RuntimeError; end
+    class PrivateKeyMissing < RuntimeError; end
+    class CannotWritePrivateKey < RuntimeError; end
+    class RoleNotFound < RuntimeError; end
+    class ValidationFailed < ArgumentError; end
+    class InvalidPrivateKey < ArgumentError; end
+    class ConfigurationError < ArgumentError; end
+    class RedirectLimitExceeded < RuntimeError; end
+    class AmbiguousRunlistSpecification < ArgumentError; end
+    class CookbookNotFound < RuntimeError; end
+    # Cookbook loader used to raise an argument error when cookbook not found.
+    # for back compat, need to raise an error that inherits from ArgumentError
+    class CookbookNotFoundInRepo < ArgumentError; end
+    class AttributeNotFound < RuntimeError; end
+    class InvalidCommandOption < RuntimeError; end
+    class CommandTimeout < RuntimeError; end
+    class ShellCommandFailed < RuntimeError; end
+    class RequestedUIDUnavailable < RuntimeError; end
+    class InvalidHomeDirectory < ArgumentError; end
+    class DsclCommandFailed < RuntimeError; end
+    class UserIDNotFound < ArgumentError; end
+    class GroupIDNotFound < ArgumentError; end
+    class InvalidResourceReference < RuntimeError; end
+    class ResourceNotFound < RuntimeError; end
+    class InvalidResourceSpecification < ArgumentError; end
+    class SolrConnectionError < RuntimeError; end
+    class IllegalChecksumRevert < RuntimeError; end
+    class CookbookVersionNameMismatch < ArgumentError; end
+    class MissingParentDirectory < RuntimeError; end
+    class UnresolvableGitReference < RuntimeError; end
+    class InvalidEnvironmentRunListSpecification < ArgumentError; end
+    class InvalidDataBagItemID < ArgumentError; end
+    class InvalidDataBagName < ArgumentError; end
+    class EnclosingDirectoryDoesNotExist < ArgumentError; end
+
+    class ObsoleteDependencySyntax < ArgumentError; end
+
+    # A different version of a cookbook was added to a
+    # VersionedRecipeList than the one already there.
+    class CookbookVersionConflict < ArgumentError ; end
+
+    # does not follow X.Y.Z format. ArgumentError?
+    class InvalidCookbookVersion < ArgumentError; end
+
+    # version constraint should be a string or array, or it doesn't
+    # match OP VERSION. ArgumentError?
+    class InvalidVersionConstraint < ArgumentError; end
+
+    class CookbookVersionSelection
+
+      # Compound exception: In run_list expansion and resolution,
+      # run_list items referred to cookbooks that don't exist and/or
+      # have no versions available.
+      class InvalidRunListItems < StandardError
+        attr_reader :non_existent_cookbooks
+        attr_reader :cookbooks_with_no_matching_versions
+
+        def initialize(message, non_existent_cookbooks, cookbooks_with_no_matching_versions)
+          super(message)
+
+          @non_existent_cookbooks = non_existent_cookbooks
+          @cookbooks_with_no_matching_versions = cookbooks_with_no_matching_versions
+        end
+
+        def to_json(*a)
+          result = {
+            "message" => message,
+            "non_existent_cookbooks" => non_existent_cookbooks,
+            "cookbooks_with_no_versions" => cookbooks_with_no_matching_versions
+          }
+          result.to_json(*a)
+        end
+      end
+
+      # In run_list expansion and resolution, a constraint was
+      # unsatisfiable.
+      #
+      # This exception may not be the complete error report. If you
+      # resolve the misconfiguration represented by this exception and
+      # re-solve, you may get another exception
+      class UnsatisfiableRunListItem < StandardError
+        attr_reader :run_list_item
+        attr_reader :non_existent_cookbooks, :most_constrained_cookbooks
+
+        # most_constrained_cookbooks: if I were to remove constraints
+        # regarding these cookbooks, I would get a solution or move on
+        # to the next error (deeper in the graph). An item in this list
+        # may be unsatisfiable, but when resolved may also reveal
+        # further unsatisfiable constraints; this condition would not be
+        # reported.
+        def initialize(message, run_list_item, non_existent_cookbooks, most_constrained_cookbooks)
+          super(message)
+
+          @run_list_item = run_list_item
+          @non_existent_cookbooks = non_existent_cookbooks
+          @most_constrained_cookbooks = most_constrained_cookbooks
+        end
+
+        def to_json(*a)
+          result = {
+            "message" => message,
+            "unsatisfiable_run_list_item" => run_list_item,
+            "non_existent_cookbooks" => non_existent_cookbooks,
+            "most_constrained_cookbooks" => most_constrained_cookbooks
+          }
+          result.to_json(*a)
+        end
+      end
+    end
+  end
+end

data/lib/chef/file_access_control.rb

@@ -0,0 +1,140 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Daniel DeLeo (<dan@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.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/log'
+
+class Chef
+
+  # == Chef::FileAccessControl
+  # FileAccessControl objects set the owner, group and mode of +file+ to
+  # the values specified by a value object, usually a Chef::Resource.
+  class FileAccessControl
+    UINT = (1 << 32)
+    UID_MAX = (1 << 32) - 10
+  
+    attr_reader :resource
+  
+    attr_reader :file
+  
+    # FileAccessControl objects set the owner, group and mode of +file+ to
+    # the values specified by +resource+. +file+ is completely independent
+    # of any file or path attribute on +resource+, so it is possible to set
+    # access control settings on a tempfile (for example).
+    # === Arguments:
+    # resource:   probably a Chef::Resource::File object (or subclass), but
+    #             this is not required. Must respond to +owner+, +group+,
+    #             and +mode+
+    # file:       The file whose access control settings you wish to modify,
+    #             given as a String.
+    def initialize(resource, file)
+      @resource, @file = resource, file
+      @modified = false
+    end
+  
+    def modified?
+      @modified
+    end
+  
+    def set_all
+      set_owner
+      set_group
+      set_mode
+    end
+  
+    # Workaround the fact that Ruby's Etc module doesn't believe in negative
+    # uids, so negative uids show up as the diminished radix complement of
+    # a uint. For example, a uid of -2 is reported as 4294967294
+    def dimished_radix_complement(int)
+      if int > UID_MAX
+        int - UINT
+      else
+        int
+      end
+    end
+  
+    def target_uid
+      return nil if resource.owner.nil?
+      if resource.owner.kind_of?(String)
+        dimished_radix_complement( Etc.getpwnam(resource.owner).uid )
+      elsif resource.owner.kind_of?(Integer)
+        resource.owner
+      else
+        Chef::Log.error("The `owner` parameter of the #@resource resource is set to an invalid value (#{resource.owner.inspect})")
+        raise ArgumentError, "cannot resolve #{resource.owner.inspect} to uid, owner must be a string or integer"
+      end
+    rescue ArgumentError
+      raise Chef::Exceptions::UserIDNotFound, "cannot determine user id for '#{resource.owner}', does the user exist on this system?"
+    end
+  
+    def set_owner
+      if (uid = target_uid) && (uid != stat.uid)
+        Chef::Log.debug("setting owner on #{file} to #{uid}")
+        File.chown(uid, nil, file)
+        modified
+      end
+    end
+  
+    def target_gid
+      return nil if resource.group.nil?
+      if resource.group.kind_of?(String)
+        dimished_radix_complement( Etc.getgrnam(resource.group).gid )
+      elsif resource.group.kind_of?(Integer)
+        resource.group
+      else
+        Chef::Log.error("The `group` parameter of the #@resource resource is set to an invalid value (#{resource.owner.inspect})")
+        raise ArgumentError, "cannot resolve #{resource.group.inspect} to gid, group must be a string or integer"
+      end
+    rescue ArgumentError
+      raise Chef::Exceptions::GroupIDNotFound, "cannot determine group id for '#{resource.group}', does the group exist on this system?"
+    end
+  
+    def set_group
+      if (gid = target_gid) && (gid != stat.gid)
+        Chef::Log.debug("setting group on #{file} to #{gid}")
+        File.chown(nil, gid, file)
+        modified
+      end
+    end
+
+    def target_mode
+      return nil if resource.mode.nil?
+      (resource.mode.respond_to?(:oct) ? resource.mode.oct : resource.mode.to_i) & 007777
+    end
+
+    def set_mode
+      if (mode = target_mode) && (mode != (stat.mode & 007777))
+        Chef::Log.debug("setting mode on #{file} to #{mode.to_s(8)}")
+        File.chmod(target_mode, file)
+        modified
+      end
+    end
+  
+
+    def stat
+      @stat ||= ::File.stat(file)
+    end
+  
+    private
+  
+    def modified
+      @modified = true
+    end
+  
+  end
+end

data/lib/chef/file_cache.rb

@@ -0,0 +1,218 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 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/mixin/params_validate'
+require 'chef/mixin/create_path'
+require 'chef/exceptions'
+require 'chef/json_compat'
+require 'fileutils'
+
+class Chef
+  class FileCache
+    class << self
+      include Chef::Mixin::ParamsValidate
+      include Chef::Mixin::CreatePath
+
+      # Write a file to the File Cache.
+      #
+      # === Parameters
+      # path<String>:: The path to the file you want to put in the cache - should
+      #   be relative to file_cache_path
+      # contents<String>:: A string with the contents you want written to the file
+      #
+      # === Returns
+      # true
+      def store(path, contents)
+        validate(
+          {
+            :path => path,
+            :contents => contents
+          },
+          {
+            :path => { :kind_of => String },
+            :contents => { :kind_of => String },
+          }
+        )
+
+        file_path_array = File.split(path)
+        file_name = file_path_array.pop
+        cache_path = create_cache_path(File.join(file_path_array))
+        File.open(File.join(cache_path, file_name), "w") do |io|
+          io.print(contents)
+        end
+        true
+      end
+
+      # Move a file into the cache.  Useful with the REST raw file output.
+      #
+      # === Parameters
+      # file<String>:: The path to the file you want in the cache
+      # path<String>:: The relative name you want the new file to use
+      def move_to(file, path)
+        validate(
+          {
+            :file => file,
+            :path => path
+          },
+          {
+            :file => { :kind_of => String },
+            :path => { :kind_of => String },
+          }
+        )
+
+        file_path_array = File.split(path)
+        file_name = file_path_array.pop
+        if File.exists?(file) && File.writable?(file)
+          FileUtils.mv(
+            file,
+            File.join(create_cache_path(File.join(file_path_array), true), file_name)
+          )
+        else
+          raise RuntimeError, "Cannot move #{file} to #{path}!"
+        end
+      end
+
+      # Read a file from the File Cache
+      #
+      # === Parameters
+      # path<String>:: The path to the file you want to load - should
+      #   be relative to file_cache_path
+      # read<True/False>:: Whether to return the file contents, or the path.
+      #   Defaults to true.
+      #
+      # === Returns
+      # String:: A string with the file contents, or the path to the file.
+      #
+      # === Raises
+      # Chef::Exceptions::FileNotFound:: If it cannot find the file in the cache
+      def load(path, read=true)
+        validate(
+          {
+            :path => path
+          },
+          {
+            :path => { :kind_of => String }
+          }
+        )
+        cache_path = create_cache_path(path, false)
+        raise Chef::Exceptions::FileNotFound, "Cannot find #{cache_path} for #{path}!" unless File.exists?(cache_path)
+        if read
+          File.read(cache_path)
+        else
+          cache_path
+        end
+      end
+
+      # Delete a file from the File Cache
+      #
+      # === Parameters
+      # path<String>:: The path to the file you want to delete - should
+      #   be relative to file_cache_path
+      #
+      # === Returns
+      # true
+      def delete(path)
+        validate(
+          {
+            :path => path
+          },
+          {
+            :path => { :kind_of => String },
+          }
+        )
+        cache_path = create_cache_path(path, false)
+        if File.exists?(cache_path)
+          File.unlink(cache_path)
+        end
+        true
+      end
+
+      # List all the files in the Cache
+      #
+      # === Returns
+      # Array:: An array of files in the cache, suitable for use with load, delete and store
+      def list
+        find("**#{File::Separator}*")
+      end
+
+      ##
+      # Find files in the cache by +glob_pattern+
+      # === Returns
+      # [String] - An array of file cache keys matching the glob
+      def find(glob_pattern)
+        keys = Array.new
+        Dir[File.join(file_cache_path, glob_pattern)].each do |f|
+          if File.file?(f)
+            keys << f[/^#{Regexp.escape(Dir[file_cache_path].first) + File::Separator}(.+)/, 1]
+          end
+        end
+        keys
+      end
+
+      # Whether or not this file exists in the Cache
+      #
+      # === Parameters
+      # path:: The path to the file you want to check - is relative
+      #   to file_cache_path
+      #
+      # === Returns
+      # True:: If the file exists
+      # False:: If it does not
+      def has_key?(path)
+        validate(
+          {
+            :path => path
+          },
+          {
+            :path => { :kind_of => String },
+          }
+        )
+        full_path = create_cache_path(path, false)
+        if File.exists?(full_path)
+          true
+        else
+          false
+        end
+      end
+
+      # Create a full path to a given file in the cache. By default,
+      # also creates the path if it does not exist.
+      #
+      # === Parameters
+      # path:: The path to create, relative to file_cache_path
+      # create_if_missing:: True by default - whether to create the path if it does not exist
+      #
+      # === Returns
+      # String:: The fully expanded path
+      def create_cache_path(path, create_if_missing=true)
+        cache_dir = File.expand_path(File.join(file_cache_path, path))
+        if create_if_missing
+          create_path(cache_dir)
+        else
+          cache_dir
+        end
+      end
+
+      private
+
+      def file_cache_path
+        Chef::Config[:file_cache_path]
+      end
+
+    end
+  end
+end