fog-core 1.21.0

data/lib/fog/core/ssh.rb

@@ -0,0 +1,137 @@
+require 'delegate'
+
+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 self.reset
+        @data= nil
+      end
+
+      def initialize(address, username, options)
+        @address  = address
+        @username = username
+        @options  = options
+      end
+
+      def run(commands, &blk)
+        self.class.data[@address] << {:commands => commands, :username => @username, :options => @options}
+      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
+
+        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 run(commands, &blk)
+        commands = [*commands]
+        results  = []
+        begin
+          Net::SSH.start(@address, @username, @options) do |ssh|
+            commands.each do |command|
+              result = Result.new(command)
+              ssh.open_channel do |ssh_channel|
+                ssh_channel.request_pty
+                ssh_channel.exec(command) do |channel, success|
+                  unless success
+                    raise "Could not execute command: #{command.inspect}"
+                  end
+
+                  channel.on_data do |ch, data|
+                    result.stdout << data
+                    yield [data, ''] if blk
+                  end
+
+                  channel.on_extended_data do |ch, type, data|
+                    next unless type == 1
+                    result.stderr << data
+                    yield ['', data] if blk
+                  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
+        data = stdout.split("\r\n")
+        if data.is_a?(String)
+          Formatador.display_line(data)
+        elsif data.is_a?(Array)
+          Formatador.display_lines(data)
+        end
+      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

@@ -0,0 +1,32 @@
+require 'time'
+
+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
+      self.utc.strftime("#{DAYS[self.utc.wday]}, %d #{MONTHS[self.utc.month - 1]} %Y %H:%M:%S +0000")
+    end
+
+    def to_iso8601_basic
+      self.utc.strftime('%Y%m%dT%H%M%SZ')
+    end
+
+  end
+end

data/lib/fog/core/uuid.rb

@@ -0,0 +1,23 @@
+require 'securerandom'
+
+module Fog
+  class UUID
+    class << self
+
+      def uuid
+        if supported?
+          SecureRandom.uuid
+        else
+          ary = SecureRandom.random_bytes(16).unpack("NnnnnN")
+          ary[2] = (ary[2] & 0x0fff) | 0x4000
+          ary[3] = (ary[3] & 0x3fff) | 0x8000
+          "%08x-%04x-%04x-%04x-%04x%08x" % ary
+        end
+      end
+
+      def supported?
+        SecureRandom.respond_to?(:uuid)
+      end
+    end
+  end
+end

data/lib/fog/core/wait_for.rb

@@ -0,0 +1,15 @@
+module Fog
+  def self.wait_for(timeout=Fog.timeout, interval=Fog.interval, &block)
+    duration = 0
+    start = Time.now
+    until yield || duration > timeout
+      sleep(interval.to_f)
+      duration = Time.now - start
+    end
+    if duration > timeout
+      raise Errors::TimeoutError.new("The specified wait_for timeout (#{timeout} seconds) was exceeded")
+    else
+      { :duration => duration }
+    end
+  end
+end

data/lib/fog/core/wait_for_defaults.rb

@@ -0,0 +1,21 @@
+module Fog
+  @interval = 1
+  def self.interval
+    @interval
+  end
+
+  def self.interval=(interval)
+    raise ArgumentError, "interval must be non-negative" unless interval >= 0
+    @interval = interval
+  end
+  
+  @timeout = 600
+  def self.timeout
+    @timeout
+  end
+
+  def self.timeout=(timeout)
+    raise ArgumentError, "timeout must be non-negative" unless timeout >= 0
+    @timeout = timeout
+  end
+end

data/lib/fog/dns.rb

@@ -0,0 +1,40 @@
+module Fog
+  module DNS
+
+    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 :stormondemand
+        require 'fog/storm_on_demand/dns'
+        Fog::DNS::StormOnDemand.new(attributes)
+      else
+        if self.providers.include?(provider)
+          require "fog/#{provider}/dns"
+          return Fog::DNS.const_get(Fog.providers[provider]).new(attributes)
+        end
+
+        raise ArgumentError.new("#{provider} is not a recognized dns provider")
+      end
+    end
+
+    def self.providers
+      Fog.services[:dns]
+    end
+
+    def self.zones
+      zones = []
+      for provider in self.providers
+        begin
+          zones.concat(self[provider].zones)
+        rescue # ignore any missing credentials/etc
+        end
+      end
+      zones
+    end
+
+  end
+end

data/lib/fog/identity.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Identity
+
+    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 :rackspace
+        require 'fog/rackspace/identity'
+        Fog::Rackspace::Identity.new(attributes)
+      else
+        if self.providers.include?(provider)
+          require "fog/#{provider}/identity"
+          return Fog::Identity.const_get(Fog.providers[provider]).new(attributes)
+        end
+        raise ArgumentError.new("#{provider} has no identity service")
+      end
+    end
+
+    def self.providers
+      Fog.services[:identity]
+    end
+
+  end
+end

data/lib/fog/image.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Image
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # Prevent delete from having side effects
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+      if self.providers.include?(provider)
+        require "fog/#{provider}/image"
+        return Fog::Image.const_get(Fog.providers[provider]).new(attributes)
+      end
+      raise ArgumentError.new("#{provider} has no identity service")
+    end
+
+    def self.providers
+      Fog.services[:image]
+    end
+
+  end
+end

data/lib/fog/metering.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Metering
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # Prevent delete from having side effects
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+      if self.providers.include?(provider)
+        require "fog/#{provider}/metering"
+        return Fog::Metering.const_get(Fog.providers[provider]).new(attributes)
+      end
+
+      raise ArgumentError.new("#{provider} has no identity service")
+    end
+
+    def self.providers
+      Fog.services[:metering]
+    end
+
+  end
+end
+

data/lib/fog/monitoring.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Monitoring
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+      if provider == :stormondemand
+        require 'fog/storm_on_demand/billing'
+        Fog::Monitoring::StormOnDemand.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} has no monitoring service")
+      end
+    end
+
+    def self.providers
+      Fog.services[:monitoring]
+    end
+
+  end
+end

data/lib/fog/network.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Network
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # Prevent delete from having side effects
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+
+      if provider == :stormondemand
+        require "fog/storm_on_demand/network"
+        return Fog::Network::StormOnDemand.new(attributes)
+      elsif self.providers.include?(provider)
+        require "fog/#{provider}/network"
+        return Fog::Network.const_get(Fog.providers[provider]).new(attributes)
+      end
+
+      raise ArgumentError.new("#{provider} has no network service")
+    end
+
+    def self.providers
+      Fog.services[:network]
+    end
+
+  end
+end

data/lib/fog/orchestration.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Orchestration
+
+    def self.[](provider)
+      self.new(:provider => provider)
+    end
+
+    def self.new(attributes)
+      attributes = attributes.dup # Prevent delete from having side effects
+      provider = attributes.delete(:provider).to_s.downcase.to_sym
+
+      if self.providers.include?(provider)
+        require "fog/#{provider}/network"
+        return Fog::Orchestration.const_get(Fog.providers[provider]).new(attributes)
+      end
+
+      raise ArgumentError.new("#{provider} has no orchestration service")
+    end
+
+    def self.providers
+      Fog.services[:orchestration]
+    end
+
+  end
+end

data/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