deltacloud-core 1.0.1 → 1.0.2

data/lib/deltacloud/drivers/base_driver.rb

@@ -16,6 +16,12 @@
 
 module Deltacloud
 
+  require_relative '../core_ext.rb'
+  require_relative './exceptions.rb'
+  require_relative './features.rb'
+  require_relative '../models/hardware_profile.rb'
+  require_relative '../models/state_machine.rb'
+
   class BaseDriver
 
     include ExceptionHandler
@@ -33,12 +39,6 @@ module Deltacloud
       @features ||= {}
     end
 
-    def self.features_for(entity)
-      features.inject([]) do |result, item|
-        result << item[entity] if item.has_key? entity
-        result
-      end
-    end
 
     def self.feature(collection, feature_name)
       return if has_feature?(collection, feature_name)
@@ -75,7 +75,7 @@ module Deltacloud
       return if hw_profile
       hw_profile = ::Deltacloud::HardwareProfile.new( name, &block )
       @hardware_profiles << hw_profile
-      hw_params = hw_profile.params
+      hw_profile.params
       # FIXME: Features
       #unless hw_params.empty?
       #  feature :instances, :hardware_profiles do
@@ -145,7 +145,6 @@ module Deltacloud
 
     def instance_actions_for(state)
       actions = []
-      state_key = state.downcase.to_sym
       states = instance_state_machine.states()
       current_state = states.find{|e| e.name == state.underscore.to_sym }
       if ( current_state )
@@ -157,7 +156,11 @@ module Deltacloud
 
     def has_capability?(method)
       method = (RUBY_VERSION =~ /^1\.9/) ? method : method.to_s
-      (self.class.instance_methods - self.class.superclass.instance_methods).include? method
+      # Prevent has_capability fail when driver is inherited from another
+      # driver, like Eucalyptus
+      superclass_methods = self.class.superclass.name == 'Deltacloud::BaseDriver' ?
+        self.class.superclass.instance_methods : []
+      (self.class.instance_methods - superclass_methods).include? method
     end
 
     ## Capabilities
@@ -257,14 +260,6 @@ module Deltacloud
       end
     end
 
-    def supported_collections
-      DEFAULT_COLLECTIONS
-    end
-
-    def has_collection?(collection)
-      supported_collections.include?(collection)
-    end
-
     def catched_exceptions_list
       { :error => [], :auth => [], :glob => [] }
     end

data/lib/deltacloud/drivers/ec2/ec2_driver.rb

@@ -142,8 +142,13 @@ module Deltacloud
           profiles = hardware_profiles(nil)
           if opts[:id]
             safely do
-              img_arr = ec2.describe_images([opts[:id]]).collect do |image|
-                convert_image(image, profiles)
+              begin
+                img_arr = ec2.describe_images([opts[:id]]).collect do |image|
+                  convert_image(image, profiles)
+                end
+              rescue => e
+                raise e unless e.message =~ /Invalid id/ or e.message =~ /does not exist/
+                img_arr = []
               end
             end
             return img_arr
@@ -163,8 +168,13 @@ module Deltacloud
           realms = []
           safely do
             if opts[:id] and !opts[:id].empty?
-              ec2.describe_availability_zones([opts[:id]]).collect do |realm|
-                realms << convert_realm(realm) unless realm.empty?
+              begin
+                ec2.describe_availability_zones([opts[:id]]).collect do |realm|
+                  realms << convert_realm(realm) unless realm.empty?
+                end
+              rescue => e
+                raise e unless e.message =~ /Invalid availability zone/
+                realms = []
               end
             else
               ec2.describe_availability_zones.collect do |realm|
@@ -195,10 +205,14 @@ module Deltacloud
 
         def instance(credentials, opts={})
           ec2 = new_client(credentials)
-          inst_arr = []
           safely do
-            ec2_inst = ec2.describe_instances([opts[:id]]).first
-            raise "Instance #{opts[:id]} NotFound" if ec2_inst.nil?
+            begin
+              ec2_inst = ec2.describe_instances([opts[:id]]).first
+            rescue => e
+              raise e unless e.message =~ /Invalid id/ or e.message =~ /NotFound/
+              ec2_inst = nil
+            end
+            return if ec2_inst.nil?
             instance = convert_instance(ec2_inst)
             return nil unless instance
             if ec2_inst[:aws_platform] == 'windows'
@@ -329,8 +343,13 @@ module Deltacloud
           ec2 = new_client(credentials)
           opts ||= {}
           safely do
-            ec2.describe_key_pairs(opts[:id] ? [opts[:id]] : nil).collect do |key|
-              convert_key(key)
+            begin
+              ec2.describe_key_pairs(opts[:id] ? [opts[:id]] : nil).collect do |key|
+                convert_key(key)
+              end
+            rescue => e
+              raise e unless e.message =~ /does not exist/
+              []
             end
           end
         end
@@ -378,7 +397,7 @@ module Deltacloud
                 :instance_port => opts['listener_instance_port'],
                 :protocol => opts['listener_protocol']}]
             )
-            return load_balancer(credentials, opts['name'])
+            return load_balancer(credentials, :id => opts['name'])
           end
         end
 
@@ -440,6 +459,7 @@ module Deltacloud
 
         def delete_bucket(credentials, name, opts={})
           s3_client = new_client(credentials, :s3)
+          s3_bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, name)
           safely do
             s3_client.interface.delete_bucket(name)
           end
@@ -524,7 +544,7 @@ module Deltacloud
 
         def blob_data(credentials, bucket_id, blob_id, opts={})
           s3_client = new_client(credentials, :s3)
-          bucket, s3_client = get_bucket_with_endpoint(s3_client, credentials, bucket_id)
+          s3_client = get_bucket_with_endpoint(s3_client, credentials, bucket_id)[1]
           safely do
             s3_client.interface.get(bucket_id, blob_id) do |chunk|
               yield chunk
@@ -563,7 +583,7 @@ module Deltacloud
 
         def storage_volumes(credentials, opts={})
           ec2 = new_client( credentials )
-          volume_list = (opts and opts[:id]) ? opts[:id] : nil
+          volume_list = (opts and opts[:id]) ? [opts[:id]] : []
           safely do
             ec2.describe_volumes(volume_list).collect do |volume|
               convert_volume(volume)
@@ -588,7 +608,7 @@ module Deltacloud
             unless ec2.delete_volume(opts[:id])
               raise Deltacloud::BackendError.new(500, "StorageVolume", "Cannot delete storage volume")
             end
-            storage_volume(credentials, opts[:id])
+            storage_volume(credentials, :id => opts[:id])
           end
         end
 
@@ -608,11 +628,19 @@ module Deltacloud
 
         def storage_snapshots(credentials, opts={})
           ec2 = new_client(credentials)
-          snapshot_list = (opts and opts[:id]) ? opts[:id] : []
+          snapshot_list = opts[:id] ? [opts[:id]] : []
           safely do
+            begin
             ec2.describe_snapshots(snapshot_list).collect do |snapshot|
               convert_snapshot(snapshot)
             end
+            rescue => e
+              if e.message =~ /NotFound/
+                []
+              else
+                raise e
+              end
+            end
           end
         end
 
@@ -756,8 +784,8 @@ module Deltacloud
 
         def providers(credentials, opts={})
           ec2 = new_client(credentials)
-          providers = ec2.describe_regions.map{|r| Provider.new( {:id=>r, :name=>r,
-           :url=>"#{ENV['API_HOST']}:#{ENV['API_PORT']}#{Deltacloud[ENV['API_FRONTEND'] || :deltacloud].root_url}\;provider=#{r}" }) }
+          @providers ||= ec2.describe_regions.map{|r| Provider.new( {:id=>r, :name=>r,
+           :url=>"#{ENV['API_HOST']}:#{ENV['API_PORT']}#{Deltacloud.default_frontend.root_url}\;provider=#{r}" }) }
         end
 
         def configured_providers
@@ -769,7 +797,7 @@ module Deltacloud
             realms(credentials) && true
           rescue => e
             if e.class.name =~ /AuthFailure/
-              retval = false
+              false
             else
               safely { raise e }
             end
@@ -787,7 +815,7 @@ module Deltacloud
           klass.new(credentials.user, credentials.password, {
             :server => endpoint || endpoint_for_service(type),
             :connection_mode => :per_thread,
-            :logger => ENV['RACK_ENV'] == 'test' ? Logger.new('/dev/null') : Logger.new(STDOUT)
+            :logger => ENV['RACK_ENV'] == 'test' ? Logger.new(StringIO.new) : Logger.new(STDOUT)
           })
         end
 
@@ -808,7 +836,7 @@ module Deltacloud
 
         def get_bucket_with_endpoint(s3_client, credentials, s3_bucket_name)
             s3_bucket = s3_client.bucket(s3_bucket_name)
-            endpoint_for_bucket = Deltacloud::Drivers::driver_config[:ec2][:entrypoints]["s3"]["#{s3_bucket.location}"]
+            endpoint_for_bucket = Deltacloud::Drivers::driver_config[:ec2][:entrypoints]["s3"]["#{s3_bucket.location}"] || "s3.amazonaws.com"
             if (s3_client.interface.params[:server] != endpoint_for_bucket)
               s3_client = new_client(credentials, :s3, endpoint_for_bucket)
               s3_bucket = s3_client.bucket(s3_bucket_name)
@@ -934,8 +962,8 @@ module Deltacloud
 
         def convert_load_balancer(credentials, loadbalancer)
           realms = []
-          balancer_realms = loadbalancer[:availability_zones].each do |zone|
-            realms << realm(credentials, zone)
+          loadbalancer[:availability_zones].each do |zone|
+            realms << realm(credentials, :id => zone)
           end
           balancer = LoadBalancer.new({
             :id => loadbalancer[:name],
@@ -965,7 +993,7 @@ module Deltacloud
           end
         end
          #sources_string is @group,297467797945,test@address,ipv4,10.1.1.1,24 etc
-         id_string = "#{user_id}~#{protocol}~#{from_port}~#{to_port}~#{sources_string.chomp!(",")}"
+         "#{user_id}~#{protocol}~#{from_port}~#{to_port}~#{sources_string.chomp!(",")}"
 #sources_string.slice(0,sources_string.length-1)}"
         end
 

data/lib/deltacloud/drivers/eucalyptus/eucalyptus_driver.rb

@@ -71,7 +71,7 @@ module Deltacloud
         end
 
         def default_image_owner
-          "self" 
+          "self"
         end
 
         def default_image_type

data/lib/deltacloud/drivers/exceptions.rb

@@ -37,6 +37,13 @@ module Deltacloud
       end
     end
 
+    class ForbiddenError < DeltacloudException
+      def initialize(e, message=nil)
+        message ||= e.message
+        super(403, e.class.name, message, e.backtrace)
+      end
+    end
+
     class UnknownMediaTypeError < DeltacloudException
       def initialize(e, message=nil)
         message ||= e.message
@@ -136,6 +143,7 @@ module Deltacloud
         return @handler if @handler
         case @status
           when 401 then Deltacloud::ExceptionHandler::AuthenticationFailure.new(e, @message)
+          when 403 then Deltacloud::ExceptionHandler::ForbiddenError.new(e, @message)
           when 404 then Deltacloud::ExceptionHandler::ObjectNotFound.new(e, @message)
           when 406 then Deltacloud::ExceptionHandler::UnknownMediaTypeError.new(e, @message)
           when 405 then Deltacloud::ExceptionHandler::MethodNotAllowed.new(e, @message)
@@ -176,8 +184,10 @@ module Deltacloud
         Deltacloud::ExceptionHandler::exceptions.each do |exdef|
           if exdef.match?($!)
             new_exception = exdef.handler($!)
-            m = new_exception.message.nil? ? $!.message : new_exception.message
-            $stderr.send(report_method, "#{[$!.class.to_s, m].join(':')}\n#{$!.backtrace[0..10].join("\n")}")
+            m = (new_exception && !new_exception.message.nil?) ? new_exception.message : $!.message
+            unless ENV['RACK_ENV'] == 'test'
+              $stderr.send(report_method, "#{[$!.class.to_s, m].join(':')}\n#{$!.backtrace[0..10].join("\n")}")
+            end
             raise exdef.handler($!) unless new_exception.nil?
           end
         end

data/lib/deltacloud/drivers/features.rb

@@ -148,6 +148,14 @@ module Deltacloud
           param :sandbox, :string,  :optional
         end
       end
+
+      feature :import_key, :for => :keys do
+        description "Allow importing existing public key for creation of new key on provider"
+        operation :create do
+          param :public_key, :string, :optional
+        end
+      end
+
     end
 
   end

data/lib/deltacloud/drivers/fgcp/fgcp_client.rb

@@ -29,13 +29,16 @@ module Deltacloud
 
 class FgcpClient
 
-  def initialize(cert, key, endpoint = nil, version = '2011-01-31', locale = 'en')
+  def initialize(cert, key, region = nil, version = '2011-01-31', locale = 'en')
     @version = version
     @locale = locale
-    cert.subject.to_s =~ /\b[Cc]=(\w\w)\b/
-    country = $1.downcase
-    endpoint = Deltacloud::Drivers::driver_config[:fgcp][:entrypoints]['default'][country] unless endpoint
-    raise "API endpoint not found for region #{country}" if endpoint.nil?
+    if region.nil?
+      cert.subject.to_s =~ /\b[Cc]=(\w\w)\b/
+      region = $1.downcase
+    end
+    # first 'jp' region is now 'jp-east'
+    region = 'jp-east' if region == 'jp'
+    endpoint = Deltacloud::Drivers::driver_config[:fgcp][:entrypoints]['default'][region] || region
 
     #proxy settings:
     http_proxy = ENV['http_proxy']
@@ -87,6 +90,10 @@ class FgcpClient
     request('GetVSYSConfiguration', {'vsysId' => vsys_id})
   end
 
+  def list_vservers(vsys_id)
+    request('ListVServer', {'vsysId' => vsys_id})
+  end
+
   def start_vserver(vserver_id)
     request('StartVServer', {'vsysId' => extract_vsys_id(vserver_id), 'vserverId' => vserver_id})
   end
@@ -284,6 +291,15 @@ eoidxml
     request('DestroyVSYS', {'vsysId' => vsys_id})
   end
 
+  def get_performance_information(vserver_id, interval, data_type=nil)
+    @version = '2012-02-18'
+    if data_type.nil?
+      request('GetPerformanceInformation', {'vsysId' => extract_vsys_id(vserver_id), 'serverId' => vserver_id, 'interval' => interval})
+    else
+      request('GetPerformanceInformation', {'vsysId' => extract_vsys_id(vserver_id), 'serverId' => vserver_id, 'dataType' => data_type, 'interval' => interval})
+    end
+  end
+
   #extract vsysId from vserverId, efmId or networkId
   def extract_vsys_id(id)
     /^(\w+-\w+)\b.*/ =~ id
@@ -307,7 +323,6 @@ eoidxml
     begin
       if attachment.nil?
         @uri.query = encode_params(params)
-
         resp = @service.request_get(@uri.request_uri, @headers)
       else
         #multipart post

data/lib/deltacloud/drivers/fgcp/fgcp_driver.rb

@@ -32,6 +32,7 @@ class FgcpDriver < Deltacloud::BaseDriver
   end
 
   feature :instances, :user_name
+  feature :instances, :metrics
   feature :images, :user_name
   feature :images, :user_description
 
@@ -89,9 +90,6 @@ class FgcpDriver < Deltacloud::BaseDriver
         end
       end
     end
-#TODO: is there a way to sort them by arch and memory?
-#current order is as returned by API which is not a natural order
-#    @hardware_profiles.sort_by{|e| [e.architecture, e.memory]}
     filter_hardware_profiles(@hardware_profiles, opts)
   end
 
@@ -198,6 +196,7 @@ class FgcpDriver < Deltacloud::BaseDriver
                   )
       elsif xml = client.list_vsys['vsyss']
 
+        return [] if xml.nil?
         xml[0]['vsys'].each do |vsys|
 
           realms << Realm::new(
@@ -256,6 +255,7 @@ class FgcpDriver < Deltacloud::BaseDriver
         end
       elsif xml = client.list_vsys['vsyss']
 
+        return [] if xml.nil?
         xml[0]['vsys'].each do |vsys|
 
           # use get_vsys_configuration (instead of get_vserver_configuration) to retrieve all vservers in one call
@@ -428,12 +428,13 @@ class FgcpDriver < Deltacloud::BaseDriver
           :instance_id => vdisk['attachedTo'].nil? ? nil : vdisk['attachedTo'][0],
           :state       => state,
           :actions     => actions,
-          # alining with rhevm, which returns 'system' or 'data'
+          # aligning with rhevm, which returns 'system' or 'data'
           :kind        => determine_storage_type(opts[:id]),
           :realm_id    => client.extract_vsys_id(opts[:id])
         )
       elsif xml = client.list_vsys['vsyss']
 
+        return [] if xml.nil?
         xml[0]['vsys'].each do |vsys|
 
           vdisks = client.list_vdisk(vsys['vsysId'][0])['vdisks'][0]
@@ -449,7 +450,7 @@ class FgcpDriver < Deltacloud::BaseDriver
                 :capacity    => vdisk['size'][0],
                 :instance_id => vdisk['attachedTo'].nil? ? nil : vdisk['attachedTo'][0],
                 :realm_id    => client.extract_vsys_id(vdisk['vdiskId'][0]),
-                # alining with rhevm, which returns 'system' or 'data'
+                # aligning with rhevm, which returns 'system' or 'data'
                 :kind        => determine_storage_type(vdisk['vdiskId'][0]),
                 :state       => vdisk['attachedTo'].nil? ? nil : 'IN-USE'
               )
@@ -490,7 +491,7 @@ class FgcpDriver < Deltacloud::BaseDriver
         :realm_id    => client.extract_vsys_id(opts[:realm_id]),
         :instance_id => nil,
         :state       => 'DEPLOYING',
-        # alining with rhevm, which returns 'system' or 'data'
+        # aligning with rhevm, which returns 'system' or 'data'
         :kind        => 'data',
         :actions     => []
       )
@@ -545,15 +546,13 @@ class FgcpDriver < Deltacloud::BaseDriver
         end
       elsif xml = client.list_vsys['vsyss']
 
+        return [] if xml.nil?
         xml[0]['vsys'].each do |vsys|
 
           vdisks = client.list_vdisk(vsys['vsysId'][0])['vdisks'][0]
           if vdisks['vdisk']
             vdisks['vdisk'].each do |vdisk|
 
-#TODO: skipping system disks for now to improve performance
-if vdisk['vdiskId'][0] =~ /^.*-D-\d\d\d\d/
-
               backups = client.list_vdisk_backup(vdisk['vdiskId'][0])
               if backups['backups'] and backups['backups'][0]['backup']
                 backups['backups'][0]['backup'].each do |backup|
@@ -566,7 +565,6 @@ if vdisk['vdiskId'][0] =~ /^.*-D-\d\d\d\d/
                   )
                 end
               end
-end
             end
           end
         end
@@ -689,7 +687,7 @@ end
       client = new_client(credentials)
       opts ||= {}
       if opts[:realm_id]
-        # just in case a network realm was passed
+        # just in case a network realm was passed in
         opts[:realm_id] = client.extract_vsys_id(opts[:realm_id])
       else
         # get first vsys
@@ -699,7 +697,7 @@ end
 
       client.allocate_public_ip(opts[:realm_id])
     end
-    #TODO: new address not returned immediately!
+    # new address not returned immediately!
     Address.new(:id => 'PENDING-xxx.xxx.xxx.xxx')
   end
 
@@ -710,9 +708,9 @@ end
       if opts[:realm_id]
         opts[:realm_id] = client.extract_vsys_id(opts[:realm_id])
       else
-        xml = client.list_public_ips
-        if xml['publicips']
-          xml['publicips'][0]['publicip'].find do |ip|
+        xml = client.list_public_ips['publicips']
+        if xml
+          xml[0]['publicip'].find do |ip|
             opts[:realm_id] = ip['vsysId'][0] if opts[:id] == ip['address'][0]
           end
         end
@@ -894,15 +892,16 @@ eofwpxml
           :rules    => rules
         })
       else
-        xml = client.list_vsys
-        return [] if xml['vsyss'].nil?
+        xml = client.list_vsys['vsyss']
+        return [] if xml.nil?
 
-        firewalls = xml['vsyss'][0]['vsys'].collect do |vsys|
+        firewalls = xml[0]['vsys'].collect do |vsys|
 
           Firewall.new({
             :id => vsys['vsysId'][0] + '-S-0001',
             :name => fw_name,
             :description => "#{vsys['vsysName'][0]} [#{vsys['baseDescriptor'][0]}]",
+            :rules => [],
             :owner_id => vsys['creator'][0]
           })
         end
@@ -1013,10 +1012,10 @@ eofwopxml
     balancers = []
     safely do
       client = new_client(credentials)
-      xml = client.list_vsys
-      return [] if xml['vsyss'].nil?
+      xml = client.list_vsys['vsyss']
+      return [] if xml.nil?
 
-      xml['vsyss'][0]['vsys'].each do |vsys|
+      xml[0]['vsys'].each do |vsys|
 
         # use get_vsys_configuration (instead of list_efm) to retrieve all SLBs incl. realms in one call
         vsys_config = client.get_vsys_configuration(vsys['vsysId'][0])
@@ -1137,33 +1136,138 @@ eofwopxml
     end
   end
 
+  def metrics(credentials, opts={})
+    opts ||= {}
+    metrics_arr = []
+    safely do
+      client = new_client(credentials)
+      realms = []
+
+      # first check for cases of id or realm_id specified
+      if opts[:id]
+        metrics_arr << Metric.new(
+          :id     => opts[:id],
+          :entity => client.get_vserver_attributes(opts[:id])['vserver'][0]['vserverName'][0]
+        )
+      elsif opts[:realm_id]
+        # if realm is set, list vservers in that realm (vsys/network ID), else list from all vsys
+        realms << opts[:realm_id]
+      else
+
+        # list all vsys
+        xml = client.list_vsys['vsyss']
+        realms = xml[0]['vsys'].collect { |vsys| vsys['vsysId'][0] } if xml
+      end
+
+      # list all vservers
+      realms.each do |realm_id|
+
+        xml = client.list_vservers(client.extract_vsys_id(realm_id))['vservers']
+
+        if xml and xml[0]['vserver']
+
+          xml[0]['vserver'].each do |vserver|
+
+            # should check whether vserver is actually in opts[:realm_id] if network segment?
+            metrics_arr << Metric.new(
+              :id     => vserver['vserverId'][0],
+              :entity => vserver['vserverName'][0]
+            )
+          end
+        end
+      end
+
+      # add metric names to metrics
+      metrics_arr.each do |metric|
+        @@METRIC_NAMES.each do |name|
+          metric.add_property(name)
+        end
+        metric.properties.sort! {|a,b| a.name <=> b.name}
+      end
+    end
+    metrics_arr
+  end
+
+  def metric(credentials, opts={})
+    safely do
+      client = new_client(credentials)
+      perf = client.get_performance_information(opts[:id], 'hour')
+
+      metric = Metric.new(
+        :id         => opts[:id],
+        :entity     => perf['serverName'][0],
+        :properties => []
+      )
+      # if instance hasn't been running for an hour, no info will be returned
+      unless perf['performanceinfos'].nil? or perf['performanceinfos'][0].nil? or perf['performanceinfos'][0]['performanceinfo'].nil?
+
+        perf['performanceinfos'][0]['performanceinfo'].each do |sample|
+
+          timestamp = Time.at(sample['recordTime'][0].to_i / 1000)
+          sample.each do |measure|
+
+            measure_name = measure[0]
+            unless measure_name == 'recordTime'
+
+              unit = metric_unit_for(measure_name)
+              average = (unit == 'Percent') ? measure[1][0].to_f * 100 : measure[1][0]
+
+              properties = metric.add_property(measure_name).properties
+              property = properties.find { |p| p.name == measure_name }
+              property.values ||= []
+              property.values << {
+                :average   => average,
+                :timestamp => timestamp,
+                :unit      => unit
+              }
+            end
+          end
+          metric.properties.sort! {|a,b| a.name <=> b.name}
+        end
+      end
+      metric
+    end
+  end
+
   ######################################################################
   # Providers
   ######################################################################
+  # output of this method is used to list regions (id, url) under /api/drivers/fgcp
   def providers(credentials, opts={})
-    cert, key = convert_credentials(credentials)
-    cert.subject.to_s =~ /\b[Cc]=(\w\w)\b/
-    country = $1.downcase
-    endpoint = Deltacloud::Drivers::driver_config[:fgcp][:entrypoints]['default'][country]
-    [
+    configured_providers.collect do |region|
       Provider.new(
-        :id => "fgcp-#{country}",
-        :name => "Fujitsu Global Cloud Platform - #{country.upcase}",
-        :url => endpoint
+        :id => "fgcp-#{region}",
+        :name => "Fujitsu Global Cloud Platform - #{region.upcase}",
+        :url => Deltacloud::Drivers::driver_config[:fgcp][:entrypoints]['default'][region]
       )
-    ]
+    end
   end
 
-# following code enables region drop-down box on GUI. No need as retrieving region from cert (subject c)
-#  def configured_providers
-#    Deltacloud::Drivers::driver_config[:fgcp][:entrypoints]['default'].keys
-#  end
+  # following method enables region drop-down box on GUI
+  def configured_providers
+    Deltacloud::Drivers::driver_config[:fgcp][:entrypoints]['default'].keys.sort
+  end
 
   exceptions do
+
+    on /ALREADY_STARTED/ do
+      status 405
+    end
+
+    # trying to start a running vserver, etc.
+    on /ILLEGAL_STATE/ do
+      status 405
+    end
+
     on /AuthFailure/ do
       status 401
     end
 
+    # User not found: using certificate with wrong region
+    on /User not found in selectData./ do
+      status 401
+    end
+
     # if user doesn't have privileges to view or operate a particular resource
     on /User doesn.t have the right of access./ do
       status 400
@@ -1184,6 +1288,11 @@ eofwopxml
       status 404
     end
 
+    # trying an operation that is not supported (yet) by the target region
+    on /NOTFOUND: API to the Version/ do
+      status 501 # Not Implemented
+    end
+
     # destroying a running SLB, etc.
     on /ALREADY_STARTED/ do
       status 502 #?
@@ -1215,18 +1324,12 @@ eofwopxml
   end
 
   def convert_credentials(credentials)
-    #username could be 'dkoper'
-    #load dkoper/UserCert.p12 from cert dir
     begin
-      #p File::join(CERT_DIR, credentials.user, 'UserCert.p12')
       cert_file = File.open(File::join(CERT_DIR, credentials.user, 'UserCert.p12'), 'rb')
     rescue Errno::ENOENT => e # file not found
       raise "AuthFailure: No certificate registered under name \'#{credentials.user}\'"
 #      raise Deltacloud::ExceptionHandler::AuthenticationFailure.new(e, "No certificate registered under name #{credentials.user}")
     end
-    #TODO: check that cert's cn is indeed the username?
-    #cert.subject=/C=AU/O=Fujitsu Limited/CN=diesk_fast
-    #raise AuthError(?) if not
 
     begin
       pkcs12 = OpenSSL::PKCS12.new(cert_file, credentials.password)
@@ -1245,7 +1348,7 @@ eofwopxml
     else
       # vserver
       state = @@INSTANCE_STATE_MAP[client.get_vserver_status(vserver['vserverId'][0])['vserverStatus'][0]]
-      create_image = (state == /STOPPED|UNEXPECTED_STOP/)
+      create_image = (state =~ /STOPPED|UNEXPECTED_STOP/)
     end
 
     {
@@ -1324,21 +1427,6 @@ eofwopxml
 
     # storage volumes
     storage_volumes = []
-    # system volume
-    if server == 'vserver'
-      storage_volumes << StorageVolume.new(
-        :id          => vserver['vserverId'][0],
-        :name        => vserver['vserverName'][0],
-        #:device => '', # no API to retrieve from
-#        :capacity => '10',# or '40', need to check with image (vserver['diskimageId'][0],)
-        :realm_id    => realm_id,
-        :instance_id => vserver['vserverId'][0],
-        :state       => 'IN-USE',
-        # alining with rhevm, which returns 'system' or 'data'
-        :kind        => 'system',
-        :actions     => []
-      )
-    end
     # additional volumes
     if vserver['vdisks'] and vserver['vdisks'][0]['vdisk']
       vserver['vdisks'][0]['vdisk'].each do |vdisk|
@@ -1352,7 +1440,7 @@ eofwopxml
           :realm_id    => client.extract_vsys_id(realm_id),
           :instance_id => vserver['vserverId'][0],
           :state       => 'IN-USE',
-          # alining with rhevm, which returns 'system' or 'data'
+          # aligning with rhevm, which returns 'system' or 'data'
           :kind        => 'data',
           :actions     => actions
         )
@@ -1411,6 +1499,30 @@ eofwopxml
     client.get_efm_configuration("#{vsys_id}-S-0001", 'FW_NAT_RULE')
   end
 
+  def metric_unit_for(name)
+    case name
+      when /Utilization/ then 'Percent'
+      when /Byte/ then 'Bytes'
+      when /Sector/ then 'Count'
+      when /Count/ then 'Count'
+      when /Packet/ then 'Count'
+      else 'None'
+    end
+  end
+
+  # FGCP instance states mapped to DeltaCloud
+  @@METRIC_NAMES = [
+    'cpuUtilization',
+    'diskReadRequestCount',
+    'diskReadSector',
+    'diskWriteRequestCount',
+    'diskWriteSector',
+    'nicInputByte',
+    'nicInputPacket',
+    'nicOutputByte',
+    'nicOutputPacket'
+  ]
+
   # FGCP instance states mapped to DeltaCloud
   @@INSTANCE_STATE_MAP = {
     'DEPLOYING'       =>  'PENDING',