cifrado 0.1

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

@@ -0,0 +1,48 @@
+module Fog
+  class HMAC
+
+    def initialize(type, key)
+      @key = key
+      case type
+      when 'sha1'
+        setup_sha1
+      when 'sha256'
+        setup_sha256
+      end
+    end
+
+    def sign(data)
+      @signer.call(data)
+    end
+
+    private
+
+    def setup_sha1
+      @digest = OpenSSL::Digest::Digest.new('sha1')
+      @signer = lambda do |data|
+        OpenSSL::HMAC.digest(@digest, @key, data)
+      end
+    end
+
+    def setup_sha256
+      begin
+        @digest = OpenSSL::Digest::Digest.new('sha256')
+        @signer = lambda do |data|
+          OpenSSL::HMAC.digest(@digest, @key, data)
+        end
+      rescue RuntimeError => error
+        unless error.message == 'Unsupported digest algorithm (sha256).'
+          raise error
+        else
+          require 'hmac-sha2'
+          @hmac = ::HMAC::SHA256.new(@key)
+          @signer = lambda do |data|
+            @hmac.update(data)
+            @hmac.digest
+          end
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'multi_json'
+
+module Fog
+  module JSON
+
+    def self.sanitize(data)
+      case data
+      when Array
+        data.map {|datum| sanitize(datum)}
+      when Hash
+        for key, value in data
+          data[key] = sanitize(value)
+        end
+      when ::Time
+        data.strftime("%Y-%m-%dT%H:%M:%SZ")
+      else
+        data
+      end
+    end
+
+    # Do the MultiJson introspection at this level so we can define our encode/decode methods and perform
+    # the introspection only once rather than once per call.
+
+    def self.encode(obj)
+      MultiJson.encode(obj)
+    end
+
+    def self.decode(obj)
+      MultiJson.decode(obj)
+    end
+
+
+  end
+end

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

@@ -0,0 +1,45 @@
+module Fog
+  class Logger
+
+    @channels = {
+      :deprecation  => ::STDOUT,
+      :warning      => ::STDOUT
+    }
+    
+    @channels[:debug] = ::STDOUT if ENV['DEBUG']
+
+    def self.[](channel)
+      @channels[channel]
+    end
+
+    def self.[]=(channel, value)
+      @channels[channel] = value
+    end
+
+    def self.debug(message)
+      self.write(:debug, "[light_black][DEBUG] #{message}[/]\n")
+    end
+
+    def self.deprecation(message)
+      self.write(:deprecation, "[yellow][DEPRECATION] #{message}[/]\n")
+    end
+
+    def self.warning(message)
+      self.write(:warning, "[yellow][WARNING] #{message}[/]\n")
+    end
+
+    def self.write(key, value)
+      if channel = @channels[key]
+        value.gsub(Formatador::INDENT_REGEX, '')
+        message = if channel.tty?
+          value.gsub(Formatador::PARSE_REGEX) { "\e[#{Formatador::STYLES[$1.to_sym]}m" }.gsub(Formatador::INDENT_REGEX, '')
+        else
+          value.gsub(Formatador::PARSE_REGEX, '').gsub(Formatador::INDENT_REGEX, '')
+        end
+        channel.write(message)
+      end
+      nil
+    end
+
+  end
+end

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

@@ -0,0 +1,92 @@
+module Fog
+
+  @mocking = false
+
+  def self.mock!
+    @mocking = true
+  end
+
+  def self.unmock!
+    @mocking = false
+  end
+
+  def self.mock?
+    @mocking
+  end
+
+  def self.mocking?
+    @mocking
+  end
+
+  module Mock
+
+    @delay = 1
+    def self.delay
+      @delay
+    end
+
+    def self.delay=(new_delay)
+      raise ArgumentError, "delay must be non-negative" unless new_delay >= 0
+      @delay = new_delay
+    end
+
+    def self.not_implemented
+      raise Fog::Errors::MockNotImplemented.new("Contributions welcome!")
+    end
+
+    def self.random_base64(length)
+      random_selection(
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+        length
+      )
+    end
+
+    def self.random_hex(length)
+      max = ('f' * length).to_i(16)
+      rand(max).to_s(16).rjust(length, '0')
+    end
+
+    def self.random_letters(length)
+      random_selection(
+        'abcdefghijklmnopqrstuvwxyz',
+        length
+      )
+    end
+
+    def self.random_numbers(length)
+      max = ('9' * length).to_i
+      rand(max).to_s
+    end
+
+    def self.random_selection(characters, length)
+      selection = ''
+      length.times do
+        position = rand(characters.length)
+        selection << characters[position..position]
+      end
+      selection
+    end
+
+    def self.reset
+      mocked_services = []
+      Fog.constants.map do |x|
+        x_const = Fog.const_get(x)
+        x_const.respond_to?(:constants) && x_const.constants.map do |y|
+          y_const = x_const.const_get(y)
+          y_const.respond_to?(:constants) && y_const.constants.map do |z|
+            if z.to_sym == :Mock
+              mocked_services << y_const.const_get(z)
+            end
+          end
+        end
+      end
+
+      for mocked_service in mocked_services
+        next unless mocked_service.respond_to?(:reset)
+        mocked_service.reset
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,79 @@
+require "fog/core/deprecated_connection_accessors"
+
+module Fog
+  class Model
+
+    extend Fog::Attributes::ClassMethods
+    include Fog::Attributes::InstanceMethods
+    include Fog::Core::DeprecatedConnectionAccessors
+
+    attr_accessor :collection
+    attr_reader :service
+
+    def initialize(new_attributes = {})
+      # TODO Remove compatibility with old connection option
+      @service = new_attributes.delete(:service)
+      if @service.nil? && new_attributes[:connection]
+        Fog::Logger.deprecation("Passing :connection option is deprecated, use :service instead [light_black](#{caller.first})[/]")
+        @service = new_attributes[:connection]
+      end
+      merge_attributes(new_attributes)
+    end
+
+    def inspect
+      Thread.current[:formatador] ||= Formatador.new
+      data = "#{Thread.current[:formatador].indentation}<#{self.class.name}"
+      Thread.current[:formatador].indent do
+        unless self.class.attributes.empty?
+          data << "\n#{Thread.current[:formatador].indentation}"
+          data << self.class.attributes.map {|attribute| "#{attribute}=#{send(attribute).inspect}"}.join(",\n#{Thread.current[:formatador].indentation}")
+        end
+      end
+      data << "\n#{Thread.current[:formatador].indentation}>"
+      data
+    end
+
+    def reload
+      requires :identity
+
+      return unless data = begin
+        collection.get(identity)
+      rescue Excon::Errors::SocketError
+        nil
+      end
+
+      new_attributes = data.attributes
+      merge_attributes(new_attributes)
+      self
+    end
+
+    def to_json(options = {})
+      Fog::JSON.encode(attributes)
+    end
+
+    def symbolize_keys(hash)
+      return nil if hash.nil?
+      hash.inject({}) do |options, (key, value)|
+        options[(key.to_sym rescue key) || key] = value
+        options
+      end
+    end
+
+    def wait_for(timeout=Fog.timeout, interval=1, &block)
+      reload
+      retries = 3
+      Fog.wait_for(timeout, interval) do
+        if reload
+          retries = 3
+        elsif retries > 0
+          retries -= 1
+          sleep(1)
+        elsif retries == 0
+          raise Fog::Errors::Error.new("Reload failed, #{self.class} #{self.identity} went away.")
+        end
+        instance_eval(&block)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'nokogiri'
+
+module Fog
+  module Parsers
+    class Base < Nokogiri::XML::SAX::Document
+
+      attr_reader :response
+
+      def initialize
+        reset
+      end
+
+      def attr_value(name, attrs)
+        (entry = attrs.detect {|a, v| a == name }) && entry.last
+      end
+
+      def reset
+        @response = {}
+      end
+
+      def characters(string)
+        @value ||= ''
+        @value << string
+      end
+
+      # ###############################################################################
+      # This is a workaround. Original implementation from Nokogiri is overwritten with
+      # one that does not join namespace prefix with local name.
+      def start_element_namespace name, attrs = [], prefix = nil, uri = nil, ns = []
+        start_element name, attrs
+      end
+
+      def end_element_namespace name, prefix = nil, uri = nil
+        end_element name
+      end
+
+      # ###############################################################################
+
+      def start_element(name, attrs = [])
+        @value = nil
+      end
+
+      def value
+        @value && @value.dup
+      end
+
+    end
+  end
+end
+
+module Fog
+  class ToHashDocument < Nokogiri::XML::SAX::Document
+
+    def initialize
+      @stack = []
+    end
+
+    def characters(string)
+      @value ||= ''
+      @value << string.strip
+    end
+
+    def end_element(name)
+      last = @stack.pop
+      if last.empty? && @value.empty?
+        @stack.last[name.to_sym] = ''
+      elsif last == {:i_nil=>"true"}
+        @stack.last[name.to_sym] = nil
+      elsif !@value.empty?
+        @stack.last[name.to_sym] = @value
+      end
+      @value = ''
+    end
+
+    def body
+      @stack.first
+    end
+
+    def response
+      body
+    end
+
+    def start_element(name, attributes = [])
+      @value = ''
+      parsed_attributes = {}
+      until attributes.empty?
+        if attributes.first.is_a?(Array)
+          key, value = attributes.shift
+        else
+          key, value = attributes.shift, attributes.shift
+        end
+        parsed_attributes[key.gsub(':','_').to_sym] = value
+      end
+      if @stack.last.is_a?(Array)
+        @stack.last << {name.to_sym => parsed_attributes}
+      else
+        data = if @stack.empty?
+          @stack.push(parsed_attributes)
+          parsed_attributes
+        elsif @stack.last[name.to_sym]
+          unless @stack.last[name.to_sym].is_a?(Array)
+            @stack.last[name.to_sym] = [@stack.last[name.to_sym]]
+          end
+          @stack.last[name.to_sym] << parsed_attributes
+          @stack.last[name.to_sym].last
+        else
+          @stack.last[name.to_sym] = {}
+          @stack.last[name.to_sym].merge!(parsed_attributes)
+          @stack.last[name.to_sym]
+        end
+        @stack.push(data)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,35 @@
+module Fog
+
+  def self.providers
+    @providers ||= {}
+  end
+
+  def self.providers=(new_providers)
+    @providers = new_providers
+  end
+
+  module Provider
+
+    def self.extended(base)
+      provider = base.to_s.split('::').last
+      Fog.providers[provider.downcase.to_sym] = provider
+    end
+
+    def [](service_key)
+      eval(@services_registry[service_key]).new
+    end
+
+    def service(new_service, path, constant_string)
+      Fog.services[new_service] ||= []
+      Fog.services[new_service] |= [self.to_s.split('::').last.downcase.to_sym]
+      @services_registry ||= {}
+      @services_registry[new_service] = [self.to_s, constant_string].join('::')
+      require File.join('fog', path)
+    end
+
+    def services
+      @services_registry.keys
+    end
+
+  end
+end