fog 0.7.1 → 2.3.0

data/lib/fog/core/mock.rb

@@ -1,68 +0,0 @@
-module Fog
-
-  @mocking = false
-
-  def self.mock!
-    @mocking = true
-  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
-
-  end
-
-end

data/lib/fog/core/model.rb

@@ -1,57 +0,0 @@
-module Fog
-  class Model
-
-    extend Fog::Attributes::ClassMethods
-    include Fog::Attributes::InstanceMethods
-
-    attr_accessor :collection, :connection
-
-    def initialize(new_attributes = {})
-      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
-      if data = collection.get(identity)
-        new_attributes = data.attributes
-        merge_attributes(new_attributes)
-        self
-      end
-    end
-
-    def to_json
-      require 'json'
-      attributes.to_json
-    end
-
-    def wait_for(timeout=600, interval=1, &block)
-      reload
-      Fog.wait_for(timeout, interval) do
-        retries = 3
-        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/lib/fog/core/provider.rb

@@ -1,18 +0,0 @@
-module Fog
-  module Provider
-
-    def self.extended(base)
-      Fog.providers << base.to_s.split('::').last
-    end
-
-    def service(new_service, path)
-      services << new_service
-      require File.join('fog', path)
-    end
-
-    def services
-      @services ||= []
-    end
-
-  end
-end

data/lib/fog/core/scp.rb

@@ -1,63 +0,0 @@
-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)
-        Fog::Mock.not_implemented
-      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
-
-        @address  = address
-        @username = username
-        @options  = { :paranoid => false }.merge(options)
-      end
-
-      def upload(local_path, remote_path)
-        begin
-          Net::SCP.start(@address, @username, @options) do |scp|
-            scp.upload!(local_path, remote_path) do |ch, name, sent, total|
-              # TODO: handle progress display?
-            end
-          end
-        rescue Exception => error
-          raise error
-        end
-      end
-
-    end
-
-  end
-end

data/lib/fog/core/service.rb

@@ -1,167 +0,0 @@
-module Fog
-  class Service
-
-    class Error < Fog::Errors::Error; end
-    class NotFound < Fog::Errors::NotFound; 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__
-          module Collections
-            include Fog::Service::Collections
-
-            def service
-              #{child}
-            end
-          end
-
-          def self.service
-            #{child}
-          end
-        EOS
-      end
-
-      def new(options={})
-        # attempt to load credentials from config file
-        begin
-          default_credentials = Fog.credentials.reject {|key, value| !(recognized | requirements).include?(key)}
-          options = default_credentials.merge(options)
-        rescue LoadError
-          # if there are no configured credentials, do nothing
-        end
-
-        validate_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.new(options)
-        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({:connection => 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 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 requires(*args)
-        requirements.concat(args)
-      end
-
-      def requirements
-        @requirements ||= []
-      end
-
-      def recognizes(*args)
-        recognized.concat(args)
-      end
-
-      def recognized
-        @recognized ||= []
-      end
-
-      def validate_options(options)
-        missing = requirements - options.keys
-        unless missing.empty?
-          raise ArgumentError, "Missing required arguments: #{missing.join(', ')}"
-        end
-
-        unless recognizes.empty?
-          unrecognized = options.keys - requirements - recognized
-          unless unrecognized.empty?
-            raise ArgumentError, "Unrecognized arguments: #{unrecognized.join(', ')}"
-          end
-        end
-      end
-
-    end
-
-  end
-end
-

data/lib/fog/core/ssh.rb

@@ -1,116 +0,0 @@
-module Fog
-  module SSH
-
-    def self.new(address, username, options = {})
-      if Fog.mocking?
-        Fog::SSH::Mock.new(address, username, options)
-      else
-        Fog::SSH::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 run(commands)
-        Fog::Mock.not_implemented
-      end
-
-    end
-
-    class Real
-
-      def initialize(address, username, options)
-        require 'net/ssh'
-
-        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
-
-        @address  = address
-        @username = username
-        @options  = { :paranoid => false }.merge(options)
-      end
-
-      def run(commands)
-        commands = [*commands]
-        results  = []
-        begin
-          Net::SSH.start(@address, @username, @options) do |ssh|
-            commands.each do |command|
-              escaped_command = command.sub(/'/, %{'"'"'})
-              result = Result.new(escaped_command)
-              ssh.open_channel do |ssh_channel|
-                ssh_channel.request_pty
-                ssh_channel.exec(%{bash -lc '#{escaped_command}'}) do |channel, success|
-                  unless success
-                    raise "Could not execute command: #{command.inspect}"
-                  end
-
-                  channel.on_data do |ch, data|
-                    result.stdout << data
-                  end
-
-                  channel.on_extended_data do |ch, type, data|
-                    next unless type == 1
-                    result.stderr << data
-                  end
-
-                  channel.on_request('exit-status') do |ch, data|
-                    result.status = data.read_long
-                  end
-
-                  channel.on_request('exit-signal') do |ch, data|
-                    result.status = 255
-                  end
-                end
-              end
-              ssh.loop
-              results << result
-            end
-          end
-        rescue Net::SSH::HostKeyMismatch => exception
-          exception.remember_host!
-          sleep 0.2
-          retry
-        end
-        results
-      end
-
-    end
-
-    class Result
-
-      attr_accessor :command, :stderr, :stdout, :status
-
-      def display_stdout
-        Formatador.display_line(stdout.split("\r\n"))
-      end
-
-      def display_stderr
-        Formatador.display_line(stderr.split("\r\n"))
-      end
-
-      def initialize(command)
-        @command = command
-        @stderr = ''
-        @stdout = ''
-      end
-
-    end
-
-  end
-end

data/lib/fog/core/time.rb

@@ -1,27 +0,0 @@
-module Fog
-  class Time < ::Time
-
-    DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
-    MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
-
-    def self.now
-      at((::Time.now - offset).to_i)
-    end
-
-    def self.now=(new_now)
-      old_now = ::Time.now
-      @offset = old_now - new_now
-      new_now
-    end
-
-    def self.offset
-      @offset ||= 0
-    end
-
-    def to_date_header
-      now = self.class.now.utc
-      now.strftime("#{DAYS[now.wday]}, %d #{MONTHS[now.month - 1]} %Y %H:%M:%S +0000")
-    end
-
-  end
-end

data/lib/fog/core/wait_for.rb

@@ -1,17 +0,0 @@
-module Fog
-
-  def self.wait_for(timeout=600, interval=1, &block)
-    duration = 0
-    start = Time.now
-    until yield || duration > timeout
-      sleep(interval)
-      duration = Time.now - start
-    end
-    if duration > timeout
-      false
-    else
-      { :duration => duration }
-    end
-  end
-  
-end

data/lib/fog/core.rb

@@ -1,33 +0,0 @@
-__LIB_DIR__ = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-$LOAD_PATH.unshift __LIB_DIR__ unless
-  $LOAD_PATH.include?(__LIB_DIR__) ||
-  $LOAD_PATH.include?(File.expand_path(__LIB_DIR__))
-
-# external core dependencies
-require 'rubygems'
-require 'base64'
-require 'cgi'
-require 'excon'
-require 'fileutils'
-require 'formatador'
-require 'time'
-require 'timeout'
-
-# internal core dependencies
-require 'fog/core/attributes'
-require 'fog/core/collection'
-require 'fog/core/connection'
-require 'fog/core/credentials'
-require 'fog/core/deprecation'
-require 'fog/core/errors'
-require 'fog/core/hmac'
-require 'fog/core/model'
-require 'fog/core/mock'
-# require 'fog/core/parser'
-require 'fog/core/provider'
-require 'fog/core/service'
-require 'fog/core/ssh'
-require 'fog/core/scp'
-require 'fog/core/time'
-require 'fog/core/wait_for'

data/lib/fog/dns/aws.rb

@@ -1,125 +0,0 @@
-module Fog
-  module AWS
-    class DNS < Fog::Service
-
-      requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :host, :path, :port, :scheme, :version, :persistent
-      recognizes :provider # remove post deprecation
-
-      model_path 'fog/dns/models/aws'
-      model       :record
-      collection  :records
-      model       :zone
-      collection  :zones
-
-      request_path 'fog/dns/requests/aws'
-      request :create_hosted_zone
-      request :get_hosted_zone
-      request :delete_hosted_zone
-      request :list_hosted_zones
-      request :change_resource_record_sets
-      request :list_resource_record_sets
-      request :get_change
-
-      class Mock
-
-        def self.data
-          @data ||= Hash.new do |hash, region|
-            hash[region] = Hash.new do |region_hash, key|
-              region_hash[key] = {
-                :buckets => {}
-              }
-            end
-          end
-        end
-
-        def initialize(options={})
-          unless options.delete(:provider)
-            location = caller.first
-            warning = "[yellow][WARN] Fog::AWS::DNS.new is deprecated, use Fog::DNS.new(:provider => 'AWS') instead[/]"
-            warning << " [light_black](" << location << ")[/] "
-            Formatador.display_line(warning)
-          end
-
-          require 'mime/types'
-          @aws_access_key_id  = options[:aws_access_key_id]
-          @region             = options[:region]
-          @data = self.class.data[@region][@aws_access_key_id]
-        end
-
-        def reset_data
-          self.class.data[@region].delete(@aws_access_key_id)
-          @data = self.class.data[@region][@aws_access_key_id]
-        end
-
-        def signature(params)
-          "foo"
-        end
-      end
-
-      class Real
-
-        # Initialize connection to Route 53 DNS service
-        #
-        # ==== Notes
-        # options parameter must include values for :aws_access_key_id and
-        # :aws_secret_access_key in order to create a connection
-        #
-        # ==== Examples
-        #   dns = Fog::AWS::DNS.new(
-        #     :aws_access_key_id => your_aws_access_key_id,
-        #     :aws_secret_access_key => your_aws_secret_access_key
-        #   )
-        #
-        # ==== Parameters
-        # * options<~Hash> - config arguments for connection.  Defaults to {}.
-        #
-        # ==== Returns
-        # * dns object with connection to aws.
-        def initialize(options={})
-          unless options.delete(:provider)
-            location = caller.first
-            warning = "[yellow][WARN] Fog::AWS::DNS.new is deprecated, use Fog::DNS.new(:provider => 'DNS') instead[/]"
-            warning << " [light_black](" << location << ")[/] "
-            Formatador.display_line(warning)
-          end
-
-          require 'fog/core/parser'
-
-          @aws_access_key_id = options[:aws_access_key_id]
-          @aws_secret_access_key = options[:aws_secret_access_key]
-          @hmac     = Fog::HMAC.new('sha1', @aws_secret_access_key)
-          @host     = options[:host]      || 'route53.amazonaws.com'
-          @path     = options[:path]      || '/'
-          @port     = options[:port]      || 443
-          @scheme   = options[:scheme]    || 'https'
-          @version  = options[:version]  || '2010-10-01'
-          unless options.has_key?(:persistent)
-            options[:persistent] = true
-          end
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent])
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        private
-
-        def request(params, &block)
-          params[:headers] ||= {}
-          params[:headers]['Date'] = Fog::Time.now.to_date_header
-          params[:headers]['X-Amzn-Authorization'] = "AWS3-HTTPS AWSAccessKeyId=#{@aws_access_key_id},Algorithm=HmacSHA1,Signature=#{signature(params)}"
-          params[:path] = "/#{@version}/#{params[:path]}" 
-          @connection.request(params, &block)
-        end
-
-        def signature(params)
-          string_to_sign = params[:headers]['Date']
-          signed_string = @hmac.sign(string_to_sign)
-          signature = Base64.encode64(signed_string).chomp!
-        end
-      end
-    end
-  end
-end