opennebula 4.90.10.rc1 → 5.0.0

data/lib/VirtualMachineDriver.rb

@@ -0,0 +1,376 @@
+# -------------------------------------------------------------------------- #
+# Copyright 2002-2016, OpenNebula Project, OpenNebula Systems                #
+#                                                                            #
+# Licensed 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 "OpenNebulaDriver"
+require "CommandManager"
+require 'base64'
+require 'rexml/document'
+
+# This class provides basic messaging and logging functionality
+# to implement OpenNebula Drivers. A driver is a program that
+# specialize the OpenNebula behavior by interfacing with specific
+# infrastructure functionalities.
+#
+# A Driver inherits this class and only has to provide methods
+# for each action it wants to receive. The method must be associated
+# with the action name through the register_action function
+class VirtualMachineDriver < OpenNebulaDriver
+
+    # Virtual Machine Driver Protocol constants
+    ACTION = {
+        :deploy      => "DEPLOY",
+        :shutdown    => "SHUTDOWN",
+        :reboot      => "REBOOT",
+        :reset       => "RESET",
+        :cancel      => "CANCEL",
+        :save        => "SAVE",
+        :restore     => "RESTORE",
+        :migrate     => "MIGRATE",
+        :poll        => "POLL",
+        :log         => "LOG",
+        :attach_disk => "ATTACHDISK",
+        :detach_disk => "DETACHDISK",
+        :snapshot_create => "SNAPSHOTCREATE",
+        :snapshot_revert => "SNAPSHOTREVERT",
+        :snapshot_delete => "SNAPSHOTDELETE",
+        :cleanup         => "CLEANUP",
+        :attach_nic  => "ATTACHNIC",
+        :detach_nic  => "DETACHNIC",
+        :disk_snapshot_create => "DISKSNAPSHOTCREATE",
+        :update_sg   => "UPDATESG"
+    }
+
+    POLL_ATTRIBUTE = {
+        :memory          => "MEMORY",
+        :cpu             => "CPU",
+        :nettx           => "NETTX",
+        :netrx           => "NETRX",
+        :state           => "STATE",
+        :disk_size       => "DISK_SIZE",
+        :snapshot_size   => "SNAPSHOT_SIZE"
+    }
+
+    VM_STATE = {
+        :active  => 'a',
+        :paused  => 'p',
+        :error   => 'e',
+        :deleted => 'd',
+        :unknown => '-'
+    }
+
+    HOST_ARG = 1
+
+    # Register default actions for the protocol.
+    #
+    # @param [String] directory path inside remotes path where the scripts
+    #   reside
+    # @param [Hash] options options for OpenNebula driver (check the available
+    #   options in {OpenNebulaDriver#initialize})
+    # @option options [Boolean] :threaded (true) enables or disables threads
+    def initialize(directory, options={})
+        @options={
+            :threaded    => true,
+            :single_host => true
+        }.merge!(options)
+
+        super(directory, @options)
+
+        @hosts   = Array.new
+
+        register_action(ACTION[:deploy].to_sym,      method("deploy"))
+        register_action(ACTION[:shutdown].to_sym,    method("shutdown"))
+        register_action(ACTION[:reboot].to_sym,      method("reboot"))
+        register_action(ACTION[:reset].to_sym,       method("reset"))
+        register_action(ACTION[:cancel].to_sym,      method("cancel"))
+        register_action(ACTION[:save].to_sym,        method("save"))
+        register_action(ACTION[:restore].to_sym,     method("restore"))
+        register_action(ACTION[:migrate].to_sym,     method("migrate"))
+        register_action(ACTION[:poll].to_sym,        method("poll"))
+        register_action(ACTION[:attach_disk].to_sym, method("attach_disk"))
+        register_action(ACTION[:detach_disk].to_sym, method("detach_disk"))
+        register_action(ACTION[:snapshot_create].to_sym, method("snapshot_create"))
+        register_action(ACTION[:snapshot_revert].to_sym, method("snapshot_revert"))
+        register_action(ACTION[:snapshot_delete].to_sym, method("snapshot_delete"))
+        register_action(ACTION[:cleanup].to_sym,    method("cleanup"))
+        register_action(ACTION[:attach_nic].to_sym, method("attach_nic"))
+        register_action(ACTION[:detach_nic].to_sym, method("detach_nic"))
+        register_action(ACTION[:disk_snapshot_create].to_sym, method("disk_snapshot_create"))
+        register_action(ACTION[:update_sg].to_sym, method("update_sg"))
+    end
+
+    # Decodes the encoded XML driver message received from the core
+    #
+    # @param [String] drv_message the driver message
+    # @return [REXML::Element] the root element of the decoded XML message
+    def decode(drv_message)
+        message = Base64.decode64(drv_message)
+        xml_doc = REXML::Document.new(message)
+
+        xml_doc.root
+    end
+
+    # Execute a command associated to an action and id in a remote host.
+    def remotes_action(command, id, host, action, remote_dir, std_in=nil)
+        super(command,id,host,ACTION[action],remote_dir,std_in)
+    end
+
+    # Execute a command associated to an action and id on localhost
+    def local_action(command, id, action)
+        super(command,id,ACTION[action])
+    end
+
+    # Virtual Machine Manager Protocol Actions (generic implementation)
+    def deploy(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:deploy],RESULT[:failure],id,error)
+    end
+
+    def shutdown(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:shutdown],RESULT[:failure],id,error)
+    end
+
+    def reboot(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:reboot],RESULT[:failure],id,error)
+    end
+
+    def reset(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:reset],RESULT[:failure],id,error)
+    end
+
+    def cancel(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:cancel],RESULT[:failure],id,error)
+    end
+
+    def save(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:save],RESULT[:failure],id,error)
+    end
+
+    def restore(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:restore],RESULT[:failure],id,error)
+    end
+
+    def migrate(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:migrate],RESULT[:failure],id,error)
+    end
+
+    def poll(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:poll],RESULT[:failure],id,error)
+    end
+
+    def attach_disk(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:attach_disk],RESULT[:failure],id,error)
+    end
+
+    def detach_disk(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:detach_disk],RESULT[:failure],id,error)
+    end
+
+    def attach_nic(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:attach_nic],RESULT[:failure],id,error)
+    end
+
+    def detach_nic(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:detach_nic],RESULT[:failure],id,error)
+    end
+
+    def snapshot_create(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:snapshot_create],RESULT[:failure],id,error)
+    end
+
+    def snapshot_revert(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:snapshot_revert],RESULT[:failure],id,error)
+    end
+
+    def snapshot_delete(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:snapshot_delete],RESULT[:failure],id,error)
+    end
+
+    def disk_snapshot_create(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:disk_snapshot_create],RESULT[:failure],id,error)
+    end
+
+    def update_sg(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:update_sg],RESULT[:failure],id,error)
+    end
+
+    def cleanup(id, drv_message)
+        error = "Action not implemented by driver #{self.class}"
+        send_message(ACTION[:cleanup],RESULT[:failure],id,error)
+    end
+
+private
+
+    # Interface to handle the pending events from the ActionManager Interface
+    def delete_running_action(action_id)
+        if @options[:single_host]
+            delete_running_action_single_host(action_id)
+        else
+            super(action_id)
+        end
+    end
+
+    def delete_running_action_single_host(action_id)
+        action=@action_running[action_id]
+        if action
+            @hosts.delete(action[:host])
+            @action_running.delete(action_id)
+        end
+    end
+
+    def get_first_runable
+        if @options[:single_host]
+            get_first_runable_single_host
+        else
+            super
+        end
+    end
+
+    def get_first_runable_single_host
+        action_index=nil
+        @action_queue.each_with_index do |action, index|
+            if !action.keys.include?(:host)
+                if action[:args].length == 2
+                    begin
+                        xml=decode(action[:args].last)
+                        host=xml.elements['HOST']
+                        action[:host]=host.text if host
+                    rescue
+                        action[:host]=nil
+                    end
+                else
+                    action[:host]=nil
+                end
+            end
+
+            if action.keys.include?(:host) && action[:host]
+                if !@hosts.include?(action[:host])
+                    action_index=index
+                    break
+                end
+           else
+                action_index=index
+                break
+           end
+        end
+
+        return action_index
+    end
+
+    def get_runable_action
+        if @options[:single_host]
+            get_runable_action_single_host
+        else
+            super
+        end
+    end
+
+    def get_runable_action_single_host
+        action_index=get_first_runable
+
+        if action_index
+            action=@action_queue[action_index]
+        else
+            action=nil
+        end
+
+        if action
+            @hosts << action[:host] if action[:host]
+            @action_queue.delete_at(action_index)
+        end
+
+        return action
+    end
+
+    def empty_queue
+        if @options[:single_host]
+            empty_queue_single_host
+        else
+            super
+        end
+    end
+
+    def empty_queue_single_host
+        get_first_runable==nil
+    end
+end
+
+################################################################
+################################################################
+
+if __FILE__ == $0
+
+    class TemplateDriver < VirtualMachineDriver
+        def initialize
+            super('vmm/dummy',
+                :concurrency => 15,
+                :threaded => true)
+        end
+
+        def deploy(id, host, remote_dfile, not_used)
+            #MUST return deploy_id if deployment was successfull
+            deploy_id = "-"
+            send_message(ACTION[:deploy],RESULT[:success],id,deploy_id)
+        end
+
+        def shutdown(id, host, deploy_id, not_used)
+            send_message(ACTION[:shutdown],RESULT[:success],id)
+        end
+
+        def cancel(id, host, deploy_id, not_used)
+            send_message(ACTION[:cancel],RESULT[:success],id)
+        end
+
+        def save(id, host, deploy_id, file)
+            send_message(ACTION[:save],RESULT[:success],id)
+        end
+
+        def restore(id, host, deploy_id , file)
+            send_message(ACTION[:restore],RESULT[:success],id)
+        end
+
+        def migrate(id, host, deploy_id, dest_host)
+            send_message(ACTION[:migrate],RESULT[:success],id)
+        end
+
+        def poll(id, host, deploy_id, not_used)
+            # monitor_info: string in the form "VAR=VAL VAR=VAL ... VAR=VAL"
+            # known VAR are in POLL_ATTRIBUTES. VM states VM_STATES
+            monitor_info = "#{POLL_ATTRIBUTE[:state]}=#{VM_STATE[:active]} " \
+                           "#{POLL_ATTRIBUTE[:nettx]}=12345"
+
+            send_message(ACTION[:poll],RESULT[:success],id,monitor_info)
+        end
+    end
+
+    sd = TemplateDriver.new
+    sd.start_driver
+end

data/lib/cloud/CloudClient.rb

@@ -50,7 +50,7 @@ end
 module CloudClient
 
     # OpenNebula version
-    VERSION = '4.90.10'
+    VERSION = '5.0.0'
 
     # #########################################################################
     # Default location for the authentication file

data/lib/opennebula/virtual_machine.rb

@@ -112,6 +112,7 @@ module OpenNebula
             DISK_SNAPSHOT_REVERT_SUSPENDED
             DISK_SNAPSHOT_DELETE_SUSPENDED
             DISK_SNAPSHOT
+            DISK_SNAPSHOT_REVERT
             DISK_SNAPSHOT_DELETE
             PROLOG_MIGRATE_UNKNOWN
             PROLOG_MIGRATE_UNKNOWN_FAILURE

data/lib/opennebula.rb

@@ -66,5 +66,5 @@ require 'opennebula/marketplaceapp_pool'
 module OpenNebula
 
     # OpenNebula version
-    VERSION = '4.90.10'
+    VERSION = '5.0.0'
 end