fog 1.19.0 → 1.20.0

data/lib/fog/hp/network.rb

@@ -1,4 +1,4 @@
-require 'fog/hp'
+require 'fog/hp/core'
 
 module Fog
   module HP

data/lib/fog/hp/storage.rb

@@ -1,4 +1,4 @@
-require 'fog/hp'
+require 'fog/hp/core'
 require 'fog/storage'
 
 module Fog

data/lib/fog/ibm.rb

@@ -1,176 +1,2 @@
-require 'fog/core'
-
-module Fog
-  module IBM
-
-    extend Fog::Provider
-
-    service(:compute, 'ibm/compute', 'Compute')
-    service(:storage, 'ibm/storage', 'Storage')
-
-    # Provisioning is very slow. We'll pass this arg explicitly until there's a way
-    # to set the default timeout on a per-provider basis.
-
-    def self.timeout
-      1800
-    end
-
-    class Connection < Fog::Connection
-
-      def initialize(user, password)
-        @user = user
-        @password = password
-        @endpoint = URI.parse('https://www-147.ibm.com/computecloud/enterprise/api/rest/20100331')
-        @base_path = @endpoint.path
-        super("#{@endpoint.scheme}://#{@endpoint.host}:#{@endpoint.port}")
-      end
-
-      def request(options)
-        options[:path] = @base_path + options[:path]
-        options[:headers] ||= {}
-        options[:headers]['Authorization'] = auth_header
-        options[:headers]['Accept'] = 'application/json'
-        options[:headers]['Accept-Encoding'] = 'gzip'
-        unless options[:body].nil?
-          options[:headers]['Content-Type'] = 'application/x-www-form-urlencoded'
-          options[:body] = form_encode(options[:body])
-        end
-        response = super(options)
-        unless response.body.empty?
-          response.body = Fog::JSON.decode(response.body)
-        end
-        response
-      end
-
-      def auth_header
-        @auth_header ||= 'Basic ' + Base64.encode64("#{@user}:#{@password}").gsub("\n",'')
-      end
-
-      def form_encode(params)
-        params.reject {|k, v| v.nil? }.map {|pair| pair.map {|x| URI.escape(x.to_s) }.join('=') }.join('&')
-      end
-    end
-
-    class Mock
-      class << self
-
-        def id
-          Fog::Mock.random_numbers(7).to_i.to_s
-        end
-        alias :instance_id :id
-        alias :request_id  :id
-
-        def primary_ip
-          { "type" => 0, "ip" => Fog::IBM::Mock.ip_address, "hostname" => Fog::IBM::Mock.hostname }
-        end
-
-        def ip_address
-          ip = []
-          4.times do
-            ip << Fog::Mock.random_numbers(rand(3) + 1).to_i.to_s # remove leading 0
-          end
-          ip.join('.')
-        end
-
-        def hostname
-          "vhost" + Fog::Mock.random_numbers(3).to_i.to_s + ".fake.compute.ihost.com"
-        end
-
-        # Miliseconds since epoch
-        def launch_time
-          (Time.now.tv_sec * 1000).to_i
-        end
-
-        # 1 year from now, in miliseconds since epoch
-        def expiry_time
-          ((Time.now.tv_sec + 31556926) * 1000).to_i
-        end
-
-        def owner
-          "user" + Fog::Mock.random_numbers(3).to_i.to_s + "@company.com"
-        end
-
-        def key_material
-          OpenSSL::PKey::RSA.generate(1024)
-        end
-
-        def private_image(name, description)
-          {
-            "name"        => name,
-            "createdTime" => Fog::IBM::Mock.launch_time,
-            "productCodes"=> [],
-            "id"          => Fog::IBM::Mock.instance_id,
-            "description" => description,
-            "visibility"  => "PRIVATE",
-            "state"       => 0
-          }
-        end
-
-        def create_instance(name, image_id, instance_type, location, options)
-          {
-            "name"          => name,
-            "location"      => location,
-            "keyName"       => options[:key_name],
-            "primaryIP"     => Fog::IBM::Mock.primary_ip,
-            "productCodes"  => [],
-            "requestId"     => Fog::IBM::Mock.request_id,
-            "imageId"       => image_id,
-            "launchTime"    => Fog::IBM::Mock.launch_time,
-            "id"            => Fog::IBM::Mock.instance_id,
-            "volumes"       => [],
-            "isMiniEphemeral" => "false",
-            "instanceType"  => instance_type,
-            "diskSize"      => "60",
-            "requestName"   => "",
-            "secondaryIP"   => [],
-            "status"        => 1,
-            "software"      => [
-              { "name"=>"SUSE Linux Enterprise Server",
-                "type"=>"OS",
-                "version"=>"11 SP1" }
-            ],
-            "expirationTime"=> Fog::IBM::Mock.expiry_time,
-            "owner"         => Fog::IBM::Mock.owner
-          }
-        end
-
-        def create_volume(name, format, location_id, size, offering_id)
-          {
-            "instanceId"  => "0",
-            "state"       => 1,
-            "size"        => size,
-            "offeringId"  => offering_id,
-            "ioPrice" => {
-              "rate"  => 0.11,
-              "unitOfMeasure" => "CNT",
-              "countryCode"   => "897",
-              "effectiveDate" => Fog::IBM::Mock.launch_time,
-              "currencyCode"  => "USD",
-              "pricePerQuantity"  => 1
-            },
-            "owner"       => Fog::IBM::Mock.owner,
-            "createdTime" => Fog::IBM::Mock.launch_time,
-            "location"    => location_id,
-            "productCodes"=> [],
-            "format"      => format,
-            "name"        => name,
-            "id"          => Fog::IBM::Mock.id,
-          }
-        end
-
-        def create_address(location_id, offering_id, vlan_id)
-          # TODO: Figure out vlan handling
-          {
-            "id"        => Fog::IBM::Mock.id,
-            "location"  => location_id,
-            "offeringId"=> offering_id,
-            "ip"        => "",
-            "state"     => 0
-          }
-        end
-
-      end
-    end
-
-  end
-end
+require 'fog/ibm/compute'
+require 'fog/ibm/storage'

data/lib/fog/ibm/compute.rb

@@ -1,4 +1,4 @@
-require 'fog/ibm'
+require 'fog/ibm/core'
 require 'fog/compute'
 
 module Fog

data/lib/fog/ibm/core.rb

@@ -0,0 +1,176 @@
+require 'fog/core'
+
+module Fog
+  module IBM
+
+    extend Fog::Provider
+
+    service(:compute, 'Compute')
+    service(:storage, 'Storage')
+
+    # Provisioning is very slow. We'll pass this arg explicitly until there's a way
+    # to set the default timeout on a per-provider basis.
+
+    def self.timeout
+      1800
+    end
+
+    class Connection < Fog::Connection
+
+      def initialize(user, password)
+        @user = user
+        @password = password
+        @endpoint = URI.parse('https://www-147.ibm.com/computecloud/enterprise/api/rest/20100331')
+        @base_path = @endpoint.path
+        super("#{@endpoint.scheme}://#{@endpoint.host}:#{@endpoint.port}")
+      end
+
+      def request(options)
+        options[:path] = @base_path + options[:path]
+        options[:headers] ||= {}
+        options[:headers]['Authorization'] = auth_header
+        options[:headers]['Accept'] = 'application/json'
+        options[:headers]['Accept-Encoding'] = 'gzip'
+        unless options[:body].nil?
+          options[:headers]['Content-Type'] = 'application/x-www-form-urlencoded'
+          options[:body] = form_encode(options[:body])
+        end
+        response = super(options)
+        unless response.body.empty?
+          response.body = Fog::JSON.decode(response.body)
+        end
+        response
+      end
+
+      def auth_header
+        @auth_header ||= 'Basic ' + Base64.encode64("#{@user}:#{@password}").gsub("\n",'')
+      end
+
+      def form_encode(params)
+        params.reject {|k, v| v.nil? }.map {|pair| pair.map {|x| URI.escape(x.to_s) }.join('=') }.join('&')
+      end
+    end
+
+    class Mock
+      class << self
+
+        def id
+          Fog::Mock.random_numbers(7).to_i.to_s
+        end
+        alias :instance_id :id
+        alias :request_id  :id
+
+        def primary_ip
+          { "type" => 0, "ip" => Fog::IBM::Mock.ip_address, "hostname" => Fog::IBM::Mock.hostname }
+        end
+
+        def ip_address
+          ip = []
+          4.times do
+            ip << Fog::Mock.random_numbers(rand(3) + 1).to_i.to_s # remove leading 0
+          end
+          ip.join('.')
+        end
+
+        def hostname
+          "vhost" + Fog::Mock.random_numbers(3).to_i.to_s + ".fake.compute.ihost.com"
+        end
+
+        # Miliseconds since epoch
+        def launch_time
+          (Time.now.tv_sec * 1000).to_i
+        end
+
+        # 1 year from now, in miliseconds since epoch
+        def expiry_time
+          ((Time.now.tv_sec + 31556926) * 1000).to_i
+        end
+
+        def owner
+          "user" + Fog::Mock.random_numbers(3).to_i.to_s + "@company.com"
+        end
+
+        def key_material
+          OpenSSL::PKey::RSA.generate(1024)
+        end
+
+        def private_image(name, description)
+          {
+            "name"        => name,
+            "createdTime" => Fog::IBM::Mock.launch_time,
+            "productCodes"=> [],
+            "id"          => Fog::IBM::Mock.instance_id,
+            "description" => description,
+            "visibility"  => "PRIVATE",
+            "state"       => 0
+          }
+        end
+
+        def create_instance(name, image_id, instance_type, location, options)
+          {
+            "name"          => name,
+            "location"      => location,
+            "keyName"       => options[:key_name],
+            "primaryIP"     => Fog::IBM::Mock.primary_ip,
+            "productCodes"  => [],
+            "requestId"     => Fog::IBM::Mock.request_id,
+            "imageId"       => image_id,
+            "launchTime"    => Fog::IBM::Mock.launch_time,
+            "id"            => Fog::IBM::Mock.instance_id,
+            "volumes"       => [],
+            "isMiniEphemeral" => "false",
+            "instanceType"  => instance_type,
+            "diskSize"      => "60",
+            "requestName"   => "",
+            "secondaryIP"   => [],
+            "status"        => 1,
+            "software"      => [
+              { "name"=>"SUSE Linux Enterprise Server",
+                "type"=>"OS",
+                "version"=>"11 SP1" }
+            ],
+            "expirationTime"=> Fog::IBM::Mock.expiry_time,
+            "owner"         => Fog::IBM::Mock.owner
+          }
+        end
+
+        def create_volume(name, format, location_id, size, offering_id)
+          {
+            "instanceId"  => "0",
+            "state"       => 1,
+            "size"        => size,
+            "offeringId"  => offering_id,
+            "ioPrice" => {
+              "rate"  => 0.11,
+              "unitOfMeasure" => "CNT",
+              "countryCode"   => "897",
+              "effectiveDate" => Fog::IBM::Mock.launch_time,
+              "currencyCode"  => "USD",
+              "pricePerQuantity"  => 1
+            },
+            "owner"       => Fog::IBM::Mock.owner,
+            "createdTime" => Fog::IBM::Mock.launch_time,
+            "location"    => location_id,
+            "productCodes"=> [],
+            "format"      => format,
+            "name"        => name,
+            "id"          => Fog::IBM::Mock.id,
+          }
+        end
+
+        def create_address(location_id, offering_id, vlan_id)
+          # TODO: Figure out vlan handling
+          {
+            "id"        => Fog::IBM::Mock.id,
+            "location"  => location_id,
+            "offeringId"=> offering_id,
+            "ip"        => "",
+            "state"     => 0
+          }
+        end
+
+      end
+    end
+
+  end
+end

data/lib/fog/ibm/storage.rb

@@ -1,4 +1,4 @@
-require 'fog/ibm'
+require 'fog/ibm/core'
 require 'fog/storage'
 
 module Fog

data/lib/fog/internet_archive.rb

@@ -1,292 +1 @@
-require 'fog/core'
-require 'fog/internet_archive/signaturev4'
-
-module Fog
-  module InternetArchive
-
-    COMPLIANT_BUCKET_NAMES = /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\-(?![\.])){1,61}[a-z0-9]$/
-
-    DOMAIN_NAME = 'archive.org'
-
-    API_DOMAIN_NAME = 's3.us.' + DOMAIN_NAME
-
-    extend Fog::Provider
-
-    service(:storage, 'internet_archive/storage', 'Storage')
-
-    def self.indexed_param(key, values)
-      params = {}
-      unless key.include?('%d')
-        key << '.%d'
-      end
-      [*values].each_with_index do |value, index|
-        if value.respond_to?('keys')
-          k = format(key, index + 1)
-          value.each do | vkey, vvalue |
-            params["#{k}.#{vkey}"] = vvalue
-          end
-        else
-          params[format(key, index + 1)] = value
-        end
-      end
-      params
-    end
-
-    def self.serialize_keys(key, value, options = {})
-      case value
-      when Hash
-        value.each do | k, v |
-          options.merge!(serialize_keys("#{key}.#{k}", v))
-        end
-        return options
-      when Array
-        value.each_with_index do | it, idx |
-          options.merge!(serialize_keys("#{key}.member.#{(idx + 1)}", it))
-        end
-        return options
-      else
-        return {key => value}
-      end
-    end
-
-    def self.indexed_request_param(name, values)
-      idx = -1
-      Array(values).inject({}) do |params, value|
-        params["#{name}.#{idx += 1}"] = value
-        params
-      end
-    end
-
-    def self.indexed_filters(filters)
-      params = {}
-      filters.keys.each_with_index do |key, key_index|
-        key_index += 1
-        params[format('Filter.%d.Name', key_index)] = key
-        [*filters[key]].each_with_index do |value, value_index|
-          value_index += 1
-          params[format('Filter.%d.Value.%d', key_index, value_index)] = value
-        end
-      end
-      params
-    end
-
-    def self.escape(string)
-      string.gsub(/([^a-zA-Z0-9_.\-~]+)/) {
-        "%" + $1.unpack("H2" * $1.bytesize).join("%").upcase
-      }
-    end
-
-    def self.signed_params(params, options = {})
-      params.merge!({
-        'AWSAccessKeyId'    => options[:ia_access_key_id],
-        'SignatureMethod'   => 'HmacSHA256',
-        'SignatureVersion'  => '2',
-        'Timestamp'         => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
-        'Version'           => options[:version]
-      })
-
-      params.merge!({
-        'SecurityToken'     => options[:ia_session_token]
-      }) if options[:ia_session_token]
-
-      body = ''
-      for key in params.keys.sort
-        unless (value = params[key]).nil?
-          body << "#{key}=#{escape(value.to_s)}&"
-        end
-      end
-      string_to_sign = "POST\n#{options[:host]}:#{options[:port]}\n#{options[:path]}\n" << body.chop
-      signed_string = options[:hmac].sign(string_to_sign)
-      body << "Signature=#{escape(Base64.encode64(signed_string).chomp!)}"
-
-      body
-    end
-
-    class Mock
-
-      def self.arn(vendor, account_id, path, region = nil)
-        "arn:aws:#{vendor}:#{region}:#{account_id}:#{path}"
-      end
-
-      def self.availability_zone(region)
-        "#{region}#{Fog::Mock.random_selection('abcd', 1)}"
-      end
-
-      def self.box_usage
-        sprintf("%0.10f", rand / 100).to_f
-      end
-
-      def self.console_output
-        # "[ 0.000000] Linux version 2.6.18-xenU-ec2-v1.2 (root@domU-12-31-39-07-51-82) (gcc version 4.1.2 20070626 (Red Hat 4.1.2-13)) #2 SMP Wed Aug 19 09:04:38 EDT 2009"
-        Base64.decode64("WyAwLjAwMDAwMF0gTGludXggdmVyc2lvbiAyLjYuMTgteGVuVS1lYzItdjEu\nMiAocm9vdEBkb21VLTEyLTMxLTM5LTA3LTUxLTgyKSAoZ2NjIHZlcnNpb24g\nNC4xLjIgMjAwNzA2MjYgKFJlZCBIYXQgNC4xLjItMTMpKSAjMiBTTVAgV2Vk\nIEF1ZyAxOSAwOTowNDozOCBFRFQgMjAwOQ==\n")
-      end
-
-      def self.dns_name_for(ip_address)
-        "ec2-#{ip_address.gsub('.','-')}.compute-1.amazonaws.com"
-      end
-
-      def self.private_dns_name_for(ip_address)
-        "ip-#{ip_address.gsub('.','-')}.ec2.internal"
-      end
-
-      def self.image
-        path = []
-        (rand(3) + 2).times do
-          path << Fog::Mock.random_letters(rand(9) + 8)
-        end
-        {
-          "imageOwnerId"   => Fog::Mock.random_letters(rand(5) + 4),
-          "blockDeviceMapping" => [],
-          "productCodes"   => [],
-          "kernelId"       => kernel_id,
-          "ramdiskId"      => ramdisk_id,
-          "imageState"     => "available",
-          "imageId"        => image_id,
-          "architecture"   => "i386",
-          "isPublic"       => true,
-          "imageLocation"  => path.join('/'),
-          "imageType"      => "machine",
-          "rootDeviceType" => ["ebs","instance-store"][rand(2)],
-          "rootDeviceName" => "/dev/sda1"
-        }
-      end
-
-      def self.image_id
-        "ami-#{Fog::Mock.random_hex(8)}"
-      end
-
-      def self.key_fingerprint
-        fingerprint = []
-        20.times do
-          fingerprint << Fog::Mock.random_hex(2)
-        end
-        fingerprint.join(':')
-      end
-
-      def self.instance_id
-        "i-#{Fog::Mock.random_hex(8)}"
-      end
-
-      def self.ip_address
-        ip = []
-        4.times do
-          ip << Fog::Mock.random_numbers(rand(3) + 1).to_i.to_s # remove leading 0
-        end
-        ip.join('.')
-      end
-
-      def self.private_ip_address
-        ip_address.gsub(/^\d{1,3}\./,"10.")
-      end
-
-      def self.kernel_id
-        "aki-#{Fog::Mock.random_hex(8)}"
-      end
-
-      def self.key_material
-        OpenSSL::PKey::RSA.generate(1024).to_s
-      end
-
-      def self.owner_id
-        Fog::Mock.random_numbers(12)
-      end
-
-      def self.ramdisk_id
-        "ari-#{Fog::Mock.random_hex(8)}"
-      end
-
-      def self.request_id
-        request_id = []
-        request_id << Fog::Mock.random_hex(8)
-        3.times do
-          request_id << Fog::Mock.random_hex(4)
-        end
-        request_id << Fog::Mock.random_hex(12)
-        request_id.join('-')
-      end
-      class << self
-        alias :reserved_instances_id :request_id
-        alias :reserved_instances_offering_id :request_id
-        alias :sqs_message_id :request_id
-        alias :sqs_sender_id :request_id
-      end
-
-      def self.reservation_id
-        "r-#{Fog::Mock.random_hex(8)}"
-      end
-
-      def self.snapshot_id
-        "snap-#{Fog::Mock.random_hex(8)}"
-      end
-
-      def self.volume_id
-        "vol-#{Fog::Mock.random_hex(8)}"
-      end
-
-      def self.security_group_id
-        "sg-#{Fog::Mock.random_hex(8)}"
-      end
-
-      def self.network_interface_id
-        "eni-#{Fog::Mock.random_hex(8)}"
-      end
-      def self.internet_gateway_id
-        "igw-#{Fog::Mock.random_hex(8)}"
-      end
-      def self.dhcp_options_id
-        "dopt-#{Fog::Mock.random_hex(8)}"
-      end
-      def self.vpc_id
-        "vpc-#{Fog::Mock.random_hex(8)}"
-      end
-      def self.subnet_id
-        "subnet-#{Fog::Mock.random_hex(8)}"
-      end
-      def self.zone_id
-        "zone-#{Fog::Mock.random_hex(8)}"
-      end
-      def self.change_id
-        "change-#{Fog::Mock.random_hex(8)}"
-      end
-      def self.nameservers
-        [
-          'ns-2048.awsdns-64.com',
-          'ns-2049.awsdns-65.net',
-          'ns-2050.awsdns-66.org',
-          'ns-2051.awsdns-67.co.uk'
-        ]
-      end
-
-      def self.key_id(length=21)
-        #Probably close enough
-        Fog::Mock.random_selection('ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',length)
-      end
-
-      def self.rds_address(db_name,region)
-        "#{db_name}.#{Fog::Mock.random_letters(rand(12) + 4)}.#{region}.rds.amazonaws.com"
-      end
-    end
-
-    def self.parse_security_group_options(group_name, options)
-      options ||= Hash.new
-      if group_name.is_a?(Hash)
-        options = group_name
-      elsif group_name
-        if options.key?('GroupName')
-          raise Fog::Compute::InternetArchive::Error, 'Arguments specified both group_name and GroupName in options'
-        end
-        options = options.clone
-        options['GroupName'] = group_name
-      end
-      name_specified = options.key?('GroupName') && !options['GroupName'].nil?
-      group_id_specified = options.key?('GroupId') && !options['GroupId'].nil?
-      unless name_specified || group_id_specified
-        raise Fog::Compute::InternetArchive::Error, 'Neither GroupName nor GroupId specified'
-      end
-      if name_specified && group_id_specified
-        options.delete('GroupName')
-      end
-      options
-    end
-  end
-end
+require 'fog/internet_archive/storage'