ns-fog 1.22.2

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

@@ -0,0 +1,24 @@
+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(service.list_instances.body['instances'])
+        end
+
+        def get(server_id)
+          begin
+            new(service.get_instance(server_id).body)
+          rescue Fog::Compute::IBM::NotFound
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class IBM
+      class Vlan < Fog::Model
+        identity :id
+        attribute :name
+        attribute :location
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/compute/vlan'
+
+module Fog
+  module Compute
+    class IBM
+      class Vlans < Fog::Collection
+        model Fog::Compute::IBM::Vlan
+
+        def all
+          load(service.list_vlans.body['vlan'])
+        end
+
+        def get(vlan_id)
+          begin
+            vlan = service.list_vlans.body
+            new(vlan['vlan'].find{|vlan| vlan['id'] == vlan_id.to_s })
+          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,16 @@
+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(service.list_offerings.body['volumes'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class IBM
+      class Volume < Fog::Model
+        STATES = {
+          0  => 'New',
+          1  => 'Creating',
+          2  => 'Deleting',
+          3  => 'Deleted',
+          4  => 'Detached',
+          5  => 'Attached',
+          6  => 'Failed',
+          7  => 'Deletion pending',
+          8  => 'Being cloned',
+          9  => 'Cloning',
+          10 => 'Attaching',
+          11 => 'Detaching',
+          12 => 'Copying',
+          13 => 'Importing',
+          14 => 'Transfer retrying',
+        }
+
+        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
+        attribute :storage_area,     :aliases => 'storageArea'
+        attribute :platform_version, :aliases => 'platformVersion'
+        attribute :clone_status,     :aliases => 'cloneStatus'
+
+        def attached?
+          state == "Attached"
+        end
+
+        def attach(instance_id)
+          requires :id
+          service.attach_volume(instance_id, id).body['success']
+        end
+
+        def detach(instance_id)
+          requires :id
+          service.detach_volume(instance_id, id).body['success']
+        end
+
+        def created_at
+          Time.at(attributes[:created_at].to_f / 1000)
+        end
+
+        def destroy
+          requires :id
+          service.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 state we should be matching.
+          state == "Detached"
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :name, :offering_id, :format, :location_id, :size
+          data = service.create_volume(name, offering_id, format, location_id, size)
+          merge_attributes(data.body)
+          true
+        end
+
+        def state
+          STATES[attributes[:state]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+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(service.list_volumes.body['volumes'])
+        end
+
+        def get(volume_id)
+          begin
+            new(service.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,44 @@
+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].merge('id' => id, 'name' => name, 'description' => description)
+            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,46 @@
+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,52 @@
+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,81 @@
+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> - Comma separated list of static IP IDs to associate with this instance.
+        #   * :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={})
+          body_data     = {
+            '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],
+            'isMiniEphemeral'        => options[:is_mini_ephemeral],
+            'Configuration Data'      => options[:configuration_data],
+            'antiCollocationInstance' => options[:anti_collocation_instance]
+          }
+          if options[:secondary_ip]
+            options[:secondary_ip].split(',').map(&:strip).each_with_index do |n, idx|
+              body_data.merge!({"secondary.ip.#{idx}" => n})
+            end
+          end
+          request(
+            :method   => 'POST',
+            :expects  => 200,
+            :path     => '/instances',
+            :body     => body_data
+          )
+        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,57 @@
+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

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

@@ -0,0 +1,42 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+        # Deletes the Address that the authenticated user manages with the specified :address_id
+        #
+        # ==== Parameters
+        # * address_id<~String> - Id of address
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     *'success'<~Bool>: true or false for success
+        def delete_address(address_id)
+          request(
+            :method   => 'DELETE',
+            :expects  => 200,
+            :path     => "/addresses/#{address_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_address(address_id)
+          response = Excon::Response.new
+          if address_exists? address_id
+            self.data[:addresses].delete address_id
+            response.status = 200
+            response.body = { "success" => true }
+          else
+            response.status = 404
+          end
+          response
+        end
+
+        def address_exists?(address_id)
+          self.data[:addresses].key? address_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+        # Deletes the image that the authenticated user manages with the specified :image_id
+        #
+        # ==== Parameters
+        # * image_id<~String> - Id of image
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     *'success'<~Bool>: true or false for success
+        def delete_image(image_id)
+          request(
+            :method   => 'DELETE',
+            :expects  => 200,
+            :path     => "/offerings/image/#{image_id}"
+          )
+        end
+      end
+      class Mock
+        def delete_image(image_id)
+          response = Excon::Response.new
+          # TODO: We should probably check that an image is deleteable.
+          # i.e. that the user has appropriate permissions
+          if image_exists? image_id
+            self.data[:images].delete image_id
+            response.status = 200
+            response.body = {"success"=>true}
+          else
+            response.status = 404
+          end
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+        # Deletes the Instance that the authenticated user manages with the specified :instance_id
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Id of instance
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     *'success'<~Bool>: true or false for success
+        def delete_instance(instance_id)
+          request(
+            :method   => 'DELETE',
+            :expects  => 200,
+            :path     => "/instances/#{instance_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_instance(instance_id)
+          response = Excon::Response.new
+          if deleteable? instance_id
+            # remove from memoreeeez.
+            self.data[:instances].delete instance_id
+            response.body = { 'success' => true }
+            response.status = 200
+          else
+            # TODO: we should really return a 412 if the instance is in an invalid state, and a 404 if it doesn't exist.
+            response.status = 404
+          end
+          response
+        end
+
+        # we can't delete the instance if it doesn't exist, or is in an invalid state.
+        def deleteable?(instance_id)
+          return false unless instance_exists? instance_id
+          instance = self.data[:instances][instance_id]
+          return false if [0, 1, 7, 14, 15].include?(instance["status"].to_i)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Fog
+  module Compute
+    class IBM
+      class Real
+        # Deletes the key specified with key_name
+        #
+        # ==== Parameters
+        # * key_name<~String> - name of key to be deleted
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     *'success'<~Bool>: true or false for success
+        def delete_key(key_name)
+          request(
+            :method   => 'DELETE',
+            :expects  => 200,
+            :path     => "/keys/#{key_name}"
+          )
+        end
+      end
+      class Mock
+        def delete_key(key_name)
+          response = Excon::Response.new
+          if key_exists? key_name
+            self.data[:keys].delete(key_name)
+            response.status = 200
+            response.body = {"success"=>true}
+          else
+            response.status = 404
+          end
+          response
+        end
+      end
+    end
+  end
+end