fog 1.2.0 → 1.3.0

data/lib/fog/ibm/models/compute/servers.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/compute/server'
+
+module Fog
+  module Compute
+    class IBM
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::IBM::Server
+
+        def all
+          load(connection.list_instances.body['instances'])
+        end
+
+        def get(server_id)
+          begin
+            new(connection.get_instance(server_id).body)
+          rescue Fog::Compute::IBM::NotFound
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/models/storage/offering.rb

@@ -0,0 +1,18 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class IBM
+      class Offering < Fog::Model
+        identity :id
+        attribute :location
+        attribute :name
+        attribute :label
+        attribute :capacity
+        attribute :supported_sizes, :aliases => 'supportedSizes'
+        attribute :supported_formats, :aliases => 'formats'
+        attribute :price
+      end
+    end
+  end
+end

data/lib/fog/ibm/models/storage/offerings.rb

@@ -0,0 +1,19 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/storage/offering'
+
+module Fog
+  module Storage
+    class IBM
+
+      class Offerings < Fog::Collection
+
+        model Fog::Storage::IBM::Offering
+
+        def all
+          load(connection.list_offerings.body['volumes'])
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/models/storage/volume.rb

@@ -0,0 +1,95 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class IBM
+      class Volume < Fog::Model
+
+        STATUS = [
+          "New",              # => 0
+          "Creating",         # => 1
+          "Deleting",         # => 2
+          "Deleted",          # => 3
+          "Detached",         # => 4
+          "Attached",         # => 5
+          "Failed",           # => 6
+          "Deletion pending", # => 7
+          "Being cloned",     # => 8
+          "Cloning",          # => 9
+          "Attaching",        # => 10
+          "Detaching",        # => 11
+          "Copying",          # => 12
+          "Importing",        # => 13
+          "Transfer retrying" # => 14
+        ]
+
+        identity :id
+
+        attribute :instance_id,   :aliases => "instanceId"
+        attribute :io_price,      :aliases => "ioPrice"
+        attribute :name
+        attribute :state
+        attribute :size
+        attribute :offering_id,   :aliases => "offeringId"
+        attribute :owner
+        attribute :created_at,    :aliases => "createdTime"
+        attribute :location_id,   :aliases => "location"
+        attribute :product_codes, :aliases => "productCodes"
+        attribute :format
+
+        def attached?
+          status == "Attached"
+        end
+
+        def attach(instance_id)
+          requires :id
+          connection.attach_volume(instance_id, id).body['success']
+        end
+
+        def detach(instance_id)
+          requires :id
+          connection.detach_volume(instance_id, id).body['success']
+        end
+
+        def created_at
+          Time.at(attributes[:created_at].to_f / 1000)
+        end
+
+        def destroy
+          requires :id
+          connection.delete_volume(id)
+          true
+        end
+
+        def instance
+          return nil if instance_id.nil? || instance_id == "0" || instance_id == ""
+          Fog::Compute[:ibm].servers.get(instance_id)
+        end
+
+        def location
+          requires :location_id
+          Fog::Compute[:ibm].locations.get(location_id)
+        end
+
+        # Are we ready to be attached to an instance?
+        def ready?
+          # TODO: Not sure if this is the only status we should be matching.
+          status == "Detached"
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :name, :offering_id, :format, :location_id, :size
+          data = connection.create_volume(name, offering_id, format, location_id, size)
+          merge_attributes(data.body)
+          true
+        end
+
+        def status
+          STATUS[attributes[:state].to_i]
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/models/storage/volumes.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/storage/volume'
+
+module Fog
+  module Storage
+    class IBM
+
+      class Volumes < Fog::Collection
+
+        model Fog::Storage::IBM::Volume
+
+        def all
+          load(connection.list_volumes.body['volumes'])
+        end
+
+        def get(volume_id)
+          begin
+            new(connection.get_volume(volume_id).body)
+          rescue Fog::Storage::IBM::NotFound
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/requests/compute/clone_image.rb

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+
+        # Clones image specified by image_id
+        #
+        # ==== Parameters
+        # * image_id<~String> - id of image to be cloned
+        # * name<~String> - name of new image
+        # * description<~String> - description of new image
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ImageID'<~String>: id of new image
+        def clone_image(image_id, name, description)
+          request(
+            :method   => 'POST',
+            :expects  => 200,
+            :path     => "/offerings/image/#{image_id}",
+            :body     => {
+              'name' => name,
+              'description' => description
+            }
+          )
+        end
+
+      end
+      class Mock
+
+        def clone_image(image_id, name, description)
+          response = Excon::Response.new
+          if image_exists? image_id
+            id = Fog::IBM::Mock.instance_id
+            self.data[:images][id] = self.data[:images][image_id].dup
+            response.status = 200
+            response.body   = { "ImageID" => id }
+          else
+            response.status = 404
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/requests/compute/create_address.rb

@@ -0,0 +1,50 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+
+        # Requests a new static IP address to be created
+        #
+        # ==== Parameters
+        # * location_id<~String> - id of location
+        # * offering_id<~String> - id for offering
+        # * vlan_id<~String> - id of vlan
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'location'<~String>: location of new address
+        #     * 'offeringId'<~String>: offering id of new address
+        #     * 'id'<~String>: id
+        #     * 'ip'<~String>: returns string of spaces (ip not yet allocated right after creation)
+        #     * 'state'<~Integer>: status of address (0 when new)
+        def create_address(location, offering_id, options={})
+          request(
+            :method   => 'POST',
+            :expects  => 200,
+            :path     => '/addresses',
+            :body     => {
+              'offeringID' => offering_id,
+              'location'   => location,
+              'vlanID'     => options[:vlan_id]
+            }
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_address(location_id, offering_id="20001223", options={})
+          address         = Fog::IBM::Mock.create_address(location_id, offering_id, options)
+          self.data[:addresses][address['id']] = address
+          response        = Excon::Response.new
+          response.status = 200
+          response.body   = address
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/requests/compute/create_image.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+
+        # Requests an image to be created from an Instance
+        #
+        # ==== Parameters
+        # * instance_id<~String> - id of instance to save
+        # * name<~String> - name of image to be created
+        # * description<~String> - description of image to be created
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'name'<~String>: name of new image
+        #     * 'createdTime'<~Integer>: epoch time at creation
+        #     * 'productCodes'<~Array>:
+        #     * 'id'<~String>: id of new image
+        #     * 'description'<~String>: description
+        #     * 'visibility'<~String>: visibility level ("PRIVATE", etc)
+        #     * 'state'<~Integer>: status of image
+        def create_image(instance_id, name, description)
+          request(
+            :method   => 'PUT',
+            :expects  => 200,
+            :path     => "/instances/#{instance_id}",
+            :body     => {
+              'state'       => 'save',
+              'name'        => name,
+              'description' => description
+            }
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_image(instance_id, name, description)
+          response = Excon::Response.new
+          if instance_exists? instance_id
+            image = Fog::IBM::Mock.private_image(name, description)
+            self.data[:images][image["id"]] = image
+            response.status = 200
+            response.body = image
+          else
+            response.status = 404
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/requests/compute/create_instance.rb

@@ -0,0 +1,80 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+
+        # Requests a new Instance to be created.
+        #
+        # ==== Parameters
+        # * name<~String> - The alias to use to reference this instance
+        # * image_id<~String> - The id of the image to create this instance from
+        # * instance_type<~String> - The instance type to use for this instance
+        # * location<~String> - The id of the Location where this instance will be created
+        # * options<~Hash>:
+        #   * :key_name<~String> - The public key to use for accessing the created instance
+        #   * :ip<~String> - The ID of a static IP address to associate with this instance
+        #   * :volume_id<~String> - The ID of a storage volume to associate with this instance
+        #   * :vlan_id<~String> - The ID of a Vlan offering to associate with this instance.
+        #   * :secondary_ip<~String> - The ID of a static IP address to associate with this instance as secondary IP
+        #   * :is_mini_ephermal<~Boolean> - Whether or not the instance should be provisioned with the root segment only
+        #   * :configuration_data<~Hash> - Arbitrary name/value pairs defined by the image being created
+        #   * :anti_collocation_instance<~String> - The ID of an existing anti-collocated instance.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'name'<~String>: instance name
+        #     * 'location'<~String>: instance location id
+        #     * 'keyName'<~String>: instance assigned keypair
+        #     * 'primaryIP'<~Hash>: assigned ip address, type, and hostname
+        #     * 'productCodes'<~Array>: associated product codes
+        #     * 'requestId'<~String>:
+        #     * 'imageId'<~String>:
+        #     * 'launchTime'<~Integer>: epoch time in ms representing when the instance was launched
+        def create_instance(name, image_id, instance_type, location, options={})
+          request(
+            :method   => 'POST',
+            :expects  => 200,
+            :path     => '/instances',
+            :body     => {
+              'name'                    => name,
+              'imageID'                 => image_id,
+              'instanceType'            => instance_type,
+              'location'                => location,
+              'publicKey'               => options[:key_name],
+              'ip'                      => options[:ip],
+              'volumeID'                => options[:volume_id],
+              'vlanID'                  => options[:vlan_id],
+              'SecondaryIP'             => options[:secondary_ip],
+              'isMiniEphemermal'        => options[:is_mini_ephemeral],
+              'Configuration Data'      => options[:configuration_data],
+              'antiCollocationInstance' => options[:anti_collocation_instance],
+            }
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_instance(name, image_id, instance_type, location, options={})
+          response = Excon::Response.new
+          # Since we want to test error conditions, we have a little regex that traps specially formed
+          # instance type strings.
+          case name
+          when /FAIL:\ (\d{3})/
+            response.status = $1.to_i
+            raise Excon::Errors.status_error({:expects => 200}, response)
+          else
+            instance = Fog::IBM::Mock.create_instance(name, image_id, instance_type, location, options)
+            self.data[:instances][instance['id']] = instance
+            response.status = 200
+            response.body = {"instances" => [ instance ]}
+            response
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/requests/compute/create_key.rb

@@ -0,0 +1,61 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+
+        # Requests a new keypair to be created
+        #
+        # ==== Parameters
+        # * name<~String> - name to give new key
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'keyName'<~String>: name of new key
+        #     * 'lastModifiedTime'<~Integer>: epoch time of last modification
+        #     * 'default'<~Bool>: is default?
+        #     * 'instanceIds'<~Array>: id's of instances using key (should be empty upon creation)
+        #     * 'keyMaterial'<~String>: private key contents
+        def create_key(name, public_key=nil)
+          request(
+            :method   => 'POST',
+            :expects  => 200,
+            :path     => '/keys',
+            :body => {
+              'name' => name,
+              'publicKey' => public_key
+            }
+          )
+        end
+
+      end
+
+      class Mock
+
+        # SmartCloud returns the private key when create_key is called
+        # We need to store both the private and public key for later use
+        def create_key(name, public_key=nil)
+          response = Excon::Response.new
+          response.status = 200
+          attributes  = {
+            "keyName"           => name,
+            "lastModifiedTime"  => Fog::IBM::Mock.launch_time,
+            "default"           => false,
+            "instanceIds"       => [],
+          }
+          if public_key.nil?
+            private_key   = Fog::IBM::Mock.key_material
+            public_key    = private_key.public_key
+            response.body = attributes.merge("keyMaterial" => private_key.to_s)
+          else
+            response.body = { 'success' => true }
+          end
+          self.data[:keys][name] = attributes.merge("keyMaterial" => public_key.to_s)
+          self.data[:private_keys][name] = attributes.merge("keyMaterial" => private_key.to_s)
+          response
+        end
+
+      end
+    end
+  end
+end