cifrado 0.1

data/vendor/fog/lib/fog/openstack/volume.rb

@@ -0,0 +1,219 @@
+require 'fog/openstack'
+
+module Fog
+  module Volume
+    class OpenStack < Fog::Service
+
+      requires :openstack_auth_url
+      recognizes :openstack_auth_token, :openstack_management_url, :persistent,
+                 :openstack_service_type, :openstack_service_name, :openstack_tenant,
+                 :openstack_api_key, :openstack_username,
+                 :current_user, :current_tenant,
+                 :openstack_endpoint_type
+
+      model_path 'fog/openstack/models/volume'
+
+      model       :volume
+      collection  :volumes
+
+
+      request_path 'fog/openstack/requests/volume'
+
+       # Volume
+      request :list_volumes
+      request :create_volume
+      request :get_volume_details
+      request :delete_volume
+
+      request :create_volume_snapshot
+      request :list_snapshots
+      request :get_snapshot_details
+      request :delete_snapshot
+
+      request :set_tenant
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :users => {},
+              :tenants => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          require 'multi_json'
+          @openstack_username = options[:openstack_username]
+          @openstack_tenant   = options[:openstack_tenant]
+          @openstack_auth_uri = URI.parse(options[:openstack_auth_url])
+
+          @auth_token = Fog::Mock.random_base64(64)
+          @auth_token_expiration = (Time.now.utc + 86400).iso8601
+
+          management_url = URI.parse(options[:openstack_auth_url])
+          management_url.port = 8776
+          management_url.path = '/v1'
+          @openstack_management_url = management_url.to_s
+
+          @data ||= { :users => {} }
+          unless @data[:users].find {|u| u['name'] == options[:openstack_username]}
+            id = Fog::Mock.random_numbers(6).to_s
+            @data[:users][id] = {
+              'id'       => id,
+              'name'     => options[:openstack_username],
+              'email'    => "#{options[:openstack_username]}@mock.com",
+              'tenantId' => Fog::Mock.random_numbers(6).to_s,
+              'enabled'  => true
+            }
+          end
+        end
+
+        def data
+          self.class.data[@openstack_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@openstack_username)
+        end
+
+        def credentials
+          { :provider                 => 'openstack',
+            :openstack_auth_url       => @openstack_auth_uri.to_s,
+            :openstack_auth_token     => @auth_token,
+            :openstack_management_url => @openstack_management_url }
+        end
+      end
+
+      class Real
+        attr_reader :current_user
+        attr_reader :current_tenant
+
+        def initialize(options={})
+          require 'multi_json'
+
+          @openstack_auth_token = options[:openstack_auth_token]
+
+          unless @openstack_auth_token
+            missing_credentials = Array.new
+            @openstack_api_key  = options[:openstack_api_key]
+            @openstack_username = options[:openstack_username]
+
+            missing_credentials << :openstack_api_key  unless @openstack_api_key
+            missing_credentials << :openstack_username unless @openstack_username
+            raise ArgumentError, "Missing required arguments: #{missing_credentials.join(', ')}" unless missing_credentials.empty?
+          end
+
+          @openstack_tenant               = options[:openstack_tenant]
+          @openstack_auth_uri             = URI.parse(options[:openstack_auth_url])
+          @openstack_management_url       = options[:openstack_management_url]
+          @openstack_must_reauthenticate  = false
+          @openstack_service_type         = options[:openstack_service_type] || ['volume']
+          @openstack_service_name         = options[:openstack_service_name]
+
+          @openstack_endpoint_type        = options[:openstack_endpoint_type] || 'adminURL'
+          @connection_options = options[:connection_options] || {}
+
+          @current_user = options[:current_user]
+          @current_tenant = options[:current_tenant]
+
+          authenticate
+
+          @persistent = options[:persistent] || false
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def credentials
+          { :provider                 => 'openstack',
+            :openstack_auth_url       => @openstack_auth_uri.to_s,
+            :openstack_auth_token     => @auth_token,
+            :openstack_management_url => @openstack_management_url,
+            :current_user             => @current_user,
+            :current_tenant           => @current_tenant }
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          begin
+            response = @connection.request(params.merge({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'Accept' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@path}/#{params[:path]}"#,
+              # Causes errors for some requests like tenants?limit=1
+              # :query    => ('ignore_awful_caching' << Time.now.to_i.to_s)
+            }))
+          rescue Excon::Errors::Unauthorized => error
+            if error.response.body != 'Bad username or password' # token expiration
+              @openstack_must_reauthenticate = true
+              authenticate
+              retry
+            else # bad credentials
+              raise error
+            end
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Compute::OpenStack::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          unless response.body.empty?
+            response.body = MultiJson.decode(response.body)
+          end
+          response
+        end
+
+        private
+
+        def authenticate
+          if !@openstack_management_url || @openstack_must_reauthenticate
+            options = {
+              :openstack_tenant   => @openstack_tenant,
+              :openstack_api_key  => @openstack_api_key,
+              :openstack_username => @openstack_username,
+              :openstack_auth_uri => @openstack_auth_uri,
+              :openstack_auth_token => @openstack_auth_token,
+              :openstack_service_type => @openstack_service_type,
+              :openstack_service_name => @openstack_service_name,
+              :openstack_endpoint_type => @openstack_endpoint_type
+            }
+
+            credentials = Fog::OpenStack.authenticate_v2(options, @connection_options)
+
+            @current_user = credentials[:user]
+            @current_tenant = credentials[:tenant]
+
+            @openstack_must_reauthenticate = false
+            @auth_token = credentials[:token]
+            @openstack_management_url = credentials[:server_management_url]
+            uri = URI.parse(@openstack_management_url)
+          else
+            @auth_token = @openstack_auth_token
+            uri = URI.parse(@openstack_management_url)
+          end
+
+          @host   = uri.host
+          @path   = uri.path
+          @path.sub!(/\/$/, '')
+          @port   = uri.port
+          @scheme = uri.scheme
+          true
+        end
+
+      end
+    end
+  end
+end
+

data/vendor/fog/lib/fog/providers.rb

@@ -0,0 +1,2 @@
+require 'fog/openstack'
+require 'fog/digitalocean'

data/vendor/fog/lib/fog/schema/data_validator.rb

@@ -0,0 +1,154 @@
+module Fog
+  module Schema
+    # This validates a data object against a Ruby based schema to see
+    # if they match.
+    #
+    # * An object matches the schema if +==+ or +===+ returns +true+
+    # * Hashes match if all the key's values match the classes given
+    #   in the schema as well. This can be configured in the options
+    # * Arrays match when every element in the data matches the case
+    #   given in the schema.
+    #
+    # The schema and validation are very simple and probably not
+    # suitable for some cases.
+    #
+    # The following classes can be used to check for special behaviour
+    #
+    # * Fog::Boolean - value may be +true+ or +false+
+    # * Fog::Nullable::Boolean - value may be +true+, +false+ or +nil+
+    # * Fog::Nullable::Integer - value may be an Integer or +nil+
+    # * Fog::Nullable::String
+    # * Fog::Nullable::Time
+    # * Fog::Nullable::Float
+    # * Fog::Nullable::Hash
+    # * Fog::Nullable::Array
+    #
+    # All the "nullable" objects will pass if the value is of the class
+    # or if it is +nil+. This allows you to match APIs that may include
+    # keys when the value is not available in some cases but will
+    # always be a String. Such as an password that is only displayed
+    # on the reset action.
+    #
+    # The keys for "nullable" resources should always be present but
+    # original matcher had a bug that allowed these to also appear to
+    # work as optional keys/values.
+    #
+    # If you need the original behaviour, data with a missing key is
+    # still valid, then you may pass the +:allow_optional_rules+
+    # option to the #validate method.
+    #
+    # That is not recommended because you are describing a schema
+    # with optional keys in a format that does not support it.
+    #
+    # Setting +:allow_extra_keys+ as +true+ allows the data to
+    # contain keys not declared by the schema and still pass. This
+    # is useful if new attributes appear in the API in a backwards
+    # compatible manner and can be ignored.
+    #
+    # This is the behaviour you would have seen with +strict+ being
+    # +false+ in the original test helper.
+    #
+    # @example Schema example
+    #     {
+    #       "id" => String,
+    #       "ram" => Integer,
+    #       "disks" => [
+    #         "size" => Float
+    #       ],
+    #       "dns_name" => Fog::Nullable::String,
+    #       "active" => Fog::Boolean,
+    #       "created" => DateTime
+    #     }
+    #
+    class DataValidator
+
+      def initialize
+        @message = nil
+      end
+
+      # Checks if the data structure matches the schema passed in and
+      # returns +true+ if it fits.
+      #
+      # @param [Object] data Hash or Array to check
+      # @param [Object] schema Schema pattern to check against
+      # @param [Boolean] options
+      # @option options [Boolean] :allow_extra_keys
+      #     If +true+ does not fail if extra keys are in the data
+      #     that are not in the schema.
+      # @option options [Boolean] :allow_optional_rules
+      #     If +true+ does not fail if extra keys are in the schema
+      #     that do not match the data. Not recommended!
+      #
+      # @return [Boolean] Did the data fit the schema?
+      def validate(data, schema, options = {})
+        valid = validate_value(schema, data, options)
+
+        unless valid
+          @message = "#{data.inspect} does not match #{schema.inspect}"
+        end
+        valid
+      end
+
+      # This returns the last message set by the validator
+      #
+      # @return [String]
+      def message
+        @message
+      end
+
+    private
+
+      # This contains a slightly modified version of the Hashidator gem
+      # but unfortunately the gem does not cope with Array schemas.
+      #
+      # @see https://github.com/vangberg/hashidator/blob/master/lib/hashidator.rb
+      #
+      def validate_value(validator, value, options)
+        Fog::Logger.write :debug, "[yellow][DEBUG] #{value.inspect} against #{validator.inspect}[/]\n"
+
+        case validator
+        when Array
+          return false if value.is_a?(Hash)
+          value.respond_to?(:all?) && value.all? {|x| validate_value(validator[0], x, options)}
+        when Symbol
+          value.respond_to? validator
+        when Hash
+          return false if value.is_a?(Array)
+
+          # When being strict values not specified in the schema are fails
+          unless options[:allow_extra_keys]
+            if value.respond_to?(:empty?)
+              # Validator is empty but values are not
+              return false if !value.empty? && validator.empty?
+            end
+          end
+
+          unless options[:allow_optional_rules]
+            if value.respond_to?(:empty?)
+              # Validator has rules left but no more values
+              return false if value.empty? && !validator.empty?
+            end
+          end
+
+          validator.all? do |key, sub_validator|
+            Fog::Logger.write :debug, "[blue][DEBUG] #{key.inspect} against #{sub_validator.inspect}[/]\n"
+            validate_value(sub_validator, value[key], options)
+          end
+        else
+          result = validator == value
+          result = validator === value unless result
+          # Repeat unless we have a Boolean already
+          unless (result.is_a?(TrueClass) || result.is_a?(FalseClass))
+            result = validate_value(result, value, options)
+          end
+          if result
+            Fog::Logger.write :debug, "[green][DEBUG] Validation passed: #{value.inspect} against #{validator.inspect}[/]\n"
+          else
+            Fog::Logger.write :debug, "[red][DEBUG] Validation failed: #{value.inspect} against #{validator.inspect}[/]\n"
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/vendor/fog/lib/fog/storage.rb

@@ -0,0 +1,97 @@
+module Fog
+  module Storage
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # prevent delete from having side effects
+      case provider = attributes.delete(:provider).to_s.downcase.to_sym
+      when :atmos
+        require 'fog/atmos/storage'
+        Fog::Storage::Atmos.new(attributes)
+      when :aws
+        require 'fog/aws/storage'
+        Fog::Storage::AWS.new(attributes)
+      when :google
+        require 'fog/google/storage'
+        Fog::Storage::Google.new(attributes)
+      when :hp
+        require 'fog/hp/storage'
+        Fog::Storage::HP.new(attributes)
+      when :ibm
+        require 'fog/ibm/storage'
+        Fog::Storage::IBM.new(attributes)
+      when :internetarchive
+        require 'fog/internet_archive/storage'
+        Fog::Storage::InternetArchive.new(attributes)
+      when :local
+        require 'fog/local/storage'
+        Fog::Storage::Local.new(attributes)
+      when :ninefold
+        require 'fog/ninefold/storage'
+        Fog::Storage::Ninefold.new(attributes)
+      when :rackspace
+        require 'fog/rackspace/storage'
+        Fog::Storage::Rackspace.new(attributes)
+      when :openstack
+        require 'fog/openstack/storage'
+        Fog::Storage::OpenStack.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} is not a recognized storage provider")
+      end
+    end
+
+    def self.directories
+      directories = []
+      for provider in self.providers
+        begin
+          directories.concat(self[provider].directories)
+        rescue # ignore any missing credentials/etc
+        end
+      end
+      directories
+    end
+
+    def self.get_body_size(body)
+      if body.respond_to?(:force_encoding)
+        body.force_encoding('BINARY')
+      end
+      if body.respond_to?(:bytesize)
+        body.bytesize
+      elsif body.respond_to?(:size)
+        body.size
+      elsif body.respond_to?(:stat)
+        body.stat.size
+      else
+        0
+      end
+    end
+
+    def self.get_content_type(data)
+      if data.respond_to?(:path) and !data.path.nil?
+        filename = ::File.basename(data.path)
+        unless (mime_types = MIME::Types.of(filename)).empty?
+          mime_types.first.content_type
+        end
+      end
+    end
+
+    def self.parse_data(data)
+      {
+        :body     => data,
+        :headers  => {
+          'Content-Length'  => get_body_size(data),
+          'Content-Type'    => get_content_type(data)
+          #'Content-MD5' => Base64.encode64(Digest::MD5.digest(metadata[:body])).strip
+        }
+      }
+    end
+
+    def self.providers
+      Fog.services[:storage]
+    end
+
+  end
+end