fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

data/lib/fog/hp/models/block_storage_v2/snapshots.rb

@@ -0,0 +1,43 @@
+require 'fog/core/collection'
+require 'fog/hp/models/block_storage_v2/snapshot'
+
+module Fog
+  module HP
+    class BlockStorageV2
+
+      class Snapshots < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::BlockStorageV2::Snapshot
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          details = filters.delete(:details)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          if details
+            data = service.list_snapshots_detail(non_aliased_filters).body['snapshots']
+          else
+            data = service.list_snapshots(non_aliased_filters).body['snapshots']
+          end
+          load(data)
+        end
+
+        def get(snapshot_id)
+          if snapshot = service.get_snapshot_details(snapshot_id).body['snapshot']
+            new(snapshot)
+          end
+        rescue Fog::HP::BlockStorageV2::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/block_storage_v2/volume.rb

@@ -0,0 +1,139 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class BlockStorageV2
+
+      class Volume < Fog::Model
+
+        identity  :id
+
+        attribute :name,                 :aliases => 'display_name'
+        attribute :description,          :aliases => 'display_description'
+        attribute :size
+        attribute :status
+        attribute :type,                 :aliases => 'volume_type'
+        attribute :created_at
+        attribute :availability_zone
+        attribute :snapshot_id
+        attribute :source_volid
+        attribute :attachments
+        attribute :metadata
+        attribute :bootable
+        attribute :image_metadata,       :aliases => 'volume_image_metadata'
+
+        def initialize(attributes = {})
+          # assign these attributes first to prevent race condition with new_record?
+          self.image_id = attributes.delete(:image_id)
+          super
+        end
+
+        # a volume can be attached to only one server at a time
+        def device
+          attachments[0]['device'] if has_attachments?
+        end
+
+        # a volume can be attached to only one server at a time
+        def server_id
+          attachments[0]['server_id'] if has_attachments?
+        end
+
+        # used for creating bootable volumes
+        def image_id=(new_image_id)
+          @image_id = new_image_id
+        end
+
+        def image_id
+          @image_id = image_metadata['image_id'] if image_metadata
+        end
+
+        # a volume can be attached to only one server at a time
+        def has_attachments?
+          !(attachments.nil? || attachments.empty? || attachments[0].empty?)
+        end
+
+        def in_use?
+          self.status == 'in-use'
+        end
+        alias :attached? :in_use?
+
+        def backing_up?
+          self.status == 'backing-up'
+        end
+
+        def restoring?
+          self.status == 'restoring-backup'
+        end
+
+        def ready?
+          self.status == 'available'
+        end
+
+        # volume can be attached to only one server at a time
+        def attach(new_server_id, device)
+          requires :id
+          unless in_use?
+            data = service.compute.attach_volume(new_server_id, id, device)
+            merge_attributes(:attachments => attachments << data.body['volumeAttachment'])
+            true
+          else
+            false
+          end
+        end
+
+        def detach
+          requires :id
+          if has_attachments?
+            service.compute.detach_volume(self.server_id, id)
+          end
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_volume(id)
+          true
+        end
+
+        def save
+          identity ? update : create
+        end
+
+        private
+
+        def create
+          options = {
+            'display_name'        => name,
+            'display_description' => description,
+            'size'                => size,
+            'metadata'            => metadata,
+            'snapshot_id'         => snapshot_id,
+            'imageRef'            => @image_id,
+            'availability_zone'   => availability_zone,
+            'source_volid'        => source_volid,
+            'volume_type'         => type                 # this parameter is currently ignored
+          }
+          options = options.reject {|_, value| value.nil?}
+          data = service.create_volume(options)
+          merge_attributes(data.body['volume'])
+          true
+        end
+
+        def update
+          requires :id
+          options = {
+            'display_name'        => name,
+            'display_description' => description,
+            'metadata'            => metadata
+          }
+          options = options.reject {|_, value| value.nil?}
+          data = service.update_volume(id, options)
+          merge_attributes(data.body['volume'])
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/block_storage_v2/volume_backup.rb

@@ -0,0 +1,58 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class BlockStorageV2
+
+      class VolumeBackup < Fog::Model
+
+        identity  :id
+
+        attribute :name
+        attribute :description
+        attribute :size
+        attribute :status
+        attribute :created_at
+        attribute :availability_zone
+        attribute :volume_id
+        attribute :container
+        attribute :fail_reason
+        attribute :object_count
+        attribute :links
+
+        def restoring?
+          self.status == 'restoring'
+        end
+
+        def ready?
+          self.status == 'available'
+        end
+
+        def restore(volume_id=nil)
+          requires :id
+          if volume_id
+            service.restore_volume_backup(id, :volume_id => volume_id)
+          else
+            service.restore_volume_backup(id)
+          end
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_volume_backup(id)
+          true
+        end
+
+        def save
+          requires :volume_id
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          merge_attributes(service.create_volume_backup(volume_id, attributes).body['backup'])
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/block_storage_v2/volume_backups.rb

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/hp/models/block_storage_v2/volume_backup'
+
+module Fog
+  module HP
+    class BlockStorageV2
+
+      class VolumeBackups < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::BlockStorageV2::VolumeBackup
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          details = filters.delete(:details)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          if details
+            data = service.list_volume_backups_detail(non_aliased_filters).body['backups']
+          else
+            data = service.list_volume_backups(non_aliased_filters).body['backups']
+          end
+          load(data)
+        end
+
+        def get(backup_id)
+          backup = service.get_volume_backup_details(backup_id).body['backup']
+          new(backup)
+        rescue Fog::HP::BlockStorageV2::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/block_storage_v2/volumes.rb

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/hp/models/block_storage_v2/volume'
+
+module Fog
+  module HP
+    class BlockStorageV2
+
+      class Volumes < Fog::Collection
+
+        attribute :filters
+
+        model Fog::HP::BlockStorageV2::Volume
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          details = filters.delete(:details)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          if details
+            data = service.list_volumes_detail(non_aliased_filters).body['volumes']
+          else
+            data = service.list_volumes(non_aliased_filters).body['volumes']
+          end
+          load(data)
+        end
+
+        def get(volume_id)
+          volume = service.get_volume_details(volume_id).body['volume']
+          new(volume)
+        rescue Fog::HP::BlockStorageV2::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 require 'fog/core/model'
-require 'fog/openstack/models/compute/metadata'
+require 'fog/hp/models/compute/metadata'
 
 module Fog
   module Compute

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

@@ -47,11 +47,6 @@ module Fog
           super
         end
 
-        def console_output(num_lines)
-          requires :id
-          service.get_console_output(id, num_lines)
-        end
-
         def metadata
           @metadata ||= begin
             Fog::Compute::HP::Metadata.new({
@@ -71,6 +66,20 @@ module Fog
           self.user_data_encoded = [ascii_userdata].pack('m')  # same as Base64.encode64
         end
 
+        def console_output(num_lines)
+          requires :id
+          service.get_console_output(id, num_lines)
+        end
+
+        def vnc_console_url(type='novnc')
+          requires :id
+          if resp = service.get_vnc_console(id, type).body
+            resp['console']['url']
+          else
+            nil
+          end
+        end
+
         def destroy
           requires :id
           service.delete_server(id)
@@ -91,9 +100,18 @@ module Fog
           @network_name ||= "private"
         end
 
+        def private_ip_addresses
+          return nil if addresses.nil?
+          addr = []
+          addresses.each { |key, value|
+            ipaddr = value.first
+            addr << ipaddr["addr"] unless ipaddr.nil?
+          }
+          addr
+        end
+
         def private_ip_address
-          addr = addresses.nil? ? nil : addresses.fetch(network_name, []).first
-          addr["addr"] if addr
+          private_ip_addresses.first
         end
 
         def private_key_path
@@ -105,20 +123,23 @@ module Fog
           @private_key ||= private_key_path && File.read(private_key_path)
         end
 
-        def public_ip_address
-          # FIX: Both the private and public ips are bundled under "private" network name
-          # So hack to get to the public ip address
-          if !addresses.nil?
-            addr = addresses.fetch(network_name, [])
-            # if we have more than 1 address, then the return the second address which is public
-            if addr.count > 1
-              addr[1]["addr"]
-            else
-              nil
+        def public_ip_addresses
+          return nil if addresses.nil?
+          addr = []
+          addresses.each { |key, value|
+            if value.count > 1
+              value = value.dup
+              value.delete_at(0)
+              value.each { |ipaddr|
+                addr << ipaddr["addr"]
+              }
             end
-          else
-            nil
-          end
+          }
+          addr
+        end
+
+        def public_ip_address
+          public_ip_addresses.first
         end
 
         def public_key_path

data/lib/fog/hp/models/compute_v2/address.rb

@@ -0,0 +1,70 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Address < Fog::Model
+
+        identity  :id
+
+        attribute :ip
+        attribute :fixed_ip
+        attribute :instance_id
+
+        def initialize(attributes = {})
+          # assign server first to prevent race condition with persisted?
+          self.server = attributes.delete(:server)
+          super
+        end
+
+        def destroy
+          requires :id
+          service.release_address(id)
+          true
+        end
+
+        def server=(new_server)
+          if new_server
+            associate(new_server)
+          else
+            disassociate
+          end
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          data = service.allocate_address.body['floating_ip']
+          new_attributes = data.reject {|key,value| !['id', 'instance_id', 'ip', 'fixed_ip'].include?(key)}
+          merge_attributes(new_attributes)
+          if @server
+            self.server = @server
+          end
+          true
+        end
+
+        private
+
+        def associate(new_server)
+          unless persisted?
+            @server = new_server
+          else
+            @server = nil
+            self.instance_id = new_server.id
+            service.associate_address(instance_id, ip)
+          end
+        end
+
+        def disassociate
+          @server = nil
+          if persisted?
+            service.disassociate_address(instance_id, ip)
+          end
+          self.instance_id = nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/compute_v2/addresses.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/hp/models/compute_v2/address'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Addresses < Fog::Collection
+
+        model Fog::Compute::HPV2::Address
+
+        def all
+          data = service.list_addresses.body['floating_ips']
+          load(data)
+        end
+
+        def get(address_id)
+          if address = service.get_address(address_id).body['floating_ip']
+            new(address)
+          end
+        rescue Fog::Compute::HPV2::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/compute_v2/availability_zone.rb

@@ -0,0 +1,22 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class AvailabilityZone < Fog::Model
+
+        identity :name, :aliases => 'zoneName'
+
+        attribute   :zoneState
+        attribute   :hosts
+
+        def available?
+          zoneState['available']
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/compute_v2/availability_zones.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/hp/models/compute_v2/availability_zone'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class AvailabilityZones < Fog::Collection
+
+        model Fog::Compute::HPV2::AvailabilityZone
+
+        def all
+          data = service.list_availability_zones.body['availabilityZoneInfo']
+          load(data)
+        end
+
+        def get(zone_name)
+          if zone_name
+            self.all.select {|z| z.name == zone_name}.first
+          end
+        rescue Fog::Compute::HPV2::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/compute_v2/flavor.rb

@@ -0,0 +1,22 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute   :name
+        attribute   :disk
+        attribute   :ram
+        attribute   :cores, :aliases => 'vcpus'
+        attribute   :ephemeral_disk, :aliases => 'OS-FLV-EXT-DATA:ephemeral'
+        attribute   :links
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/compute_v2/flavors.rb

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/hp/models/compute_v2/flavor'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Flavors < Fog::Collection
+
+        attribute :filters
+
+        model Fog::Compute::HPV2::Flavor
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          details = filters.delete(:details)
+          self.filters = filters
+          non_aliased_filters = Fog::HP.convert_aliased_attributes_to_original(self.model, filters)
+          if details
+            data = service.list_flavors_detail(non_aliased_filters).body['flavors']
+          else
+            data = service.list_flavors(non_aliased_filters).body['flavors']
+          end
+          load(data)
+        end
+
+        def get(flavor_id)
+          data = service.get_flavor_details(flavor_id).body['flavor']
+          new(data)
+        rescue Fog::Compute::HPV2::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end