fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

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

@@ -0,0 +1,87 @@
+require 'fog/core/model'
+require 'fog/hp/models/compute_v2/metadata'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Image < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :created_at,  :aliases => 'created'
+        attribute :updated_at,  :aliases => 'updated'
+        attribute :progress
+        attribute :status
+        attribute :server
+        attribute :links
+        #attribute :metadata        # lazy load metadata as needed per model
+
+        def metadata
+          @metadata ||= begin
+            Fog::Compute::HPV2::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.delete_image(id)
+          true
+        end
+
+        def ready?
+          status == 'ACTIVE'
+        end
+
+        # The following are built-in metadata for each image, exposed as helpers
+        def bootable_volume?
+          m = @metadata.detect {|md| md.key == 'com.hp__1__bootable_volume'}
+          m.value unless m.nil?
+        end
+
+        def provider
+          m = @metadata.detect {|md| md.key == 'com.hp__1__provider'}
+          m.value unless m.nil?
+        end
+
+        def os_distro
+          m = @metadata.detect {|md| md.key == 'com.hp__1__os_distro'}
+          m.value unless m.nil?
+        end
+
+        def os_version
+          m = @metadata.detect {|md| md.key == 'com.hp__1__os_version'}
+          m.value unless m.nil?
+        end
+
+        def license
+          m = @metadata.detect {|md| md.key == 'hp_image_license'}
+          m.value unless m.nil?
+        end
+
+        def type
+          m = @metadata.detect {|md| md.key == 'com.hp__1__image_type'}
+          m.value unless m.nil?
+        end
+
+        def architecture
+          m = @metadata.detect {|md| md.key == 'architecture'}
+          m.value unless m.nil?
+        end
+
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'fog/core/collection'
+require 'fog/hp/models/compute_v2/image'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Images < Fog::Collection
+
+        attribute :filters
+
+        model Fog::Compute::HPV2::Image
+
+        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_images_detail(non_aliased_filters).body['images']
+          else
+            data = service.list_images(non_aliased_filters).body['images']
+          end
+          load(data)
+          self
+        end
+
+        def get(image_id)
+          data = service.get_image_details(image_id).body['image']
+          new(data)
+        rescue Fog::Compute::HPV2::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class KeyPair < Fog::Model
+
+        identity  :name
+
+        attribute :fingerprint
+        attribute :public_key
+        attribute :private_key
+        attribute :user_id
+
+        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
+            service.create_key_pair(name).body['keypair']
+          end
+          new_attributes = data.reject {|key,value| !['fingerprint', 'public_key', 'name', 'private_key', 'user_id'].include?(key)}
+          merge_attributes(new_attributes)
+          true
+        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|
+              split_private_key.each {|line| f.puts line}
+              f.chmod 0600
+            end
+            "Key file built: #{path}"
+          else
+            'Invalid private key'
+          end
+        end
+
+        def writable?
+          !!(private_key && ENV.has_key?('HOME'))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/hp/models/compute_v2/key_pair'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class KeyPairs < Fog::Collection
+
+        model Fog::Compute::HPV2::KeyPair
+
+        def all
+          items = []
+          service.list_key_pairs.body['keypairs'].each do |kp|
+            items = items + kp.map { |_, value| value }
+          end
+          load(items)
+        end
+
+        def get(key_pair_name)
+          if key_pair_name
+            self.all.select {|kp| kp.name == key_pair_name}.first
+          end
+        rescue Fog::Compute::HPV2::NotFound
+          nil
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/model'
+require 'fog/hp/models/compute_v2/meta_parent'
+
+module Fog
+  module Compute
+    class HPV2
+      class Meta < Fog::Model
+
+        include Fog::Compute::HPV2::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_v2/meta_parent.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class HPV2
+      module MetaParent
+
+        def parent
+          @parent
+        end
+
+        def parent=(new_parent)
+          @parent = new_parent
+        end
+
+        def collection_name
+          if @parent.class == Fog::Compute::HPV2::Image
+            return 'images'
+          elsif @parent.class == Fog::Compute::HPV2::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

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

@@ -0,0 +1,79 @@
+require 'fog/core/collection'
+require 'fog/hp/models/compute_v2/meta_parent'
+require 'fog/hp/models/compute_v2/meta'
+require 'fog/hp/models/compute_v2/image'
+require 'fog/hp/models/compute_v2/server'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Metadata < Fog::Collection
+
+        model Fog::Compute::HPV2::Meta
+
+        include Fog::Compute::HPV2::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::HPV2::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::HPV2::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::HPV2::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_v2/server.rb

@@ -0,0 +1,339 @@
+require 'fog/compute/models/server'
+require 'fog/hp/models/compute_v2/metadata'
+
+module Fog
+  module Compute
+    class HPV2
+
+      class Server < Fog::Compute::Server
+
+        identity  :id
+
+        attribute :addresses
+        attribute :host_id,     :aliases => 'hostId'
+        attribute :name
+        attribute :personality
+        attribute :progress
+        attribute :accessIPv4
+        attribute :accessIPv6
+        attribute :state,       :aliases => 'status'
+        attribute :created_at,  :aliases => 'created'
+        attribute :updated_at,  :aliases => 'updated'
+        attribute :tenant_id
+        attribute :user_id
+        attribute :key_name
+        attribute :security_groups
+        attribute :config_drive
+        attribute :user_data_encoded
+        attribute :availability_zone, :aliases => 'OS-EXT-AZ:availability_zone'
+        attribute :power_state,       :aliases => 'OS-EXT-STS:power_state'
+        attribute :task_state,        :aliases => 'OS-EXT-STS:task_state'
+        attribute :vm_state,          :aliases => 'OS-EXT-STS:vm_state'
+        attribute :links
+        attribute :image_id,          :aliases => 'image', :squash => 'id'
+        attribute :flavor_id,         :aliases => 'flavor', :squash => 'id'
+        #attribute :metadata        # lazy load metadata as needed per model
+        # these are implemented as methods
+        attribute :private_ip_address
+        attribute :public_ip_address
+
+        attr_reader :password
+        attr_writer :private_key, :private_key_path
+        attr_writer :public_key, :public_key_path
+        attr_writer :username, :network_name
+
+        def initialize(attributes = {})
+          # 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)
+          self.networks = attributes.delete(:networks)
+          super
+        end
+
+        def metadata
+          @metadata ||= begin
+            Fog::Compute::HPV2::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 user_data=(ascii_userdata)
+          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)
+          true
+        end
+
+        def key_pair
+          requires :key_name
+
+          service.key_pairs.get(key_name)
+        end
+
+        def key_pair=(new_keypair)
+          self.key_name = new_keypair && new_keypair.name
+        end
+
+        def network_name
+          @network_name ||= get_first_network_with_public_ip
+        end
+
+        # derive the network names from the addresses hash
+        def network_names
+          self.addresses.keys unless self.addresses.nil?
+        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
+          private_ip_addresses.first if private_ip_addresses
+        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_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
+          }
+          addr
+        end
+
+        def public_ip_address
+          public_ip_addresses.first if public_ip_addresses
+        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 flavor
+          requires :flavor_id
+          @flavor ||= service.flavors.get(flavor_id)
+        end
+
+        def image
+          requires :image_id
+          @image ||= service.images.get(image_id)
+        end
+
+        def min_count=(new_min_count)
+          @min_count = new_min_count
+        end
+
+        def max_count=(new_max_count)
+          @max_count = new_max_count
+        end
+
+        def block_device_mapping=(new_block_device_mapping)
+          @block_device_mapping = new_block_device_mapping
+        end
+
+        def networks=(new_networks)
+          @networks = new_networks
+        end
+
+        def ready?
+          self.state == 'ACTIVE'
+        end
+
+        def windows_password
+          requires :id
+          service.get_windows_password(id)
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          service.reboot_server(id, type)
+          true
+        end
+
+        def rebuild(image_id, name, options={})
+          requires :id
+          service.rebuild_server(id, image_id, name, options)
+          true
+        end
+
+        #def resize(flavor_id)
+        #  requires :id
+        #  service.resize_server(id, flavor_id)
+        #  true
+        #end
+
+        #def revert_resize
+        #  requires :id
+        #  service.revert_resized_server(id)
+        #  true
+        #end
+        #
+        #def confirm_resize
+        #  requires :id
+        #  service.confirm_resized_server(id)
+        #  true
+        #end
+
+        def create_image(name, metadata = {})
+          requires :id
+          response = service.create_image(id, name, metadata)
+          begin
+            image_id = response.headers["Location"].match(/\/([^\/]+$)/)[1]
+            Fog::Compute::HPV2::Image.new(:collection => service.images, :service => service, :id => image_id)
+          rescue
+            nil
+          end
+        end
+
+        def volume_attachments
+          @volume_attachments ||= begin
+            Fog::Compute::HPV2::VolumeAttachments.new({
+              :service => service,
+              :server => self
+            })
+          end
+        end
+
+        def update_name(new_name)
+          requires :id
+          service.update_server(id, :name => new_name)
+          true
+        end
+
+        def add_security_group(sg_name)
+          requires :id
+          service.add_security_group(id, sg_name)
+          true
+        end
+
+        def remove_security_group(sg_name)
+          requires :id
+          service.remove_security_group(id, sg_name)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :flavor_id, :name
+          meta_hash = {}
+          metadata.each { |meta| meta_hash.store(meta.key, meta.value) }
+          options = {
+            '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,
+            'config_drive'    => config_drive,
+            'user_data'       => user_data_encoded,
+            'availability_zone'  => availability_zone,
+            'networks'        => @networks
+          }
+          options = options.reject {|key, value| value.nil?}
+          # 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
+
+        def setup(credentials = {})
+          requires :public_ip_address, :identity, :public_key, :username
+          Fog::SSH.new(public_ip_address, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l #{username}},
+            %{echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json},
+            %{echo "#{Fog::JSON.encode(metadata)}" >> ~/metadata.json}
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
+
+        def username
+          @username ||= 'ubuntu'
+        end
+
+        private
+
+        def adminPass=(new_admin_pass)
+          @password = new_admin_pass
+        end
+
+        def get_first_network_with_public_ip
+          return '' if self.addresses.nil?
+          net = self.addresses.select {|_,v| v.count > 1}
+          # select returns a hash in 1.9+ and Array for 1.8.7
+          # so this below does not work in 1.8.7
+          #net.keys.first
+          # this is compatible to 1.8.7 and 1.9+
+          return '' if net.nil?
+          return '' if net.first.nil?
+          net.first[0]
+        end
+
+      end
+
+    end
+  end
+
+end