cifrado 0.1

data/vendor/fog/lib/fog/core/collection.rb

@@ -0,0 +1,145 @@
+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].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
+
+    remove_method :clear
+    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
+
+
+    remove_method :inspect
+    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
+end

data/vendor/fog/lib/fog/core/connection.rb

@@ -0,0 +1,36 @@
+module Fog
+  class Connection
+
+    def initialize(url, persistent=false, params={})
+      Excon.defaults[:headers]['User-Agent'] ||= "fog/#{Fog::VERSION}"
+      @excon = Excon.new(url, params)
+      @persistent = persistent
+    end
+
+    def request(params, &block)
+      unless @persistent
+        reset
+      end
+      unless block_given?
+        if (parser = params.delete(:parser))
+          body = Nokogiri::XML::SAX::PushParser.new(parser)
+          params[:response_block] = lambda { |chunk, remaining, total| body << chunk }
+        end
+      end
+
+      response = @excon.request(params, &block)
+
+      if parser
+        body.finish
+        response.body = parser.response
+      end
+
+      response
+    end
+
+    def reset
+      @excon.reset
+    end
+
+  end
+end

data/vendor/fog/lib/fog/core/credentials.rb

@@ -0,0 +1,65 @@
+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_credentials(args)
+    if args.is_a? Hash
+      copy = Array.new
+      args.each do |key, value|
+        copy.push(key.to_sym, self.symbolize_credentials(value))
+      end
+      Hash[*copy]
+    else
+      args
+    end
+  end
+
+end

data/vendor/fog/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/vendor/fog/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/vendor/fog/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/vendor/fog/lib/fog/core/errors.rb

@@ -0,0 +1,108 @@
+module Fog
+  module Errors
+
+    class Error < StandardError
+      attr_accessor :verbose
+
+      def self.slurp(error, message = nil)
+        new_error = new(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_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:
+  :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:
+#
+# End of Fog Credentials File
+#######################################################
+
+    YML
+      raise(Fog::Errors::LoadError.new(missing_credentials_message))
+    end
+
+  end
+end