fog 1.9.0 → 1.10.0

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/hp/models/block_storage/volume'
+
+module Fog
+  module HP
+    class BlockStorage
+
+      class Volumes < Fog::Collection
+
+        model Fog::HP::BlockStorage::Volume
+
+        def all
+          data = service.list_volumes.body['volumes']
+          load(data)
+        end
+
+        def get(volume_id)
+          volume = service.get_volume_details(volume_id).body['volume']
+          new(volume)
+        rescue Fog::HP::BlockStorage::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -20,7 +20,6 @@ module Fog
 
         def destroy
           requires :id
-
           service.release_address(id)
           true
         end

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

@@ -1,4 +1,5 @@
 require 'fog/core/model'
+require 'fog/openstack/models/compute/metadata'
 
 module Fog
   module Compute
@@ -13,15 +14,53 @@ module Fog
         attribute :updated_at,  :aliases => 'updated'
         attribute :progress
         attribute :status
-        attribute :minDisk,     :aliases => 'min_disk'
-        attribute :minRam,      :aliases => 'min_ram'
-        attribute :server,   :aliases => 'server'
+        attribute :server
         attribute :metadata
         attribute :links
 
+        # these values are extracted from metadata
+        attr_reader :min_disk
+        attr_reader :min_ram
+        attr_reader :image_type
+        attr_reader :architecture
+
+        def metadata
+          @metadata ||= begin
+            Fog::Compute::HP::Metadata.new({
+              :service => service,
+              :parent => self
+            })
+          end
+        end
+
+        def metadata=(new_metadata={})
+          metas = []
+          new_metadata.each_pair {|k,v| metas << {"key" => k, "value" => v} }
+          metadata.load(metas)
+        end
+
+        def min_disk
+          m = metadata.get("min_disk")
+          m.value unless m.nil?
+        end
+
+        def min_ram
+          m = metadata.get("min_ram")
+          m.value unless m.nil?
+        end
+
+        def image_type
+          m = metadata.get("image_type")
+          m.value unless m.nil?
+        end
+
+        def architecture
+          m = metadata.get("architecture")
+          m.value unless m.nil?
+        end
+
         def destroy
           requires :id
-
           service.delete_image(id)
           true
         end

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

@@ -9,14 +9,9 @@ module Fog
 
         model Fog::Compute::HP::Image
 
-        attribute :server
-
         def all
           data = service.list_images_detail.body['images']
           load(data)
-          if server
-            self.replace(self.select {|image| image.server.id == server.id})
-          end
           self
         end
 

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

@@ -13,18 +13,14 @@ module Fog
         attribute :private_key
         attribute :user_id
 
-        attr_accessor :public_key
-
         def destroy
           requires :name
-
           service.delete_key_pair(name)
           true
         end
 
         def save
           requires :name
-
           data = if public_key
             service.create_key_pair(name, public_key).body['keypair']
           else
@@ -36,7 +32,6 @@ module Fog
         end
 
         def write(path="#{ENV['HOME']}/.ssh/hp_#{Fog.credential.to_s}_#{name}.pem")
-
           if writable?
             split_private_key = private_key.split(/\n/)
             File.open(path, "w") do |f|

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

@@ -0,0 +1,29 @@
+require 'fog/core/model'
+require 'fog/hp/models/meta_parent'
+
+module Fog
+  module Compute
+    class HP
+      class Meta < Fog::Model
+
+        include Fog::Compute::HP::MetaParent
+
+        identity :key
+        attribute :value
+
+        def destroy
+          requires :identity
+          service.delete_meta(collection_name, @parent.id, key)
+          true
+        end
+
+        def save
+          requires :identity, :value
+          service.update_meta(collection_name, @parent.id, key, value)
+          true
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'fog/core/collection'
+require 'fog/hp/models/meta_parent'
+require 'fog/hp/models/compute/meta'
+require 'fog/hp/models/compute/image'
+require 'fog/hp/models/compute/server'
+
+module Fog
+  module Compute
+    class HP
+
+      class Metadata < Fog::Collection
+
+        model Fog::Compute::HP::Meta
+
+        include Fog::Compute::HP::MetaParent
+
+        def all
+          requires :parent
+          if @parent.id
+            metadata = service.list_metadata(collection_name, @parent.id).body['metadata']
+            metas = []
+            metadata.each_pair {|k,v| metas << {"key" => k, "value" => v} }
+            load(metas)
+          end
+        end
+
+        def destroy(key)
+          requires :parent
+          service.delete_meta(collection_name, @parent.id, key)
+        rescue Fog::Compute::HP::NotFound
+          nil
+        end
+
+        def get(key)
+          requires :parent
+          data = service.get_meta(collection_name, @parent.id, key).body["meta"]
+          metas = []
+          data.each_pair {|k,v| metas << {"key" => k, "value" => v} }
+          new(metas[0])
+        rescue Fog::Compute::HP::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :parent
+          super({ :parent => @parent }.merge!(attributes))
+        end
+
+        def set(data=nil)
+          requires :parent
+          service.set_metadata(collection_name, @parent.id, meta_hash(data))
+        end
+
+        def update(data=nil)
+          requires :parent
+          service.update_metadata(collection_name, @parent.id, meta_hash(data))
+        end
+
+
+        private
+        def meta_hash(data=nil)
+          if data.nil?
+            data={}
+            self.each do |meta|
+              if meta.is_a?(Fog::Compute::HP::Meta) then
+                data.store(meta.key, meta.value)
+              else
+                data.store(meta["key"], meta["value"])
+              end
+            end
+          end
+          data
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require 'fog/compute/models/server'
+require 'fog/hp/models/compute/metadata'
 
 module Fog
   module Compute
@@ -24,6 +25,8 @@ module Fog
         attribute :tenant_id
         attribute :user_id
         attribute :key_name
+        attribute :security_groups
+        attribute :config_drive
         # these are implemented as methods
         attribute :image_id
         attribute :flavor_id
@@ -31,25 +34,42 @@ module Fog
         attribute :public_ip_address
 
         attr_reader :password
-        attr_writer :image_id, :flavor_id
+        attr_writer :private_key, :private_key_path
+        attr_writer :public_key, :public_key_path
+        attr_writer :username, :image_id, :flavor_id, :network_name
 
         def initialize(attributes = {})
-          # assign these attributes first to prevent race condition with persisted?
-          self.security_groups = attributes.delete(:security_groups)
+          # assign these attributes first to prevent race condition with new_record?
           self.min_count = attributes.delete(:min_count)
           self.max_count = attributes.delete(:max_count)
+          self.block_device_mapping = attributes.delete(:block_device_mapping)
           super
         end
 
-        def destroy
+        def console_output(num_lines)
           requires :id
-          service.delete_server(id)
-          true
+          service.get_console_output(id, num_lines)
         end
 
-        def images
+        def metadata
+          @metadata ||= begin
+            Fog::Compute::HP::Metadata.new({
+              :service => service,
+              :parent => self
+            })
+          end
+        end
+
+        def metadata=(new_metadata={})
+          metas = []
+          new_metadata.each_pair {|k,v| metas << {"key" => k, "value" => v} }
+          metadata.load(metas)
+        end
+
+        def destroy
           requires :id
-          service.images(:server => self)
+          service.delete_server(id)
+          true
         end
 
         def key_pair
@@ -62,16 +82,29 @@ module Fog
           self.key_name = new_keypair && new_keypair.name
         end
 
+        def network_name
+          @network_name ||= "private"
+        end
+
         def private_ip_address
-          addr = addresses.nil? ? nil : addresses.fetch('private', []).first
+          addr = addresses.nil? ? nil : addresses.fetch(network_name, []).first
           addr["addr"] if addr
         end
 
+        def private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+          @private_key_path &&= File.expand_path(@private_key_path)
+        end
+
+        def private_key
+          @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('private', [])
+            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"]
@@ -83,6 +116,15 @@ module Fog
           end
         end
 
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+          @public_key_path &&= File.expand_path(@public_key_path)
+        end
+
+        def public_key
+          @public_key ||= public_key_path && File.read(public_key_path)
+        end
+
         def image_id
           @image_id ||= (image.nil? ? nil : image["id"])
         end
@@ -107,12 +149,8 @@ module Fog
           @max_count = new_max_count
         end
 
-        def security_groups=(new_security_groups)
-          @security_groups = new_security_groups
-        end
-
-        def security_groups
-          @security_groups
+        def block_device_mapping=(new_block_device_mapping)
+          @block_device_mapping = new_block_device_mapping
         end
 
         def ready?
@@ -125,6 +163,11 @@ module Fog
           true
         end
 
+        def windows_password()
+          requires :id
+          service.get_windows_password(id)
+        end
+
         def reboot(type = 'SOFT')
           requires :id
           service.reboot_server(id, type)
@@ -160,21 +203,38 @@ module Fog
           service.create_image(id, name, metadata)
         end
 
+        def volume_attachments
+          requires :id
+          if vols = service.list_server_volumes(id).body
+            vols["volumeAttachments"]
+          end
+        end
+
         def save
           raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
-          requires :flavor_id, :image_id, :name
+          requires :flavor_id, :name
+          meta_hash = {}
+          metadata.each { |meta| meta_hash.store(meta.key, meta.value) }
           options = {
-            'metadata'    => metadata,
+            'metadata'    => meta_hash,
             'personality' => personality,
             'accessIPv4'  => accessIPv4,
             'accessIPv6'  => accessIPv6,
             'min_count'   => @min_count,
             'max_count'   => @max_count,
             'key_name'    => key_name,
-            'security_groups' => @security_groups
+            'security_groups' => security_groups,
+            'config_drive'    => config_drive
           }
           options = options.reject {|key, value| value.nil?}
-          data = service.create_server(name, flavor_id, image_id, options)
+          # either create a regular server or a persistent server based on input
+          if image_id
+            # create a regular server using the image
+            data = service.create_server(name, flavor_id, image_id, options)
+          elsif image_id.nil? && !@block_device_mapping.nil? && !@block_device_mapping.empty?
+            # create a persistent server using the bootable volume in the block_device_mapping
+            data = service.create_persistent_server(name, flavor_id, @block_device_mapping, options)
+          end
           merge_attributes(data.body['server'])
           true
         end
@@ -193,6 +253,10 @@ module Fog
           retry
         end
 
+        def username
+          @username ||= 'root'
+        end
+
         private
 
         def adminPass=(new_admin_pass)

data/lib/fog/hp/models/meta_parent.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class HP
+      module MetaParent
+
+        def parent
+          @parent
+        end
+
+        def parent=(new_parent)
+          @parent = new_parent
+        end
+
+        def collection_name
+          if @parent.class == Fog::Compute::HP::Image
+            return "images"
+          elsif @parent.class == Fog::Compute::HP::Server
+            return "servers"
+          else
+            raise "Metadata is not supported for this model type."
+          end
+        end
+
+        def metas_to_hash(metas)
+          hash = {}
+          metas.each { |meta| hash.store(meta.key, meta.value) }
+          hash
+        end
+
+      end
+    end
+  end
+end