deltacloud-core 0.3.0 → 0.4.0

data/lib/deltacloud/drivers/opennebula/opennebula_driver.rb

@@ -31,6 +31,8 @@ module Deltacloud
 
 class OpennebulaDriver < Deltacloud::BaseDriver
 
+  feature :instances, :user_name
+
   ######################################################################
   # Hardware profiles
   ######################################################################
@@ -126,6 +128,10 @@ class OpennebulaDriver < Deltacloud::BaseDriver
 
 	hwp_id = opts[:hwp_id] || 'small'
 
+	if not opts[:name]
+          opts[:name] = "#{Time.now.to_i.to_s}#{rand(9)}"
+        end
+
 	instancexml = ERB.new(OCCI_VM).result(binding)
 	instancefile = "|echo '#{instancexml}'"
 

data/lib/deltacloud/drivers/rackspace/rackspace_driver.rb

@@ -109,6 +109,16 @@ class RackspaceDriver < Deltacloud::BaseDriver
     end
   end
 
+  def destroy_image(credentials, image_id)
+    rax_client = new_client(credentials)
+    safely do
+      image = rax_client.get_image(image_id.to_i)
+      unless image.delete!
+        raise "ERROR: Cannot delete image with ID:#{image_id}"
+      end
+    end
+  end
+
   def run_on_instance(credentials, opts={})
     target = instance(credentials, :id => opts[:id])
     param = {}
@@ -262,7 +272,7 @@ class RackspaceDriver < Deltacloud::BaseDriver
   def create_blob(credentials, bucket_id, blob_id, blob_data, opts={})
     cf = cloudfiles_client(credentials)
     #insert ec2-specific header for user metadata ... X-Object-Meta-KEY = VALUE
-    opts.gsub_keys("HTTP_X_Deltacloud_Blobmeta_", "X-Object-Meta-")
+    BlobHelper::rename_metadata_headers(opts, "X-Object-Meta-")
     opts['Content-Type'] = blob_data[:type]
     object = nil
     safely do
@@ -311,11 +321,39 @@ class RackspaceDriver < Deltacloud::BaseDriver
     cf = cloudfiles_client(credentials)
     meta_hash = opts['meta_hash']
     #the set_metadata method actually places the 'X-Object-Meta-' prefix for us:
-    meta_hash.gsub_keys('HTTP_X_Deltacloud_Blobmeta_', '')
+    BlobHelper::rename_metadata_headers(meta_hash, '')
     safely do
       blob = cf.container(opts['bucket']).object(opts[:id])
       blob.set_metadata(meta_hash)
-    end 
+    end
+  end
+
+  #params: {:user,:password,:bucket,:blob,:content_type,:content_length,:metadata}
+  def blob_stream_connection(params)
+    #create a cloudfiles connection object to get the authtoken
+    cf, cf_host, cf_path, cf_authtoken = nil
+    safely do
+      cf = CloudFiles::Connection.new(:username => params[:user],
+                                :api_key => params[:password])
+      cf_authtoken = cf.authtoken
+      cf_host = cf.storagehost
+      cf_path = cf.storagepath
+    end
+    provider = "https://#{cf_host}"
+    uri = URI.parse(provider)
+    http = Net::HTTP.new(uri.host, uri.port )
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    request = Net::HTTP::Put.new("#{cf_path}/#{params[:bucket]}/#{params[:blob]}")
+    request['Host'] = "#{cf_host}"
+    request['X-Auth-Token'] = "#{cf_authtoken}"
+    request['Content-Type'] = params[:content_type]
+    request['Content-Length'] = params[:content_length]
+    request['Expect'] = "100-continue"
+    metadata = params[:metadata] || {}
+    BlobHelper::rename_metadata_headers(metadata, 'X-Object-Meta-')
+    metadata.each{|k,v| request[k] = v}
+    return http, request
   end
 
 private
@@ -391,12 +429,24 @@ private
     end
   end
 
-  def catched_exceptions_list
-    {
-      :auth => [ /Authentication failed/ ],
-      :error => [ /Error/ ],
-      :glob => [ /CloudServers::Exception::(\w+)/, /Deltacloud::Runner::(\w+)/ ]
-    }
+  exceptions do
+
+    on /No offering found/ do
+      status 400
+    end
+
+    on /Authentication failed/ do
+      status 401
+    end
+
+    on /Error/ do
+      status 500
+    end
+
+    on /CloudServers::Exception::(\w+)/ do
+      status 500
+    end
+
   end
 
   private

data/lib/deltacloud/drivers/rhevm/rhevm_client.rb

@@ -1,3 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.  The
+# ASF licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the
+# License.  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+
 require 'rubygems'
 require 'base64'
 require 'restclient'
@@ -58,7 +74,7 @@ module RHEVM
           template_(:id => template_id)
           cluster(:id => opts[:realm_id] || clusters.first.id)
           type_ opts[:hwp_id] || 'desktop'
-          memory opts[:hwp_memory] || (512*1024*1024).to_s
+          memory opts[:hwp_memory] ? (opts[:hwp_memory].to_i*1024*1024).to_s : (512*1024*1024).to_s
           cpu {
             topology( :cores => (opts[:hwp_cpu] || '1'), :sockets => '1' )
           }
@@ -74,6 +90,35 @@ module RHEVM
       RHEVM::VM::new(self, Nokogiri::XML(vm).root)
     end
 
+    def create_template(vm_id, opts={})
+      opts ||= {}
+      builder = Nokogiri::XML::Builder.new do
+        template_ {
+          name opts[:name]
+          description opts[:description]
+          vm(:id => vm_id)
+        }
+      end
+      headers = opts[:headers] || {}
+      headers.merge!({
+        :content_type => 'application/xml',
+        :accept => 'application/xml',
+      })
+      headers.merge!(auth_header)
+      template = RHEVM::client(@api_entrypoint)["/templates"].post(Nokogiri::XML(builder.to_xml).root.to_s, headers)
+      RHEVM::Template::new(self, Nokogiri::XML(template).root)
+    end
+
+    def destroy_template(id, headers={})
+      headers.merge!({
+        :content_type => 'application/xml',
+        :accept => 'application/xml',
+      })
+      headers.merge!(auth_header)
+      RHEVM::client(@api_entrypoint)["/templates/%s" % id].delete(headers)
+      return true
+    end
+
     def templates(opts={})
       headers = {
         :accept => "application/xml"
@@ -99,8 +144,8 @@ module RHEVM
         [ RHEVM::Cluster::new(self, vm)]
       else
         Client::parse_response(RHEVM::client(@api_entrypoint)["/clusters"].get(headers)).xpath('/clusters/cluster').collect do |vm|
-          RHEVM::Cluster::new(self, vm)
-        end
+          RHEVM::Cluster::new(self, vm) if has_datacenter?(vm)
+        end.compact
       end
     end
 
@@ -150,7 +195,9 @@ module RHEVM
     end
 
     def auth_header
-      { :authorization => "Basic " + Base64.encode64("#{@credentials[:username]}:#{@credentials[:password]}"), }
+      # As RDOC says this is the function for strict_encode64:
+      encoded_credentials = ["#{@credentials[:username]}:#{@credentials[:password]}"].pack("m0").gsub(/\n/,'')
+      { :authorization => "Basic " + encoded_credentials }
     end
 
     def base_url
@@ -162,6 +209,10 @@ module RHEVM
       Nokogiri::XML(response)
     end
 
+    def has_datacenter?(vm)
+      value=!(vm/'data_center').empty?
+      value
+    end
   end
 
   class BaseObject
@@ -173,7 +224,6 @@ module RHEVM
       @client = client
       self
     end
-
   end
 
   class Link
@@ -195,7 +245,7 @@ module RHEVM
   class VM < BaseObject
     attr_reader :description, :status, :memory, :profile, :display, :host, :cluster, :template, :macs
     attr_reader :storage, :cores, :username, :creation_time
-    attr_reader :ip
+    attr_reader :ip, :vnc
 
     def initialize(client, xml)
       super(client, xml[:id], xml[:href], (xml/'name').first.text)
@@ -225,6 +275,10 @@ module RHEVM
       @macs = (xml/'nics/nic/mac').collect { |mac| mac[:address] }
       @creation_time = (xml/'creation_time').text
       @ip = ((xml/'guest_info/ip').first[:address] rescue nil)
+      unless @ip
+        @vnc = ((xml/'display/address').first.text rescue "127.0.0.1")
+        @vnc += ":#{((xml/'display/port').first.text rescue "5890")}"
+      end
     end
 
   end
@@ -262,6 +316,7 @@ module RHEVM
       @description = ((xml/'description').first.text rescue nil)
       @datacenter = Link::new(@client, (xml/'data_center').first[:id], (xml/'data_center').first[:href])
     end
+
   end
 
   class DataCenter < BaseObject
@@ -318,7 +373,7 @@ module RHEVM
       @path = ((xml/'storage/path').first.text rescue nil)
     end
   end
-  
+
 end
 
 class String
@@ -329,4 +384,3 @@ class String
     end
   end
 end
-

data/lib/deltacloud/drivers/rhevm/rhevm_driver.rb

@@ -33,7 +33,11 @@ module Deltacloud
 
 class RHEVMDriver < Deltacloud::BaseDriver
 
-  feature :instances, :user_name
+  feature :instances, :user_name do
+    constraint :max_length, 50
+  end
+
+  USER_NAME_MAX = feature(:instances, :user_name).constraints[:max_length]
 
   # FIXME: These values are just for ilustration
   # Also I choosed 'SERVER' and 'DESKTOP' names
@@ -56,26 +60,9 @@ class RHEVMDriver < Deltacloud::BaseDriver
     architecture 'x86_64'
   end
 
-  # Instead of setting a URL for RHEV provider
-  # do it here in driver, so it can be altered by HTTP headers
-  #
-  def provider_uri=(uri)
-    @RHEVM_URI = uri
-  end
-
-  # Default Provider URI.
-  #
-  # IMPORTANT:
-  # This URI can be overridden using shell variable API_PROVIDER
-  # or setting provider using HTTP header X-Deltacloud-Provider to URL.
-  #
-  def provider_uri
-    Deltacloud::Drivers::driver_config[:rhevm][:entrypoints]['default']['default']
-  end
-
   define_instance_states do
     start.to( :pending )          .automatically
-    pending.to( :running )        .automatically
+    pending.to( :running )        .on( :start )
     pending.to( :stopped )        .automatically
     stopped.to( :running )        .on( :start )
     running.to( :stopping )       .on( :stop )
@@ -96,6 +83,7 @@ class RHEVMDriver < Deltacloud::BaseDriver
         realm_arr << convert_realm(r, d)
       end
     end
+    realm_arr = filter_on( realm_arr, :id, opts )
     realm_arr
   end
 
@@ -115,6 +103,29 @@ class RHEVMDriver < Deltacloud::BaseDriver
     img_arr.sort_by{|e| [e.owner_id, e.name]}
   end
 
+  def create_image(credentials, opts={})
+    client = new_client(credentials)
+    unless opts[:name]
+      instance = instances(credentials, :id => opts[:id])
+      raise "Specified instance '#{opts[:id]}' not found"
+      template_name = "#{instance.first.name}-template"
+    end
+    safely do
+      new_image = client.create_template(opts[:id], :name => (opts[:name] || template_name),
+                                         :description => opts[:description])
+      convert_image(client, new_image)
+    end
+  end
+
+  def destroy_image(credentials, image_id)
+    client = new_client(credentials)
+    safely do
+      unless client.destroy_template(image_id)
+        raise "ERROR: Unable to remove image"
+      end
+    end
+  end
+
   def instances(credentials, opts={})
     client = new_client(credentials)
     inst_arr = []
@@ -168,8 +179,15 @@ class RHEVMDriver < Deltacloud::BaseDriver
   def create_instance(credentials, image_id, opts={})
     client = new_client(credentials)
     params = {}
+    name = opts[:name]
+    if not name
+      name = Time.now.to_i.to_s
+    end
+    if name.length > USER_NAME_MAX
+      raise "Parameter name must be #{USER_NAME_MAX} characters or less"
+    end
     safely do
-      params[:name] = opts[:name] if opts[:name]
+      params[:name] = name
       params[:realm_id] = opts[:realm_id] if opts[:realm_id]
       params[:hwp_id] = opts[:hwp_id] if opts[:hwp_id]
       params[:hwp_memory] = opts[:hwp_memory] if opts[:hwp_memory]
@@ -182,8 +200,8 @@ class RHEVMDriver < Deltacloud::BaseDriver
     retval = true
     begin
       realms(credentials)
-    rescue Deltacloud::BackendError
-     retval = false
+    rescue
+      retval = false
     end
     retval
   end
@@ -191,26 +209,35 @@ class RHEVMDriver < Deltacloud::BaseDriver
   private
 
   def new_client(credentials)
-    url = (Thread.current[:provider] || ENV['API_PROVIDER'] || provider_uri)
+    url = api_provider
     safely do
       ::RHEVM::Client.new(credentials.user, credentials.password, url)
     end
   end
 
+  def confserver_ip(uuid)
+    client = RestClient::Resource::new(ENV['CONFIG_SERVER_ADDRESS'])
+    client["/ip/%s/%s" % [ (ENV['CONFIG_SERVER_VERSION'] || '0.0.1'), uuid]].get(:accept => 'text/plain').body.strip rescue nil
+  end
+
   def convert_instance(client, inst)
     state = convert_state(inst.status)
     storage_size = inst.storage.nil? ? 1 :  (inst.storage.to_i/1024/1024/1024)
-    profile = InstanceProfile::new(inst.profile.upcase, 
+    profile = InstanceProfile::new(inst.profile.upcase,
                                    :hwp_memory => inst.memory.to_i/1024/1024,
                                    :hwp_cpu => inst.cores,
                                    :hwp_storage => "#{storage_size}"
     )
-    # Include VNC and SPICE addresses
-    if inst.ip
-      public_addresses = [ inst.ip ]
-    else
-      public_addresses = [ inst.macs ]
-    end
+    public_addresses = []
+    # First check if RHEV-M guest tools are installed and IP address is offered by them
+    public_addresses << inst.ip if inst.ip
+    # Second check if ConfServer broker is running, then ask for an IP there
+    public_addresses << confserver_ip(inst.id) if ENV['CONFIG_SERVER_ADDRESS'] and public_addresses.empty?
+    public_addresses.compact!
+    # If everything fails fallback to report MAC address
+    public_addresses = inst.macs if public_addresses.empty?
+    public_addresses.flatten!
+    public_addresses << inst.vnc if inst.vnc
     Instance.new(
       :id => inst.id,
       :name => inst.name,
@@ -223,18 +250,23 @@ class RHEVMDriver < Deltacloud::BaseDriver
       :hardware_profile_id => profile.id,
       :actions=>instance_actions_for( state ),
       :public_addresses => public_addresses,
-      :private_addresses => []
+      :private_addresses => [],
+      :create_image => true
     )
   end
 
-  # STATES: 
+  # STATES:
   #
-  # UNASSIGNED, DOWN, UP, POWERING_UP, POWERED_DOWN, PAUSED, MIGRATING_FROM, MIGRATING_TO, 
-  # UNKNOWN, NOT_RESPONDING, WAIT_FOR_LAUNCH, REBOOT_IN_PROGRESS, SAVING_STATE, RESTORING_STATE, 
-  # SUSPENDED, IMAGE_ILLEGAL, IMAGE_LOCKED or POWERING_DOWN 
+  # UNASSIGNED, DOWN, UP, POWERING_UP, POWERED_DOWN, PAUSED, MIGRATING_FROM,
+  # MIGRATING_TO, UNKNOWN, NOT_RESPONDING, WAIT_FOR_LAUNCH, REBOOT_IN_PROGRESS,
+  # SAVING_STATE, RESTORING_STATE, SUSPENDED, IMAGE_ILLEGAL,
+  # IMAGE_LOCKED or POWERING_DOWN
   #
   def convert_state(state)
-    case state
+    unless state.respond_to?(:upcase)
+      raise "State #{state.inspect} is not a string"
+    end
+    case state.strip.upcase
     when 'WAIT_FOR_LAUNCH', 'REBOOT_IN_PROGRESS', 'SAVING_STATE',
       'RESTORING_STATE', 'POWERING_DOWN', 'POWERING_UP', 'IMAGE_LOCKED', 'SAVING_STATE' then
       'PENDING'
@@ -242,6 +274,8 @@ class RHEVMDriver < Deltacloud::BaseDriver
       'STOPPED'
     when 'UP', 'MIGRATING_TO', 'MIGRATING_FROM'
       'RUNNING'
+    else
+      raise "Unexpected state '#{state}'"
     end
   end
 
@@ -277,15 +311,36 @@ class RHEVMDriver < Deltacloud::BaseDriver
     )
   end
 
-  # Disabling this error catching will lead to more verbose messages
-  # on console (eg. response from RHEV-M API (so far I didn't figure our
-  # how to pass those message to our exception handling tool)
-  def catched_exceptions_list
-    {
-      :auth => [RestClient::Unauthorized],
-      :error => [RestClient::InternalServerError],
-      :glob => [ /(RestClient|RHEVM)::(\w+)/ ]
-    }
+  exceptions do
+
+    on /Bad Request/ do
+      status 400
+    end
+
+    on /RestClient::Unauthorized/ do
+      status 401
+    end
+
+    on /RestClient::ResourceNotFound/ do
+      status 404
+    end
+
+    on /RestClient::InternalServerError/ do
+      status 502
+    end
+
+    on /(RestClient|RHEVM)/ do
+      status 500
+    end
+
+    on /(.*) not found^/ do
+      status 400
+    end
+
+    on /Parameter name/ do
+      status 400
+    end
+
   end
 
 end