fog-core 1.21.0

data/lib/fog/core/class_from_string.rb

@@ -0,0 +1,26 @@
+module Fog
+   # get class by string or nil
+   def self.class_from_string classname, defaultpath=""
+     if classname and classname.is_a? String then
+        chain = classname.split("::")
+        klass = Kernel
+        chain.each do |klass_string|
+           klass = klass.const_get klass_string
+        end
+        if klass.is_a? Class then
+           klass
+        elsif defaultpath != nil then
+           Fog.class_from_string((defaultpath.split("::")+chain).join("::"), nil)
+        else
+           nil
+        end
+     elsif classname and classname.is_a? Class then
+        classname
+     else
+        nil
+     end
+   rescue NameError
+     defaultpath != nil ? Fog.class_from_string((defaultpath.split("::")+chain).join("::"), nil) : nil
+   end
+end
+

data/lib/fog/core/collection.rb

@@ -0,0 +1,161 @@
+require "fog/core/deprecated_connection_accessors"
+
+module Fog
+  class Collection < Array
+    extend Fog::Attributes::ClassMethods
+    include Fog::Attributes::InstanceMethods
+    include Fog::Core::DeprecatedConnectionAccessors
+
+    attr_reader :service
+
+    Array.public_instance_methods(false).each do |method|
+      unless [:reject, :select, :slice, :clear, :inspect].include?(method.to_sym)
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{method}(*args)
+            unless @loaded
+              lazy_load
+            end
+            super
+          end
+        EOS
+      end
+    end
+
+    %w[reject select slice].each do |method|
+      class_eval <<-EOS, __FILE__, __LINE__
+        def #{method}(*args)
+          unless @loaded
+            lazy_load
+          end
+          data = super
+          self.clone.clear.concat(data)
+        end
+      EOS
+    end
+
+    def self.model(new_model=nil)
+      if new_model == nil
+        @model
+      else
+        @model = new_model
+      end
+    end
+
+    def clear
+      @loaded = true
+      super
+    end
+
+    def create(attributes = {})
+      object = new(attributes)
+      object.save
+      object
+    end
+
+    def destroy(identity)
+      object = new(:identity => identity)
+      object.destroy
+    end
+
+    # Creates a new Fog::Collection based around the passed service
+    #
+    # @param [Hash] attributes
+    # @option attributes [Fog::Service] service Instance of a service
+    #
+    # @return [Fog::Collection]
+    #
+    def initialize(attributes = {})
+      @service = attributes.delete(:service)
+      @loaded = false
+      merge_attributes(attributes)
+    end
+
+
+    def inspect
+      Thread.current[:formatador] ||= Formatador.new
+      data = "#{Thread.current[:formatador].indentation}<#{self.class.name}\n"
+      Thread.current[:formatador].indent do
+        unless self.class.attributes.empty?
+          data << "#{Thread.current[:formatador].indentation}"
+          data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
+          data << "\n"
+        end
+        data << "#{Thread.current[:formatador].indentation}["
+        unless self.empty?
+          data << "\n"
+          Thread.current[:formatador].indent do
+            data << self.map {|member| member.inspect}.join(",\n")
+            data << "\n"
+          end
+          data << Thread.current[:formatador].indentation
+        end
+        data << "]\n"
+      end
+      data << "#{Thread.current[:formatador].indentation}>"
+      data
+    end
+
+    def load(objects)
+      clear
+      for object in objects
+        self << new(object)
+      end
+      self
+    end
+
+    def model
+      self.class.instance_variable_get('@model')
+    end
+
+    def new(attributes = {})
+      unless attributes.is_a?(::Hash)
+        raise(ArgumentError.new("Initialization parameters must be an attributes hash, got #{attributes.class} #{attributes.inspect}"))
+      end
+      model.new(
+        {
+          :collection => self,
+          :service => service
+        }.merge(attributes)
+      )
+    end
+
+    def reload
+      clear
+      lazy_load
+      self
+    end
+
+    def table(attributes = nil)
+      Formatador.display_table(self.map {|instance| instance.attributes}, attributes)
+    end
+
+    def to_json(options = {})
+      Fog::JSON.encode(self.map {|member| member.attributes})
+    end
+
+    private
+
+    def lazy_load
+      self.all
+    end
+
+  end
+
+  # Base class for collection classes whose 'all' method returns only a single page of results and passes the
+  # 'Marker' option along as self.filters[:marker]
+  class PagedCollection < Collection
+
+    def each(filters=filters)
+      if block_given?
+        begin
+          page = self.all(filters)
+          # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
+          base_each = Fog::Collection.instance_method(:each)
+          base_each.bind(page).call { |item| yield item }
+        end while self.filters[:marker]
+      end
+      self
+    end
+
+  end
+end

data/lib/fog/core/connection.rb

@@ -0,0 +1,72 @@
+module Fog
+  module Core
+
+    # Fog::Core::Connection is a generic class to contain a HTTP link to an API.
+    #
+    # It is intended to be subclassed by providers who can then add their own
+    # modifications such as authentication or response object.
+    #
+    class Connection
+      # Prepares the connection and sets defaults for any future requests.
+      #
+      # @param [String] url The destination URL
+      # @param persistent [Boolean]
+      # @param [Hash] params
+      # @option params [String] :body Default text to be sent over a socket. Only used if :body absent in Connection#request params
+      # @option params [Hash<Symbol, String>] :headers The default headers to supply in a request. Only used if params[:headers] is not supplied to Connection#request
+      # @option params [String] :host The destination host's reachable DNS name or IP, in the form of a String
+      # @option params [String] :path Default path; appears after 'scheme://host:port/'. Only used if params[:path] is not supplied to Connection#request
+      # @option params [Fixnum] :port The port on which to connect, to the destination host
+      # @option params [Hash]   :query Default query; appended to the 'scheme://host:port/path/' in the form of '?key=value'. Will only be used if params[:query] is not supplied to Connection#request
+      # @option params [String] :scheme The protocol; 'https' causes OpenSSL to be used
+      # @option params [String] :proxy Proxy server; e.g. 'http://myproxy.com:8888'
+      # @option params [Fixnum] :retry_limit Set how many times we'll retry a failed request.  (Default 4)
+      # @option params [Class] :instrumentor Responds to #instrument as in ActiveSupport::Notifications
+      # @option params [String] :instrumentor_name Name prefix for #instrument events.  Defaults to 'excon'
+      #
+      def initialize(url, persistent=false, params={})
+        unless params.has_key?(:debug_response)
+          params[:debug_response] = true
+        end
+        params[:headers] ||= {}
+        params[:headers]['User-Agent'] ||= "fog/#{Fog::VERSION}"
+        params.merge!(:persistent => params.fetch(:persistent, persistent))
+        @excon = Excon.new(url, params)
+      end
+
+      # Makes a request using the connection using Excon
+      #
+      # @param [Hash] params
+      # @option params [String] :body text to be sent over a socket
+      # @option params [Hash<Symbol, String>] :headers The default headers to supply in a request
+      # @option params [String] :host The destination host's reachable DNS name or IP, in the form of a String
+      # @option params [String] :path appears after 'scheme://host:port/'
+      # @option params [Fixnum] :port The port on which to connect, to the destination host
+      # @option params [Hash]   :query appended to the 'scheme://host:port/path/' in the form of '?key=value'
+      # @option params [String] :scheme The protocol; 'https' causes OpenSSL to be used
+      # @option params [Proc] :response_block
+      #
+      # @return [Excon::Response]
+      #
+      # @raise [Excon::Errors::StubNotFound]
+      # @raise [Excon::Errors::Timeout]
+      # @raise [Excon::Errors::SocketError]
+      #
+      def request(params, &block)
+        @excon.request(params, &block)
+      end
+
+      # Make {#request} available even when it has been overidden by a subclass
+      # to allow backwards compatibility.
+      #
+      alias_method :original_request, :request
+      protected :original_request
+
+      # Closes the connection
+      #
+      def reset
+        @excon.reset
+      end
+    end
+  end
+end

data/lib/fog/core/credentials.rb

@@ -0,0 +1,70 @@
+require 'yaml'
+
+module Fog
+  require 'fog/core/deprecation'
+
+  # Assign a new credential to use from configuration file
+  #   @param [String, Symbol] new_credential name of new credential to use
+  #   @ return [Symbol] name of the new credential
+  def self.credential=(new_credential)
+    @credentials = nil
+    @credential = new_credential && new_credential.to_sym
+  end
+
+  # @return [String, Symbol] The credential to use in Fog
+  def self.credential
+    @credential ||= ( ENV["FOG_CREDENTIAL"] && ENV["FOG_CREDENTIAL"].to_sym ) || :default
+  end
+
+  # @return [String] The path for configuration_file
+  def self.credentials_path
+    @credential_path ||= begin
+      path = ENV["FOG_RC"] || (ENV['HOME'] && File.directory?(ENV['HOME']) && '~/.fog')
+      File.expand_path(path) if path
+    rescue
+      nil
+    end
+  end
+
+  # @return [String] The new path for credentials file
+  def self.credentials_path=(new_credentials_path)
+    @credentials = nil
+    @credential_path = new_credentials_path
+  end
+
+  # @return [Hash] The credentials pulled from the configuration file
+  # @raise [LoadError] Configuration unavailable in configuration file
+  def self.credentials
+    @credentials  ||= begin
+      if credentials_path && File.exists?(credentials_path)
+        credentials = self.symbolize_credentials(YAML.load_file(credentials_path))
+        (credentials && credentials[credential]) || Fog::Errors.missing_credentials
+      else
+        {}
+      end
+    end
+  end
+
+  # @return [Hash] The newly assigned credentials
+  def self.credentials=(new_credentials)
+    @credentials = new_credentials
+  end
+
+  def self.symbolize_credential?(key)
+    ![:headers].include?(key)
+  end
+
+  def self.symbolize_credentials(args)
+    if args.is_a? Hash
+      copy = Array.new
+      args.each do |key, value|
+        obj = symbolize_credential?(key) ? self.symbolize_credentials(value) : value
+        copy.push(key.to_sym, obj)
+      end
+      Hash[*copy]
+    else
+      args
+    end
+  end
+
+end

data/lib/fog/core/current_machine.rb

@@ -0,0 +1,34 @@
+require 'thread'
+module Fog
+  class CurrentMachine
+    @@lock = Mutex.new
+    AMAZON_AWS_CHECK_IP = 'http://checkip.amazonaws.com'
+
+    def self.ip_address= ip_address
+      @@lock.synchronize do
+        @@ip_address = ip_address
+      end
+    end
+
+    # Get the ip address of the machine from which this command is run. It is
+    # recommended that you surround calls to this function with a timeout block
+    # to ensure optimum performance in the case where the amazonaws checkip
+    # service is unavailable.
+    #
+    # @example Get the current ip address
+    #   begin
+    #     Timeout::timeout(5) do
+    #       puts "Your ip address is #{Fog::CurrentMachine.ip_address}"
+    #     end
+    #   rescue Timeout::Error
+    #     puts "Service timeout"
+    #   end
+    #
+    # @raise [Excon::Errors::Error] if the net/http request fails.
+    def self.ip_address
+      @@lock.synchronize do
+        @@ip_address ||= Excon.get(AMAZON_AWS_CHECK_IP).body.chomp
+      end
+    end
+  end
+end

data/lib/fog/core/deprecated_connection_accessors.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Core
+    # This module covers the shared code used by models and collections
+    # that deprecates the confusing usage of 'connection' which was
+    # actually intended to be an instance of Fog::Service
+    module DeprecatedConnectionAccessors
+      # Sets the Service but using the wrong name!
+      #
+      # @deprecated The connection name was wrong and confusing since it refered to the service
+      # @param [Fog::Service] service An instance of a Fog service this collection is for
+      #
+      def connection=(service)
+        Fog::Logger.deprecation("#connection= is deprecated, pass :service in at creation [light_black](#{caller.first})[/]")
+        @service = service
+      end
+
+      # Returns the Service the collection is part of
+      #
+      # @deprecated #connection is deprecated due to confusing name, use #service instead
+      # @return [Fog::Service]
+      #
+      def connection
+        Fog::Logger.deprecation("#connection is deprecated, use #service instead [light_black](#{caller.first})[/]")
+        @service
+      end
+
+      # Prepares the value of the service based on the passed attributes
+      #
+      # @note Intended for use where the service is required before the normal
+      #   initializer runs. The logic is run there with deprecation warnings.
+      #
+      # @param [Hash] attributes
+      # @return [Fog::Service]
+      #
+      def prepare_service_value(attributes)
+        @service = attributes[:service] || attributes[:connection]
+      end
+
+    end
+  end
+end

data/lib/fog/core/deprecation.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Deprecation
+
+    def deprecate(older, newer)
+      module_eval <<-EOS, __FILE__, __LINE__
+        def #{older}(*args)
+          Fog::Logger.deprecation("#{self} => ##{older} is deprecated, use ##{newer} instead [light_black](#{caller.first})[/]")
+          send(:#{newer}, *args)
+        end
+      EOS
+    end
+
+    def self_deprecate(older, newer)
+      module_eval <<-EOS, __FILE__, __LINE__
+        def self.#{older}(*args)
+          Fog::Logger.deprecation("#{self} => ##{older} is deprecated, use ##{newer} instead [light_black](#{caller.first})[/]")
+          send(:#{newer}, *args)
+        end
+      EOS
+    end
+
+  end
+end

data/lib/fog/core/errors.rb

@@ -0,0 +1,118 @@
+module Fog
+  module Errors
+
+    class Error < StandardError
+      attr_accessor :verbose
+
+      def self.slurp(error, message = nil)
+        new_error = new(message || error.message)
+        new_error.set_backtrace(error.backtrace)
+        new_error.verbose = error.message
+        new_error
+      end
+    end
+
+    class MockNotImplemented < Fog::Errors::Error; end
+
+    class NotFound < Fog::Errors::Error; end
+
+    class LoadError < LoadError; end
+
+    class TimeoutError< Fog::Errors::Error; end
+
+    class NotImplemented < Fog::Errors::Error; end
+
+    # @return [String] The error message that will be raised, if credentials cannot be found
+    def self.missing_credentials
+      missing_credentials_message = <<-YML
+Missing Credentials
+
+To run as '#{Fog.credential}', add the following to your resource config file: #{Fog.credentials_path}
+An alternate file may be used by placing its path in the FOG_RC environment variable
+
+#######################################################
+# Fog Credentials File
+#
+# Key-value pairs should look like:
+# :aws_access_key_id:                 022QF06E7MXBSAMPLE
+:#{Fog.credential}:
+  :aws_access_key_id:
+  :aws_secret_access_key:
+  :bluebox_api_key:
+  :bluebox_customer_id:
+  :brightbox_client_id:
+  :brightbox_secret:
+  :clodo_api_key:
+  :clodo_username:
+  :go_grid_api_key:
+  :go_grid_shared_secret:
+  :google_client_email:
+  :google_key_location:
+  :google_project:
+  :google_storage_access_key_id:
+  :google_storage_secret_access_key:
+  :hp_access_key:
+  :hp_secret_key:
+  :hp_tenant_id:
+  :hp_avl_zone:
+  :linode_api_key:
+  :local_root:
+  :bare_metal_cloud_password:
+  :bare_metal_cloud_username:
+  :public_key_path:
+  :private_key_path:
+  :openstack_api_key:
+  :openstack_username:
+  :openstack_auth_url:
+  :openstack_tenant:
+  :openstack_region:
+  :ovirt_username:
+  :ovirt_password:
+  :ovirt_url:
+  :libvirt_uri:
+  :rackspace_api_key:
+  :rackspace_username:
+  :rackspace_servicenet:
+  :rackspace_cdn_ssl:
+  :rage4_email:
+  :rage4_password:
+  :riakcs_access_key_id:
+  :riakcs_secret_access_key:
+  :stormondemand_username:
+  :stormondemand_password:
+  :terremark_username:
+  :terremark_password:
+  :voxel_api_key:
+  :voxel_api_secret:
+  :zerigo_email:
+  :zerigo_token:
+  :dnsimple_email:
+  :dnsimple_password:
+  :dnsmadeeasy_api_key:
+  :dnsmadeeasy_secret_key:
+  :dreamhost_api_key:
+  :cloudstack_host:
+  :cloudstack_api_key:
+  :cloudstack_secret_access_key:
+  :vsphere_server:
+  :vsphere_username:
+  :vsphere_password:
+  :libvirt_username:
+  :libvirt_password:
+  :libvirt_uri:
+  :libvirt_ip_command:
+  :ibm_username:
+  :ibm_password:
+  :vcloud_director_host:
+  :vcloud_director_username:
+  :vcloud_director_password:
+#
+# End of Fog Credentials File
+#######################################################
+
+    YML
+      raise(Fog::Errors::LoadError.new(missing_credentials_message))
+    end
+
+  end
+end