fog-core 1.21.0

data/lib/fog/core/hmac.rb

@@ -0,0 +1,35 @@
+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.new('sha1')
+      @signer = lambda do |data|
+        OpenSSL::HMAC.digest(@digest, @key, data)
+      end
+    end
+
+    def setup_sha256
+      @digest = OpenSSL::Digest.new('sha256')
+      @signer = lambda do |data|
+        OpenSSL::HMAC.digest(@digest, @key, data)
+      end
+    end
+
+  end
+end

data/lib/fog/core/logger.rb

@@ -0,0 +1,44 @@
+module Fog
+  class Logger
+
+    @channels = {
+      :deprecation  => ::STDERR,
+      :warning      => ::STDERR
+    }
+
+    @channels[:debug] = ::STDERR 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][fog][DEBUG] #{message}[/]\n")
+    end
+
+    def self.deprecation(message)
+      self.write(:deprecation, "[yellow][fog][DEPRECATION] #{message}[/]\n")
+    end
+
+    def self.warning(message)
+      self.write(:warning, "[yellow][fog][WARNING] #{message}[/]\n")
+    end
+
+    def self.write(key, value)
+      if channel = @channels[key]
+        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/lib/fog/core/mock.rb

@@ -0,0 +1,115 @@
+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(message = 'Contributions welcome!')
+      raise Fog::Errors::MockNotImplemented.new(message)
+    end
+
+    def self.random_ip(opts = {:version => :v4})
+      version = opts[:version]
+      if version == :v6
+        bit_length = 128
+        family = Socket::AF_INET6
+      elsif version == :v4
+        bit_length = 32
+        family = Socket::AF_INET
+      else
+        raise ArgumentError, "Unknown IP version: #{version}"
+      end
+
+      seed = 1 + rand((2**bit_length)-1)
+      IPAddr.new(seed, family).to_s
+    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_letters_and_numbers(length)
+      random_selection(
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
+        length
+      )
+    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/lib/fog/core/model.rb

@@ -0,0 +1,80 @@
+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_has_succeeded = false
+      duration = Fog.wait_for(timeout, interval) do # Note that duration = false if it times out
+        if reload
+          reload_has_succeeded = true
+          instance_eval(&block)
+        else
+          false
+        end
+      end
+      if reload_has_succeeded
+        return duration # false if timeout; otherwise {:duration => elapsed time }
+      else
+        raise Fog::Errors::Error.new("Reload failed, #{self.class} #{self.identity} not present.")
+      end
+    end
+
+  end
+end

data/lib/fog/core/provider.rb

@@ -0,0 +1,34 @@
+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, 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('::')
+    end
+
+    def services
+      @services_registry.keys
+    end
+
+  end
+end

data/lib/fog/core/scp.rb

@@ -0,0 +1,96 @@
+module Fog
+  module SCP
+
+    def self.new(address, username, options = {})
+      if Fog.mocking?
+        Fog::SCP::Mock.new(address, username, options)
+      else
+        Fog::SCP::Real.new(address, username, options)
+      end
+    end
+
+    class Mock
+
+      def self.data
+        @data ||= Hash.new do |hash, key|
+          hash[key] = []
+        end
+      end
+
+      def initialize(address, username, options)
+        @address  = address
+        @username = username
+        @options  = options
+      end
+
+      def upload(local_path, remote_path, upload_options = {})
+        self.class.data[@address] << { :username       => @username,
+                                       :options        => @options,
+                                       :local_path     => local_path,
+                                       :remote_path    => remote_path,
+                                       :upload_options => upload_options }
+      end
+
+      def download(remote_path, local_path, download_options = {})
+        self.class.data[@address] << { :username         => @username,
+                                       :options          => @options,
+                                       :remote_path      => remote_path,
+                                       :local_path       => local_path,
+                                       :download_options => download_options }
+      end
+
+    end
+
+    class Real
+
+      def initialize(address, username, options)
+        require 'net/scp'
+
+        key_manager = Net::SSH::Authentication::KeyManager.new(nil, options)
+
+        unless options[:key_data] || options[:keys] || options[:password] || key_manager.agent
+          raise ArgumentError.new(':key_data, :keys, :password or a loaded ssh-agent is required to initialize SSH')
+        end
+
+        options[:timeout] = 30
+        if options[:key_data] || options[:keys]
+          options[:keys_only] = true
+          #Explicitly set these so net-ssh doesn't add the default keys
+          #as seen at https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/session.rb#L131-146
+          options[:keys] = [] unless options[:keys]
+          options[:key_data] = [] unless options[:key_data]
+        end
+
+        @address  = address
+        @username = username
+        @options  = { :paranoid => false }.merge(options)
+      end
+
+      def upload(local_path, remote_path, upload_options = {}, &block)
+        begin
+          Net::SCP.start(@address, @username, @options) do |scp|
+            scp.upload!(local_path, remote_path, upload_options) do |ch, name, sent, total|
+              block.call(ch, name, sent, total) if block
+            end
+          end
+        rescue Exception => error
+          raise error
+        end
+      end
+
+      def download(remote_path, local_path, download_options = {}, &block)
+        begin
+          Net::SCP.start(@address, @username, @options) do |scp|
+            scp.download!(remote_path, local_path, download_options) do |ch, name, sent, total|
+              block.call(ch, name, sent, total) if block
+            end
+          end
+        rescue Exception => error
+          raise error
+        end
+      end
+
+    end
+
+  end
+end

data/lib/fog/core/service.rb

@@ -0,0 +1,223 @@
+module Fog
+
+  def self.services
+    @services ||= {}
+  end
+
+  class Service
+
+    class Error < Fog::Errors::Error; end
+    class NotFound < Fog::Errors::NotFound; end
+
+    module NoLeakInspector
+      def inspect
+        "#<#{self.class}:#{self.object_id} #{(self.instance_variables - service.secrets).map {|iv| [iv, self.instance_variable_get(iv).inspect].join('=')}.join(' ')}>"
+      end
+    end
+
+    module Collections
+
+      def collections
+        service.collections
+      end
+
+      def mocked_requests
+        service.mocked_requests
+      end
+
+      def requests
+        service.requests
+      end
+
+    end
+
+    class << self
+
+      def inherited(child)
+        child.class_eval <<-EOS, __FILE__, __LINE__
+          class Error < Fog::Service::Error; end
+          class NotFound < Fog::Service::NotFound; end
+
+          module Collections
+            include Fog::Service::Collections
+
+            def service
+              #{child}
+            end
+          end
+
+          def self.service
+            #{child}
+          end
+        EOS
+      end
+
+      def new(options={})
+        options = Fog.symbolize_credentials(options)
+        options = fetch_credentials(options).merge(options)
+        validate_options(options)
+        coerce_options(options)
+        setup_requirements
+
+        if Fog.mocking?
+          service::Mock.send(:include, service::Collections)
+          service::Mock.new(options)
+        else
+          service::Real.send(:include, service::Collections)
+          service::Real.send(:include, service::NoLeakInspector)
+          service::Real.new(options)
+        end
+      end
+
+      def fetch_credentials(options)
+        # attempt to load credentials from config file
+        begin
+          Fog.credentials.reject {|key, value| !(recognized | requirements).include?(key)}
+        rescue LoadError
+          # if there are no configured credentials, do nothing
+          {}
+        end
+      end
+
+      def setup_requirements
+        if superclass.respond_to?(:setup_requirements)
+          superclass.setup_requirements
+        end
+
+        @required ||= false
+        unless @required
+          for collection in collections
+            require [@model_path, collection].join('/')
+            constant = collection.to_s.split('_').map {|characters| characters[0...1].upcase << characters[1..-1]}.join('')
+            service::Collections.module_eval <<-EOS, __FILE__, __LINE__
+              def #{collection}(attributes = {})
+                #{service}::#{constant}.new({:service => self}.merge(attributes))
+              end
+            EOS
+          end
+          for model in models
+            require [@model_path, model].join('/')
+          end
+          for request in requests
+            require [@request_path, request].join('/')
+            if service::Mock.method_defined?(request)
+              mocked_requests << request
+            else
+              service::Mock.module_eval <<-EOS, __FILE__, __LINE__
+                def #{request}(*args)
+                  Fog::Mock.not_implemented
+                end
+              EOS
+            end
+          end
+          @required = true
+        end
+      end
+
+      def model_path(new_path)
+        @model_path = new_path
+      end
+
+      def collection(new_collection)
+        collections << new_collection
+      end
+
+      def collections
+        @collections ||= []
+      end
+
+      def coerce_options(options)
+        options.each do |key, value|
+          value_string = value.to_s.downcase
+          if value.nil?
+            options.delete(key)
+          elsif value == value_string.to_i.to_s
+            options[key] = value.to_i
+          else
+            options[key] = case value_string
+            when 'false'
+              false
+            when 'true'
+              true
+            else
+              value
+            end
+          end
+        end
+      end
+
+      def mocked_requests
+        @mocked_requests ||= []
+      end
+
+      def model(new_model)
+        models << new_model
+      end
+
+      def models
+        @models ||= []
+      end
+
+      def request_path(new_path)
+        @request_path = new_path
+      end
+
+      def request(new_request)
+        requests << new_request
+      end
+
+      def requests
+        @requests ||= []
+      end
+
+      def secrets(*args)
+        if args.empty?
+          @secrets ||= []
+        else
+          args.inject(secrets) do |secrets, secret|
+            secrets << "@#{secret}".to_sym
+          end
+        end
+      end
+
+      def requires(*args)
+        requirements.concat(args)
+      end
+
+      def requirements
+        @requirements ||= []
+      end
+
+      def recognizes(*args)
+        recognized.concat(args)
+      end
+
+      def recognized
+        @recognized ||= [:connection_options]
+      end
+
+      def validate_options(options)
+        keys = []
+        for key, value in options
+          unless value.nil?
+            keys << key
+          end
+        end
+        missing = requirements - keys
+        unless missing.empty?
+          raise ArgumentError, "Missing required arguments: #{missing.join(', ')}"
+        end
+
+        unless recognizes.empty?
+          unrecognized = options.keys - requirements - recognized
+          unless unrecognized.empty?
+            Fog::Logger.warning("Unrecognized arguments: #{unrecognized.join(', ')}")
+          end
+        end
+      end
+
+    end
+
+  end
+end
+