fog 1.2.0 → 1.3.0

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/compute/address'
+
+module Fog
+  module Compute
+    class IBM
+
+      class Addresses < Fog::Collection
+
+        model Fog::Compute::IBM::Address
+
+        def all
+          load(connection.list_addresses.body['addresses'])
+        end
+
+        def get(address_id)
+          begin
+            address = connection.list_addresses.body
+            new(address['addresses'].find{|address| address['id'] == address_id.to_s })
+          rescue Fog::Compute::IBM::NotFound
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'fog/core/model'
+require 'fog/ibm/models/compute/instance-types'
+
+module Fog
+  module Compute
+    class IBM
+      class Image < Fog::Model
+
+        STATES = {
+          0 => 'New',
+          1 => 'Available',
+          2 => 'Unavailable',
+          3 => 'Deleted',
+          4 => 'Capturing',
+          5 => 'Importing',
+          6 => 'Copying',
+          7 => 'Failed',
+        }
+
+        identity :id
+
+        attribute :architecture
+        attribute :created_at, :aliases => 'createdTime'
+        attribute :description
+        attribute :documentation
+        attribute :location
+        attribute :manifest
+        attribute :name
+        attribute :owner
+        attribute :platform
+        attribute :product_codes, :aliases => 'productCodes'
+        attribute :state
+        attribute :supported_instance_types, :aliases => 'supportedInstanceTypes'
+        attribute :visibility
+
+        attribute :volume_id
+
+        def initialize(new_attributes = {})
+          super(new_attributes)
+          attributes[:supported_instance_types] = Fog::Compute::IBM::InstanceTypes.new.load(attributes[:supported_instance_types]) if attributes[:supported_instance_types]
+        end
+
+        def save
+          requires :id, :volume_id
+          data = connection.create_image(id, volume_id)
+          merge_attributes(data.body)
+          data.body['success']
+        end
+
+        def state
+          STATES[attributes[:state]]
+        end
+
+        def ready?
+          state == 'Available'
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/compute/image'
+
+module Fog
+  module Compute
+    class IBM
+
+      class Images < Fog::Collection
+
+        model Fog::Compute::IBM::Image
+
+        def all
+          load(connection.list_images.body['images'])
+        end
+
+        def get(image_id)
+          begin
+            new(connection.get_image(image_id).body)
+          rescue Fog::Compute::IBM::NotFound
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/ibm/models/compute/instance-type.rb

@@ -0,0 +1,14 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class IBM
+      class InstanceType < Fog::Model
+        identity :id
+        attribute :detail
+        attribute :label
+        attribute :price
+      end
+    end
+  end
+end

data/lib/fog/ibm/models/compute/instance-types.rb

@@ -0,0 +1,15 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/compute/instance-type'
+
+module Fog
+  module Compute
+    class IBM
+
+      class InstanceTypes < Fog::Collection
+
+        model Fog::Compute::IBM::InstanceType
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class IBM
+      class Key < Fog::Model
+        identity :name, :aliases => 'keyName'
+        attribute :default
+        attribute :public_key, :aliases => 'keyMaterial'
+        attribute :instance_ids, :aliases => 'instanceIds'
+        attribute :modified_at, :aliases => 'lastModifiedTime'
+
+        def save
+          requires :name
+          data = connection.create_key(name, public_key)
+          merge_attributes(data.body)
+          data.body['keyName'] == name
+        end
+
+        def destroy
+          data = connection.delete_key(identity)
+          data.body['success']
+        end
+
+        def default?
+          default
+        end
+
+        def instances
+          instance_ids.map { Fog::Compute[:ibm].servers.get(instance_id) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/compute/key'
+
+module Fog
+  module Compute
+    class IBM
+
+      class Keys < Fog::Collection
+
+        model Fog::Compute::IBM::Key
+
+        def all
+          load(connection.list_keys.body['keys'])
+        end
+
+        def get(key_id)
+          begin
+            new(connection.get_key(key_id).body)
+          rescue Fog::Compute::IBM::NotFound
+            nil
+          end
+        end
+
+        def default
+          find {|key| key.default? }
+        end
+
+        def default=(key_name)
+          connection.modify_key(key_name, 'default' => true)
+        end
+
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/ibm/models/compute/location'
+
+module Fog
+  module Compute
+    class IBM
+
+      class Locations < Fog::Collection
+
+        model Fog::Compute::IBM::Location
+
+        def all
+          load(connection.list_locations.body['locations'])
+        end
+
+        def get(location_id)
+          begin
+            new(connection.get_location(location_id).body)
+          rescue Fog::Compute::IBM::NotFound
+            nil
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class IBM
+
+      class Server < Fog::Compute::Server
+
+        STATES = [
+          "New",            # => 0
+          "Provisioning",   # => 1
+          "Failed",         # => 2
+          "Removed",        # => 3
+          "Rejected",       # => 4
+          "Active",         # => 5
+          "Unknown",        # => 6
+          "Deprovisioning", # => 7
+          "Restarting",     # => 8
+          "Starting",       # => 9
+          "Stopping",       # => 10
+          "Stopped",        # => 11
+          "Deprovisioning pending", # => 12
+          "Restart pending",# => 13
+          "Attaching",      # => 14
+          "Detaching"       # => 15
+        ]
+
+        identity :id
+
+        attribute :disk_size, :aliases => 'diskSize'
+        attribute :expires_at, :aliases => 'expirationTime'
+        attribute :image_id, :aliases => 'imageId'
+        attribute :instance_type, :aliases => 'instanceType'
+        attribute :ip
+        attribute :key_name, :aliases => 'keyName'
+        attribute :launched_at, :aliases => 'launchTime'
+        attribute :location_id, :aliases => 'location'
+        attribute :name
+        attribute :owner
+        attribute :primary_ip, :aliases => 'primaryIP'
+        attribute :product_codes, :aliases => 'productCodes'
+        attribute :request_id, :aliases => 'requestId'
+        attribute :request_name, :aliases => 'requestName'
+        attribute :is_mini_ephemeral, :aliases => 'isMiniEphemeral'
+        attribute :secondary_ip, :aliases => 'secondaryIP'
+        attribute :software
+        attribute :state, :aliases => 'status'
+        attribute :volume_ids, :aliases => 'volumes'
+        attribute :vlan_id, :aliases => 'vlanID'
+
+        def initialize(new_attributes={})
+          super(new_attributes)
+          self.name ||= 'fog-instance'
+          self.image_id ||= '20010001'
+          self.location_id ||= '41'
+          self.instance_type ||= 'COP32.1/2048/60'
+          self.key_name ||= 'fog'
+        end
+
+        def save
+          requires :name, :image_id, :instance_type, :location_id
+          data = connection.create_instance(name, image_id, instance_type, location_id,
+                                            :key_name => key_name,
+                                            :vlan_id => vlan_id,
+                                            :secondary_ip => secondary_ip)
+          data.body['instances'].each do |iattrs|
+            if iattrs['name'] == name
+              merge_attributes(iattrs)
+              return true
+            end
+          end
+          false
+        end
+
+        def state
+          STATES[attributes[:state].to_i]
+        end
+
+        def ready?
+          state == "Active"
+        end
+
+        def reboot
+          requires :id
+          connection.modify_instance(id, 'state' => 'restart').body['success']
+        end
+
+        def destroy
+          requires :id
+          connection.delete_instance(id).body['success']
+        end
+
+        def rename(name)
+          requires :id
+          if connection.modify_instance(id, 'name' => name).body["success"]
+            attributes[:name] = name
+          else
+            return false
+          end
+          true
+        end
+
+        def allocate_ip(wait_for_ready=true)
+          requires :location_id
+          new_ip = connection.addresses.new(:location => location_id)
+          new_ip.save
+          new_ip.wait_for(Fog::IBM::TIMEOUT) { ready? } if wait_for_ready
+          secondary_ip << new_ip
+          new_ip
+        end
+
+        def addresses
+          addys = secondary_ip.map {|ip| Fog::Compute[:ibm].addresses.new(ip) }
+          # Set an ID, in case someone tries to save
+          addys << connection.addresses.new(attributes[:primary_ip].merge(
+            :id => "0",
+            :location => location_id,
+            :state => 3
+          ))
+          addys
+        end
+
+        def attach(volume_id)
+          requires :id
+          data = connection.modify_instance(id, {'type' => 'attach', 'storageId' => volume_id})
+          data.body
+        end
+
+        def detach(volume_id)
+          requires :id
+          data = connection.modify_instance(id, {'type' => 'detach', 'storageId' => volume_id})
+          data.body
+        end
+
+        def launched_at
+          Time.at(attributes[:launched_at].to_f / 1000)
+        end
+
+        def expires_at
+          Time.at(attributes[:expires_at].to_f / 1000)
+        end
+
+        # Sets expiration time - Pass an instance of Time.
+        def expire_at(time)
+          expiry_time = (time.tv_sec * 1000).to_i
+          data = connection.modify_instance(id, 'expirationTime' => expiry_time)
+          if data.body['expirationTime'] == expiry_time
+            attributes[:expires_at] = expiry_time
+            true
+          else
+            false
+          end
+        end
+
+        # Expires the instance immediately
+        def expire!
+          expire_at(Time.now + 5)
+        end
+
+        def image
+          requires :image_id
+          connection.images.get(image_id)
+        end
+
+        def location
+          requires :location_id
+          connection.locations.get(location_id)
+        end
+
+        def public_hostname
+          primary_ip ? primary_ip['hostname'] : nil
+        end
+
+        def public_ip_address
+          primary_ip ? primary_ip['ip'] : nil
+        end
+
+        # Creates an image from the current instance
+        # if name isn't passed then we'll take the current name and timestamp it
+        def to_image(opts={})
+         options = {
+           :name => name + " as of " + Time.now.strftime("%Y-%m-%d %H:%M"),
+           :description => ""
+         }.merge(opts)
+         connection.create_image(id, options[:name], options[:description]).body
+        end
+        alias :create_image :to_image
+      end
+
+    end
+  end
+
+end