mbailey-chef 0.9.12.1

data/lib/chef/data_bag_item.rb

@@ -0,0 +1,228 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Copyright:: Copyright (c) 2009 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/config'
+require 'chef/mixin/params_validate'
+require 'chef/mixin/from_file'
+require 'chef/couchdb'
+require 'chef/index_queue'
+require 'chef/data_bag'
+require 'extlib'
+require 'json'
+
+class Chef
+  class DataBagItem
+    
+    include Chef::Mixin::FromFile
+    include Chef::Mixin::ParamsValidate
+    include Chef::IndexQueue::Indexable
+    
+    DESIGN_DOCUMENT = {
+      "version" => 1,
+      "language" => "javascript",
+      "views" => {
+        "all" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "data_bag_item") {
+              emit(doc.name, doc);
+            }
+          }
+          EOJS
+        },
+        "all_id" => {
+          "map" => <<-EOJS
+          function(doc) { 
+            if (doc.chef_type == "data_bag_item") {
+              emit(doc.name, doc.name);
+            }
+          }
+          EOJS
+        }
+      }
+    }
+
+    attr_accessor :couchdb_rev, :couchdb_id, :couchdb
+    attr_reader :raw_data
+    
+    # Create a new Chef::DataBagItem
+    def initialize(couchdb=nil)
+      @couchdb_rev = nil
+      @couchdb_id = nil
+      @data_bag = nil
+      @raw_data = Mash.new
+      @couchdb = couchdb || Chef::CouchDB.new
+    end
+
+    def chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])      
+    end
+
+    def self.chef_server_rest
+      Chef::REST.new(Chef::Config[:chef_server_url])      
+    end
+
+    def raw_data
+      @raw_data
+    end
+
+    def raw_data=(new_data)
+      raise Exceptions::ValidationFailed, "Data Bag Items must contain a Hash or Mash!" unless new_data.kind_of?(Hash) || new_data.kind_of?(Mash)
+      raise Exceptions::ValidationFailed, "Data Bag Items must have an id key in the hash! #{new_data.inspect}" unless new_data.has_key?("id")
+      raise Exceptions::ValidationFailed, "Data Bag Item id does not match alphanumeric/-/_!" unless new_data["id"] =~ /^[\-[:alnum:]_]+$/
+      @raw_data = new_data
+    end
+
+    def data_bag(arg=nil) 
+      set_or_return(
+        :data_bag,
+        arg,
+        :regex => /^[\-[:alnum:]_]+$/
+      )
+    end
+
+    def name
+      object_name
+    end
+
+    def object_name
+      raise Exceptions::ValidationFailed, "You must have an 'id' or :id key in the raw data" unless raw_data.has_key?('id')
+      raise Exceptions::ValidationFailed, "You must have declared what bag this item belongs to!" unless data_bag
+      
+      id = raw_data['id']
+      "data_bag_item_#{data_bag}_#{id}"
+    end
+
+    def self.object_name(data_bag_name, id)
+      "data_bag_item_#{data_bag_name}_#{id}"
+    end
+
+    def to_hash
+      result = self.raw_data
+      result["chef_type"] = "data_bag_item"
+      result["data_bag"] = self.data_bag
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result
+    end
+
+    # Serialize this object as a hash 
+    def to_json(*a)
+      result = {
+        "name" => self.object_name,
+        "json_class" => self.class.name,
+        "chef_type" => "data_bag_item",
+        "data_bag" => self.data_bag,
+        "raw_data" => self.raw_data
+      }
+      result["_rev"] = @couchdb_rev if @couchdb_rev
+      result.to_json(*a)
+    end
+    
+    # Create a Chef::DataBagItem from JSON
+    def self.json_create(o)
+      bag_item = new
+      bag_item.data_bag(o["data_bag"])
+      o.delete("data_bag")
+      o.delete("chef_type")
+      o.delete("json_class")
+      o.delete("name")
+      if o.has_key?("_rev")
+        bag_item.couchdb_rev = o["_rev"] 
+        o.delete("_rev")
+      end
+      if o.has_key?("_id")
+        bag_item.couchdb_id = o["_id"]
+        bag_item.index_id = bag_item.couchdb_id
+        o.delete("_id")
+      end
+      bag_item.raw_data = Mash.new(o["raw_data"])
+      bag_item
+    end
+
+    # The Data Bag Item behaves like a hash - we pass all that stuff along to @raw_data.
+    def method_missing(method_symbol, *args, &block) 
+      self.raw_data.send(method_symbol, *args, &block)
+    end
+    
+    # Load a Data Bag Item by name from CouchDB
+    def self.cdb_load(data_bag, name, couchdb=nil)
+      (couchdb || Chef::CouchDB.new).load("data_bag_item", object_name(data_bag, name))
+    end
+    
+    # Load a Data Bag Item by name via RESTful API
+    def self.load(data_bag, name)
+      Chef::REST.new(Chef::Config[:chef_server_url]).get_rest("data/#{data_bag}/#{name}")
+    end
+    
+    # Remove this Data Bag Item from CouchDB
+    def cdb_destroy
+      Chef::Log.debug "destroying data bag item: #{self.inspect}"
+      @couchdb.delete("data_bag_item", object_name, @couchdb_rev)
+    end
+    
+    def destroy(data_bag=data_bag, databag_item=name)
+      chef_server_rest.delete_rest("data/#{data_bag}/#{databag_item}")
+    end
+     
+    # Save this Data Bag Item to CouchDB
+    def cdb_save
+      @couchdb_rev = @couchdb.store("data_bag_item", object_name, self)["rev"]
+    end
+    
+    # Save this Data Bag Item via RESTful API
+    def save(item_id=@raw_data['id'])
+      r = chef_server_rest
+      begin
+        r.put_rest("data/#{data_bag}/#{item_id}", @raw_data)
+      rescue Net::HTTPServerException => e
+        raise e unless e.response.code == "404"
+        r.post_rest("data/#{data_bag}", @raw_data) 
+      end
+      self
+    end
+    
+    # Create this Data Bag Item via RESTful API
+    def create
+      chef_server_rest.post_rest("data/#{data_bag}", @raw_data) 
+      self
+    end 
+    
+    # Set up our CouchDB design document
+    def self.create_design_document(couchdb=nil)
+      (couchdb || Chef::CouchDB.new).create_design_document("data_bag_items", DESIGN_DOCUMENT)
+    end
+    
+    # As a string
+    def to_s
+      "data_bag_item[#{id}]"
+    end
+
+    def pretty_print(pretty_printer)
+      pretty_printer.pp({"data_bag_item('#{data_bag}', '#{id}')" => self.to_hash})
+    end
+
+    def id
+      @raw_data['id']
+    end
+
+  end
+end
+
+

data/lib/chef/exceptions.rb

@@ -0,0 +1,66 @@
+#
+# 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.
+
+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 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
+    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
+  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 << 31)
+  
+    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 'json'
+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