deltacloud-core 0.5.0 → 1.0.0

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

@@ -18,11 +18,30 @@
 require 'rubygems'
 require 'uri'
 
+require 'digest/sha1'
 require 'net/https'
 
+require "rexml/document"
+
+begin
+  require 'rexml/formatters/pretty'
+  REXML_FORMATTERS=true
+rescue LoadError
+  REXML_FORMATTERS=false
+end
+
+begin
+  require 'curb'
+  CURL_LOADED=true
+rescue LoadError
+  CURL_LOADED=false
+end
+
 begin
-    require 'net/http/post/multipart'
+  require 'net/http/post/multipart'
+  MULTIPART_LOADED=true
 rescue LoadError
+  MULTIPART_LOADED=false
 end
 
 ###############################################################################
@@ -30,85 +49,100 @@ end
 # Cloud Client
 ###############################################################################
 module CloudClient
-    # #########################################################################
-    # Default location for the authentication file
-    # #########################################################################
-    DEFAULT_AUTH_FILE = ENV["HOME"]+"/.one/one_auth"
-
-    # #########################################################################
-    # Gets authorization credentials from ONE_AUTH or default
-    # auth file.
-    #
-    # Raises an error if authorization is not found
-    # #########################################################################
-    def self.get_one_auth
-        if ENV["ONE_AUTH"] and !ENV["ONE_AUTH"].empty? and
-           File.file?(ENV["ONE_AUTH"])
-            one_auth=File.read(ENV["ONE_AUTH"]).strip.split(':')
-        elsif File.file?(DEFAULT_AUTH_FILE)
-            one_auth=File.read(DEFAULT_AUTH_FILE).strip.split(':')
-        else
-            raise "No authorization data present"
-        end
-
-        raise "Authorization data malformed" if one_auth.length < 2
-
-        one_auth
+  # #########################################################################
+  # Default location for the authentication file
+  # #########################################################################
+  DEFAULT_AUTH_FILE = ENV["HOME"]+"/.one/one_auth"
+
+  # #########################################################################
+  # Gets authorization credentials from ONE_AUTH or default
+  # auth file.
+  #
+  # Raises an error if authorization is not found
+  # #########################################################################
+  def self.get_one_auth
+    if ENV["ONE_AUTH"] and !ENV["ONE_AUTH"].empty? and
+       File.file?(ENV["ONE_AUTH"])
+      one_auth=File.read(ENV["ONE_AUTH"]).strip.split(':')
+    elsif File.file?(DEFAULT_AUTH_FILE)
+      one_auth=File.read(DEFAULT_AUTH_FILE).strip.split(':')
+    else
+      raise "No authorization data present"
     end
 
-    # #########################################################################
-    # Starts an http connection and calls the block provided. SSL flag
-    # is set if needed.
-    # #########################################################################
-    def self.http_start(url, &block)
-        http = Net::HTTP.new(url.host, url.port)
-        if url.scheme=='https'
-            http.use_ssl = true
-            http.verify_mode=OpenSSL::SSL::VERIFY_NONE
-        end
-
-        begin
-            http.start do |connection|
-                block.call(connection)
-            end
-        rescue Errno::ECONNREFUSED => e
-            str =  "Error connecting to server (#{e.to_s})."
-            str << "Server: #{url.host}:#{url.port}"
-
-            return CloudClient::Error.new(str)
-        end
+    raise "Authorization data malformed" if one_auth.length < 2
+
+    one_auth
+  end
+
+  # #########################################################################
+  # Starts an http connection and calls the block provided. SSL flag
+  # is set if needed.
+  # #########################################################################
+  def self.http_start(url, timeout, &block)
+    http = Net::HTTP.new(url.host, url.port)
+
+    if timeout
+      http.read_timeout = timeout.to_i
     end
 
-    # #########################################################################
-    # The Error Class represents a generic error in the Cloud Client
-    # library. It contains a readable representation of the error.
-    # #########################################################################
-    class Error
-        attr_reader :message
-
-        # +message+ a description of the error
-        def initialize(message=nil)
-            @message=message
-        end
-
-        def to_s()
-            @message
-        end
+    if url.scheme=='https'
+      http.use_ssl = true
+      http.verify_mode=OpenSSL::SSL::VERIFY_NONE
     end
 
-    # #########################################################################
-    # Returns true if the object returned by a method of the OpenNebula
-    # library is an Error
-    # #########################################################################
-    def self.is_error?(value)
-        value.class==CloudClient::Error
+    begin
+      res = http.start do |connection|
+        block.call(connection)
+      end
+    rescue Errno::ECONNREFUSED => e
+      str =  "Error connecting to server (#{e.to_s}).\n"
+      str << "Server: #{url.host}:#{url.port}"
+
+      return CloudClient::Error.new(str,"503")
+    rescue Errno::ETIMEDOUT => e
+      str =  "Error timeout connecting to server (#{e.to_s}).\n"
+      str << "Server: #{url.host}:#{url.port}"
+
+      return CloudClient::Error.new(str,"504")
+    rescue Timeout::Error => e
+      str =  "Error timeout while connected to server (#{e.to_s}).\n"
+      str << "Server: #{url.host}:#{url.port}"
+
+      return CloudClient::Error.new(str,"504")
     end
-end
 
-# Command line help functions
-module CloudCLI
-    # Returns the command name
-    def cmd_name
-        File.basename($0)
+    if res.is_a?(Net::HTTPSuccess)
+      res
+    else
+      CloudClient::Error.new(res.body, res.code)
     end
+  end
+
+  # #########################################################################
+  # The Error Class represents a generic error in the Cloud Client
+  # library. It contains a readable representation of the error.
+  # #########################################################################
+  class Error
+    attr_reader :message
+    attr_reader :code
+
+    # +message+ a description of the error
+    def initialize(message=nil, code="500")
+      @message=message
+      @code=code
+    end
+
+    def to_s()
+      @message
+    end
+  end
+
+  # #########################################################################
+  # Returns true if the object returned by a method of the OpenNebula
+  # library is an Error
+  # #########################################################################
+  def self.is_error?(value)
+    value.class==CloudClient::Error
+  end
 end

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

@@ -16,187 +16,327 @@
 #
 
 require 'rubygems'
-require 'uri'
 require 'rexml/document'
+require 'uri'
 
 require 'deltacloud/drivers/opennebula/cloud_client'
 
 
 module OCCIClient
 
-    #####################################################################
-    #  Client Library to interface with the OpenNebula OCCI Service
-    #####################################################################
-    class Client
-
-        ######################################################################
-        # Initialize client library
-        ######################################################################
-        def initialize(endpoint_str=nil, user=nil, pass=nil, debug_flag=true)
-            @debug = debug_flag
-
-            # Server location
-            if endpoint_str
-                @endpoint =  endpoint_str
-            elsif ENV["OCCI_URL"]
-                @endpoint = ENV["OCCI_URL"]
-            else
-                @endpoint = "http://localhost:4567"
-            end
-
-            # Autentication
-            if user && pass
-                @occiauth = [user, pass]
-            else
-                @occiauth = CloudClient::get_one_auth
-            end
-
-            if !@occiauth
-                raise "No authorization data present"
-            end
-
-            @occiauth[1] = Digest::SHA1.hexdigest(@occiauth[1])
-        end
+  #####################################################################
+  #  Client Library to interface with the OpenNebula OCCI Service
+  #####################################################################
+  class Client
+
+    attr_accessor :endpoint
+
+    ######################################################################
+    # Initialize client library
+    ######################################################################
+    def initialize(endpoint_str=nil, user=nil, pass=nil,
+             timeout=nil, debug_flag=true)
+      @debug   = debug_flag
+      @timeout = timeout
+
+      # Server location
+      @endpoint = ENV["OCCI_URL"] || endpoint_str || Proc.new(raise "No OpenNebula Provider location configured! Client needs to set \'X-Deltacloud-Provider\' HTTP request header, OR, Deltacloud server administrator must set either the OCCI_URL or API_PROVIDER environment variables")
+#"http://localhost:4567"
+
+      # Autentication
+      if user && pass
+        @occiauth = [user, pass]
+      else
+        @occiauth = CloudClient::get_one_auth
+      end
+
+      if !@occiauth
+        raise "No authorization data present"
+      end
+
+      @occiauth[1] = Digest::SHA1.hexdigest(@occiauth[1])
+    end
 
-        #################################
-        # Pool Resource Request Methods #
-        #################################
+    #################################
+    # Pool Resource Request Methods #
+    #################################
 
-        ######################################################################
-        # Post a new VM to the VM Pool
-        # :instance_type
-        # :xmlfile
-        ######################################################################
-        def post_vms(xmlfile)
-            xml=File.read(xmlfile)
+    def get_root
+      get('/')
+    end
+
+    ######################################################################
+    # Retieves the available Instance types
+    ######################################################################
+    def get_instance_types
+      get('/instance_type?verbose=yes')
+    end
 
-            url = URI.parse(@endpoint+"/compute")
+    ######################################################################
+    # Post a new VM to the VM Pool
+    # :xmlfile
+    ######################################################################
+    def post_vms(xmlfile)
+      post('/compute', xmlfile)
+    end
 
-            req = Net::HTTP::Post.new(url.path)
-            req.body=xml
+    ######################################################################
+    # Retieves the pool of Virtual Machines
+    ######################################################################
+    def get_vms
+      get('/compute')
+    end
 
-            req.basic_auth @occiauth[0], @occiauth[1]
+    ######################################################################
+    # Post a new Network to the VN Pool
+    # :xmlfile xml description of the Virtual Network
+    ######################################################################
+    def post_network(xmlfile)
+      post('/network', xmlfile)
+    end
 
-            res = CloudClient::http_start(url) do |http|
-                http.request(req)
-            end
+    ######################################################################
+    # Retieves the pool of Virtual Networks
+    ######################################################################
+    def get_networks
+      get('/network')
+    end
 
-            if CloudClient::is_error?(res)
-                return res
-            else
-                return res.body
-            end
-        end
+    ######################################################################
+    # Post a new Image to the Image Pool
+    # :xmlfile
+    ######################################################################
+    def post_image(xmlfile, curb=true)
+      xml        = File.read(xmlfile)
 
-        ######################################################################
-        # Retieves the pool of Virtual Machines
-        ######################################################################
-        def get_vms
-            url = URI.parse(@endpoint+"/compute")
-            req = Net::HTTP::Get.new(url.path)
+      begin
+        image_info = REXML::Document.new(xml).root
+      rescue Exception => e
+        error = CloudClient::Error.new(e.message)
+        return error
+      end
 
-            req.basic_auth @occiauth[0], @occiauth[1]
+      if image_info.elements['URL']
+        file_path = image_info.elements['URL'].text
 
-            res = CloudClient::http_start(url) {|http|
-                http.request(req)
-            }
+        m = file_path.match(/^\w+:\/\/(.*)$/)
 
-            if CloudClient::is_error?(res)
-                return res
-            else
-                return res.body
-            end
+        if m
+          file_path="/"+m[1]
         end
+      elsif !image_info.elements['TYPE'] == "DATABLOCK"
+        return CloudClient::Error.new("Can not find URL")
+      end
+
+      if curb
+        if !CURL_LOADED
+          error_msg = "curb gem not loaded"
+          error = CloudClient::Error.new(error_msg)
+          return error
+        end
+
+        curl=Curl::Easy.new(@endpoint+"/storage")
 
-        ######################################################################
-        # Retieves the pool of Images owned by the user
-        ######################################################################
-        def get_images
-            url = URI.parse(@endpoint+"/storage")
-            req = Net::HTTP::Get.new(url.path)
+        curl.http_auth_types     = Curl::CURLAUTH_BASIC
+        curl.userpwd             = "#{@occiauth[0]}:#{@occiauth[1]}"
+        curl.verbose             = true if @debug
+        curl.multipart_form_post = true
 
-            req.basic_auth @occiauth[0], @occiauth[1]
+        begin
+          postfields = Array.new
+          postfields << Curl::PostField.content('occixml', xml)
 
-            res = CloudClient::http_start(url) {|http|
-                http.request(req)
-            }
+          if file_path
+            postfields << Curl::PostField.file('file', file_path)
+          end
 
-            if CloudClient::is_error?(res)
-                return res
-            else
-                return res.body
-            end
+          curl.http_post(*postfields)
+        rescue Exception => e
+          return CloudClient::Error.new(e.message)
         end
 
-        ####################################
-        # Entity Resource Request Methods  #
-        ####################################
+        return curl.body_str
+      else
+        if !MULTIPART_LOADED
+          error_msg = "multipart-post gem not loaded"
+          error = CloudClient::Error.new(error_msg)
+          return error
+        end
 
-        ######################################################################
-        # :id VM identifier
-        ######################################################################
-        def get_vm(id)
-            url = URI.parse(@endpoint+"/compute/" + id.to_s)
-            req = Net::HTTP::Get.new(url.path)
+        params=Hash.new
 
-            req.basic_auth @occiauth[0], @occiauth[1]
+        if file_path
+          file=File.open(file_path)
+          params["file"]=UploadIO.new(file,
+            'application/octet-stream', file_path)
+        end
 
-            res = CloudClient::http_start(url) {|http|
-                http.request(req)
-            }
+        params['occixml'] = xml
 
-            if CloudClient::is_error?(res)
-                return res
-            else
-                return res.body
-            end
+        url = URI.parse(@endpoint+"/storage")
+
+        req = Net::HTTP::Post::Multipart.new(url.path, params)
+
+        req.basic_auth @occiauth[0], @occiauth[1]
+
+        res = CloudClient::http_start(url, @timeout) do |http|
+          http.request(req)
         end
 
-        ######################################################################
-        # Puts a new Compute representation in order to change its state
-        # :xmlfile Compute OCCI xml representation
-        ######################################################################
-        def put_vm(xmlfile)
-            xml=File.read(xmlfile)
-            vm_info=REXML::Document.new(xml).root.elements
+        file.close if file_path
 
-            url = URI.parse(@endpoint+'/compute/' + vm_info['ID'].text)
+        if CloudClient::is_error?(res)
+          return res
+        else
+          return res.body
+        end
+      end
+    end
 
-            req = Net::HTTP::Put.new(url.path)
-            req.body = xml
+    ######################################################################
+    # Retieves the pool of Images owned by the user
+    ######################################################################
+    def get_images
+      get('/storage')
+    end
 
-            req.basic_auth @occiauth[0], @occiauth[1]
 
-            res = CloudClient::http_start(url) do |http|
-                http.request(req)
-            end
+    ####################################
+    # Entity Resource Request Methods  #
+    ####################################
 
-            if CloudClient::is_error?(res)
-                return res
-            else
-                return res.body
-            end
-        end
+    ######################################################################
+    # :id VM identifier
+    ######################################################################
+    def get_vm(id)
+      get('/compute/'+id.to_s)
+    end
 
-       #######################################################################
-        # Retieves an Image
-        # :image_uuid Image identifier
-        ######################################################################
-        def get_image(image_uuid)
-            url = URI.parse(@endpoint+"/storage/"+image_uuid)
-            req = Net::HTTP::Get.new(url.path)
-
-            req.basic_auth @occiauth[0], @occiauth[1]
-
-            res = CloudClient::http_start(url) {|http|
-                http.request(req)
-            }
-
-            if CloudClient::is_error?(res)
-                return res
-            else
-                return res.body
-            end
-        end
+    ######################################################################
+    # Puts a new Compute representation in order to change its state
+    # :xmlfile Compute OCCI xml representation
+    ######################################################################
+    def put_vm(xmlfile)
+      put('/compute/', xmlfile)
+    end
+
+    ####################################################################
+    # :id Compute identifier
+    ####################################################################
+    def delete_vm(id)
+      delete('/compute/'+id.to_s)
+    end
+
+    ######################################################################
+    # Retrieves a Virtual Network
+    # :id Virtual Network identifier
+    ######################################################################
+    def get_network(id)
+      get('/network/'+id.to_s)
+    end
+
+    ######################################################################
+    # Puts a new Network representation in order to change its state
+    # :xmlfile Network OCCI xml representation
+    ######################################################################
+    def put_network(xmlfile)
+      put('/network/', xmlfile)
+    end
+
+    ######################################################################
+    # :id VM identifier
+    ######################################################################
+    def delete_network(id)
+      delete('/network/'+id.to_s)
+    end
+
+     #######################################################################
+    # Retieves an Image
+    # :image_uuid Image identifier
+    ######################################################################
+    def get_image(id)
+      get('/storage/'+id.to_s)
+    end
+
+    ######################################################################
+    # Puts a new Storage representation in order to change its state
+    # :xmlfile Storage OCCI xml representation
+    ######################################################################
+    def put_image(xmlfile)
+      put('/storage/', xmlfile)
+    end
+
+    ######################################################################
+    # :id VM identifier
+    ######################################################################
+    def delete_image(id)
+      delete('/storage/'+id.to_s)
+    end
+
+    private
+
+    def get(path)
+      url = URI.parse(@endpoint+path)
+      path = url.path
+      path << "?#{url.query}" if url.query
+      req = Net::HTTP::Get.new(path)
+
+      do_request(url, req)
+    end
+
+    def post(path, xmlfile)
+      url = URI.parse(@endpoint+path)
+      req = Net::HTTP::Post.new(url.path)
+
+      req.body=File.read(xmlfile)
+
+      do_request(url, req)
+    end
+
+    def delete(path, xmlfile)
+      url = URI.parse(@endpoint+path)
+      req = Net::HTTP::Delete.new(url.path)
+
+      do_request(url, req)
+    end
+
+    def put(path, xmlfile)
+      xml = File.read(xmlfile)
+
+      # Get ID from XML
+      begin
+        info = REXML::Document.new(xml).root
+      rescue Exception => e
+        error = CloudClient::Error.new(e.message)
+        return error
+      end
+
+      if info.elements['ID'] == nil
+        return CloudClient::Error.new("Can not find RESOURCE ID")
+      end
+
+      resource_id = info.elements['ID'].text
+
+      url = URI.parse(@endpoint+path + resource_id)
+      req = Net::HTTP::Put.new(url.path)
+
+      req.body = xml
+
+      do_request(url, req)
+    end
+
+    def do_request(url, req)
+      req.basic_auth @occiauth[0], @occiauth[1]
+
+      res = CloudClient::http_start(url, @timeout) do |http|
+        http.request(req)
+      end
+
+      if CloudClient::is_error?(res)
+        return res
+      else
+        return res.body
+      end
     end
+  end
 end