fog 1.2.0 → 1.3.0

data/lib/fog/ibm/requests/storage/list_volumes.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Storage
+    class IBM
+      class Real
+
+        # Returns the list of storage volumes
+        #
+        # ==== Parameters
+        # No parameters
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'volumes'<~Array>: list of images
+        #       * 'name'<~String>: Name of image
+        #       * 'format'<~String>: filesystem volume is formatted with
+        #       * 'location'<~String>: datacenter location string
+        #       * 'createdTime'<~Integer>: creation time in Epoch int
+        #       * 'size'<~String>: size in GB's (as a string)
+        #       * 'productCodes'<~Array>: unsure..
+        #       * 'offeringId'<~String>:
+        #       * 'id'<~String>: volume id
+        #       * 'owner'<~String>: owner's email address
+        #       * 'state'<~Integer>: known so far: 4 provisioned, unattached; 5 provisioned, attached
+        def list_volumes
+          request(
+            :method   => 'GET',
+            :expects  => 200,
+            :path     => '/storage'
+          )
+        end
+
+      end
+
+      class Mock
+
+        def list_volumes
+          response = Excon::Response.new
+          response.status = 200
+          response.body = { 'volumes' => format_list_volumes_response }
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/storage.rb

@@ -0,0 +1,82 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'ibm'))
+require 'fog/storage'
+
+module Fog
+  module Storage
+    class IBM < Fog::Service
+
+      requires :ibm_username, :ibm_password
+      recognizes :location
+
+      model_path 'fog/ibm/models/storage'
+
+      model :offering
+      collection :offerings
+      model :volume
+      collection :volumes
+
+      request_path 'fog/ibm/requests/storage'
+
+      request :list_offerings
+
+      request :list_volumes
+      request :create_volume
+      request :delete_volume
+      request :get_volume
+
+      class Real
+        def initialize(options={})
+          @connection = Fog::IBM::Connection.new(options[:ibm_username], options[:ibm_password])
+        end
+
+        private
+
+        def request(options)
+          begin
+            @connection.request(options)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Storage::IBM::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+        end
+
+      end
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :volumes      => {},
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def data
+          self.class.data[@ibm_username]
+        end
+
+        def reset_data
+          self.class.data.delete(@ibm_username)
+          @data = self.class.data[@ibm_username]
+        end
+
+        def initialize(options={})
+          @ibm_username = options[:ibm_username]
+          @ibm_password = options[:ibm_password]
+          @data = self.class.data[@ibm_username]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/ovirt/compute.rb

@@ -36,6 +36,7 @@ module Fog
       request :list_vm_interfaces
       request :list_template_interfaces
       request :list_networks
+      request :vm_ticket
 
       module Shared
         # converts an OVIRT object into an hash for fog to consume.

data/lib/fog/ovirt/models/compute/server.rb

@@ -92,6 +92,11 @@ module Fog
           connection.destroy_vm(:id => id)
         end
 
+        def ticket(options = {})
+          raise "Can not set console ticket, Server is not ready. Server status: #{status}" unless ready?
+          connection.vm_ticket(id, options)
+        end
+
         def save
           if identity
             connection.update_vm(attributes)

data/lib/fog/ovirt/requests/compute/vm_ticket.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Compute
+    class Ovirt
+      class Real
+
+        def vm_ticket(id, options = {})
+          client.set_ticket(id, options)
+        end
+
+      end
+
+      class Mock
+
+        def vm_ticket(id, options = {})
+          "Secret"
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/providers.rb

@@ -10,6 +10,7 @@ require 'fog/ecloud'
 require 'fog/glesys'
 require 'fog/go_grid'
 require 'fog/google'
+require 'fog/ibm'
 require 'fog/joyent'
 require 'fog/libvirt'
 require 'fog/linode'

data/lib/fog/storage.rb

@@ -14,6 +14,9 @@ module Fog
       when :google
         require 'fog/google/storage'
         Fog::Storage::Google.new(attributes)
+      when :ibm
+        require 'fog/ibm/storage'
+        Fog::Storage::IBM.new(attributes)
       when :local
         require 'fog/local/storage'
         Fog::Storage::Local.new(attributes)

data/tests/aws/requests/compute/security_group_tests.rb

@@ -1,4 +1,9 @@
 Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
+  @create_security_group_format = {
+    'requestId' => String,
+    'groupId'   => String,
+    'return'    => Fog::Boolean
+  }
 
   @security_groups_format = {
     'requestId'           => String,
@@ -8,7 +13,7 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
       'groupName'         => String,
       'ipPermissions'     => [{
         'fromPort'    => Fog::Nullable::Integer,
-        'groups'      => [{ 'groupName' => Fog::Nullable::String, 'userId' => String }],
+        'groups'      => [{ 'groupName' => Fog::Nullable::String, 'userId' => String, 'groupId' => String }],
         'ipProtocol'  => String,
         'ipRanges'    => [],
         'toPort'      => Fog::Nullable::Integer,
@@ -20,17 +25,17 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
   }
 
   @owner_id = Fog::Compute[:aws].describe_security_groups('group-name' => 'default').body['securityGroupInfo'].first['ownerId']
+  @group_id_default = Fog::Compute[:aws].describe_security_groups('group-name' => 'default').body['securityGroupInfo'].first['groupId']
 
   tests('success') do
 
-    tests("#create_security_group('fog_security_group', 'tests group')").formats(AWS::Compute::Formats::BASIC) do
+    tests("#create_security_group('fog_security_group', 'tests group')").formats(@create_security_group_format) do
       Fog::Compute[:aws].create_security_group('fog_security_group', 'tests group').body
     end
-
-    tests("#create_security_group('fog_security_group_two', 'tests group')").formats(AWS::Compute::Formats::BASIC) do
+    tests("#create_security_group('fog_security_group_two', 'tests group')").formats(@create_security_group_format) do
       Fog::Compute[:aws].create_security_group('fog_security_group_two', 'tests group').body
     end
-
+    @group_id_two = Fog::Compute[:aws].describe_security_groups('group-name' => 'fog_security_group_two').body['securityGroupInfo'].first['groupId']
     group_id = Fog::Compute[:aws].describe_security_groups('group-name' => 'fog_security_group').body['securityGroupInfo'].first['groupId']
     to_be_revoked = []
     expected_permissions = []
@@ -43,17 +48,17 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
     to_be_revoked.push([permission, expected_permissions.dup])
 
     expected_permissions = [
-      {"groups"=>[{"groupName"=>"default", "userId"=>@owner_id}],
+      {"groups"=>[{"groupName"=>"default", "userId"=>@owner_id, "groupId"=>@group_id_default}],
         "fromPort"=>1,
         "ipRanges"=>[],
         "ipProtocol"=>"tcp",
         "toPort"=>65535},
-      {"groups"=>[{"groupName"=>"default", "userId"=>@owner_id}],
+      {"groups"=>[{"groupName"=>"default", "userId"=>@owner_id, "groupId"=>@group_id_default}],
         "fromPort"=>1,
         "ipRanges"=>[],
         "ipProtocol"=>"udp",
         "toPort"=>65535},
-      {"groups"=>[{"groupName"=>"default", "userId"=>@owner_id}],
+      {"groups"=>[{"groupName"=>"default", "userId"=>@owner_id, "groupId"=>@group_id_default}],
         "fromPort"=>-1,
         "ipRanges"=>[],
         "ipProtocol"=>"icmp",
@@ -77,22 +82,22 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
 
     expected_permissions = [
       {"groups"=>
-        [{"userId"=>@owner_id, "groupName"=>"default"},
-          {"userId"=>@owner_id, "groupName"=>"fog_security_group_two"}],
+        [{"userId"=>@owner_id, "groupName"=>"default", "groupId"=>@group_id_default},
+          {"userId"=>@owner_id, "groupName"=>"fog_security_group_two", "groupId"=>@group_id_two}],
         "ipRanges"=>[],
         "ipProtocol"=>"tcp",
         "fromPort"=>1,
         "toPort"=>65535},
       {"groups"=>
-        [{"userId"=>@owner_id, "groupName"=>"default"},
-          {"userId"=>@owner_id, "groupName"=>"fog_security_group_two"}],
+        [{"userId"=>@owner_id, "groupName"=>"default", "groupId"=>@group_id_default},
+          {"userId"=>@owner_id, "groupName"=>"fog_security_group_two", "groupId"=>@group_id_two}],
         "ipRanges"=>[],
         "ipProtocol"=>"udp",
         "fromPort"=>1,
         "toPort"=>65535},
       {"groups"=>
-        [{"userId"=>@owner_id, "groupName"=>"default"},
-          {"userId"=>@owner_id, "groupName"=>"fog_security_group_two"}],
+        [{"userId"=>@owner_id, "groupName"=>"default", "groupId"=>@group_id_default},
+          {"userId"=>@owner_id, "groupName"=>"fog_security_group_two", "groupId"=>@group_id_two}],
         "ipRanges"=>[],
         "ipProtocol"=>"icmp",
         "fromPort"=>-1,
@@ -194,13 +199,12 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
     to_be_revoked.push([permissions, expected_permissions.dup])
 
     expected_permissions += [
-      {"groups"=>[{"userId"=>@owner_id, "groupName"=>"fog_security_group_two"}],
+      {"groups"=>[{"userId"=>@owner_id, "groupName"=>"fog_security_group_two", "groupId"=>@group_id_two}],
         "ipRanges"=>[],
         "ipProtocol"=>"tcp",
         "fromPort"=>8000,
         "toPort"=>8000}
     ]
-
     tests("#describe_security_groups('group-name' => 'fog_security_group')").returns([]) do
       array_differences(expected_permissions, Fog::Compute[:aws].describe_security_groups('group-name' => 'fog_security_group').body['securityGroupInfo'].first['ipPermissions'])
     end
@@ -224,7 +228,7 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
 
     expected_permissions += [
       {"groups"=>
-        [{"userId"=>@owner_id, "groupName"=>"fog_security_group_two"}],
+        [{"userId"=>@owner_id, "groupName"=>"fog_security_group_two", "groupId"=>@group_id_two}],
         "ipRanges"=>[{"cidrIp"=>"172.16.0.0/24"}],
         "ipProtocol"=>"tcp",
         "fromPort"=>9000,
@@ -264,38 +268,28 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
     vpc_id = Fog::Compute[:aws].create_vpc('10.255.254.64/28').body['vpcSet'].first['vpcId']
 
     # Create security group in VPC
-    tests("#create_security_group('vpc_security_group', 'tests group')").formats(AWS::Compute::Formats::BASIC) do
+    tests("#create_security_group('vpc_security_group', 'tests group')").formats(@create_security_group_format) do
       Fog::Compute[:aws].create_security_group('vpc_security_group', 'tests group', vpc_id).body
     end
 
     group_id = Fog::Compute[:aws].describe_security_groups('group-name' => 'vpc_security_group').body['securityGroupInfo'].first['groupId']
     
-    # Access group with name in options array
-    permission = { 'IpProtocol' => '42', 'FromPort' => '22', 'ToPort' => '22', 'CidrIp' => '10.0.0.0/8' }
+    permissions = {
+      'IpPermissions' => [
+        {
+          'IpProtocol' => '42',
+          'IpRanges' => [{ 'CidrIp' => '10.0.0.0/8' }],
+        }
+      ]
+    }
+
     expected_permissions = [
       {"groups"=>[],
         "ipRanges"=>[{"cidrIp"=>"10.0.0.0/8"}],
-        "ipProtocol"=>"42",
-        "fromPort"=>22,
-        "toPort"=>22}
+        "ipProtocol"=>"42"}
     ]
 
-    options = permission.clone
-    options['GroupName'] = 'vpc_security_group'
-    tests("#authorize_security_group_ingress(#{options.inspect})").formats(AWS::Compute::Formats::BASIC) do
-      Fog::Compute[:aws].authorize_security_group_ingress(options).body
-    end
-
-    tests("#describe_security_groups('group-name' => 'vpc_security_group')").returns([]) do
-      array_differences(expected_permissions, Fog::Compute[:aws].describe_security_groups('group-name' => 'vpc_security_group').body['securityGroupInfo'].first['ipPermissions'])
-    end
-
-    tests("#revoke_security_group_ingress(#{options.inspect})").formats(AWS::Compute::Formats::BASIC) do
-      Fog::Compute[:aws].revoke_security_group_ingress(options).body
-    end
-
-    # Access group with id in options array
-    options = permission.clone
+    options = permissions.clone
     options['GroupId'] = group_id
     tests("#authorize_security_group_ingress(#{options.inspect})").formats(AWS::Compute::Formats::BASIC) do
       Fog::Compute[:aws].authorize_security_group_ingress(options).body
@@ -309,9 +303,13 @@ Shindo.tests('Fog::Compute[:aws] | security group requests', ['aws']) do
       Fog::Compute[:aws].revoke_security_group_ingress(options).body
     end
 
+    vpc_group=Fog::Compute[:aws].security_groups.get_by_id(group_id)
+    vpc_group.destroy
+
     Fog::Compute[:aws].delete_vpc(vpc_id)
 
   end
+  ## Rate limiting seems to want us to take a break otherwise it will throw errors
   tests('failure') do
 
     @security_group = Fog::Compute[:aws].security_groups.create(:description => 'tests group', :name => 'fog_security_group')

data/tests/compute/helper.rb

@@ -22,6 +22,10 @@ def compute_providers
     :glesys   => {
       :mocked => false
     },
+    :ibm => {
+      :server_attributes => {},
+      :mocked => true
+    },
     :joyent => {
       :mocked => false
     },

data/tests/compute/models/flavors_tests.rb

@@ -1,6 +1,6 @@
 for provider, config in compute_providers
 
-  next if [:glesys, :voxel].include?(provider)
+  next if [:glesys, :voxel, :ibm].include?(provider)
 
   Shindo.tests("Fog::Compute[:#{provider}] | flavors", [provider]) do
 

data/tests/helper.rb

@@ -12,7 +12,7 @@ def array_differences(array_a, array_b)
 end
 
 # check to see which credentials are available and add others to the skipped tags list
-all_providers = ['aws', 'bluebox', 'brightbox', 'dnsimple', 'dnsmadeeasy', 'dynect', 'ecloud', 'glesys', 'gogrid', 'google', 'joyent', 'linode', 'local', 'ninefold', 'baremetalcloud', 'openstack', 'ovirt', 'rackspace', 'slicehost', 'stormondemand', 'voxel', 'vsphere', 'zerigo']
+all_providers = ['aws', 'bluebox', 'brightbox', 'dnsimple', 'dnsmadeeasy', 'dynect', 'ecloud', 'glesys', 'gogrid', 'google', 'ibm', 'joyent', 'linode', 'local', 'ninefold', 'baremetalcloud', 'openstack', 'ovirt', 'rackspace', 'slicehost', 'stormondemand', 'voxel', 'vsphere', 'zerigo']
 available_providers = Fog.available_providers.map {|provider| provider.downcase}
 for provider in (all_providers - available_providers)
   Formatador.display_line("[yellow]Skipping tests for [bold]#{provider}[/] [yellow]due to lacking credentials (add some to '~/.fog' to run them)[/]")

data/tests/helpers/mock_helper.rb

@@ -30,6 +30,8 @@ if Fog.mock?
     :go_grid_shared_secret            => 'go_grid_shared_secret',
     :google_storage_access_key_id     => 'google_storage_access_key_id',
     :google_storage_secret_access_key => 'google_storage_secret_access_key',
+    :ibm_username                     => 'ibm_username',
+    :ibm_password                     => 'ibm_password',
     :joyent_username                  => "joyentuser",
     :joyent_password                  => "joyentpass",
     :linode_api_key                   => 'linode_api_key',

data/tests/ibm/models/compute/image_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests('Fog::Compute[:ibm] | image', ['ibm']) do
+
+  @image_id = '20010001'
+  @image    = Fog::Compute[:ibm].images.get(@image_id)
+
+  tests('success') do
+
+  end
+
+end

data/tests/ibm/models/compute/key_tests.rb

@@ -0,0 +1,23 @@
+Shindo.tests('Fog::Compute[:ibm] | key', ['ibm']) do
+
+  tests('success') do
+
+    @key_name = 'fog-test-key-' + Time.now.to_i.to_s(32)
+    @key      = nil
+
+    tests("Fog::Compute::IBM::Key.create(:name => '#{@key_name}')") do
+      @key = Fog::Compute[:ibm].keys.create(:name => @key_name)
+      returns(@key_name) { @key.name }
+    end
+
+    tests("Fog::Compute::IBM::Key#instances") do
+      returns([]) { @key.instances }
+    end
+
+    tests('Fog::Compute::IBM::Key#destroy') do
+      returns(true) { @key.destroy }
+    end
+
+  end
+
+end