0001-Implemented-CPU-and-memory-hotplugging.patch - OpenNebula - OpenNebula Development pages

     About the scale-in features:
     -(Implement KVM's scaling methods)
     -If we want VCPU hotpluging to be more useful, we must also take care of scaling the CPU share on the hypervisor
     -Check/Separate variable used to monitor used memory and variable used to set new memory amount
     -Check the aftermath of adding new states to the LCM
     -Register VM changes to either the VM history or to new VM attributes
     -Find a better way to inform the user in case of scale-in failure
     -Extend polling/monitoring to get number of VCPUs
     -When a scaling attempt fails, force a poll request
     -Write tests

         int reboot(
             int vid);
          /**
          *  Change the amount of memory of the VM online.
          *  The VM MUST have its mutex locked. If the function fails
          *  the calling funtion is responsible for recovering from the error.
          *    @param vm pointer to a VirtualMachine with its mutex locked.
          *    @return 0 on success
          */
         int memset(
             VirtualMachine * vm);
          /**
          *  Change the number of VCPUs of the VM online.
          *  The VM MUST have its mutex locked. If the function fails
          *  the calling funtion is responsible for recovering from the error.
          *    @param vm pointer to a VirtualMachine with its mutex locked.
          *    @return 0 on success
          */
         int vcpuset(
             VirtualMachine * vm);
     private:
         /**
          *  Thread id for the Dispatch Manager

             CANCEL_FAILURE,   /**< Sent by the VMM when a cancel action fails     */
             MONITOR_FAILURE,  /**< Sent by the VMM when a VM has failed while active */
             MONITOR_SUSPEND,  /**< Sent by the VMM when a VM is paused while active */
             MONITOR_DONE,     /**< Sent by the VMM when a VM is not found */
             MONITOR_DONE,     /**< Sent by the VMM when a VM is not found         */
             SCALE_MEMORY_SUCCESS,/**< Sent by the VMM when a memory scaling action succeeds*/
             SCALE_MEMORY_FAILURE,/**< Sent by the VMM when a memory scaling action fails*/
             SCALE_VCPU_SUCCESS,/**< Sent by the VMM when a vcpu scaling action succeeds*/
             SCALE_VCPU_FAILURE,/**< Sent by the VMM when a vcpu scaling action fails*/
             PROLOG_SUCCESS,   /**< Sent by the TM when the prolog phase succeeds  */
             PROLOG_FAILURE,   /**< Sent by the TM when the prolog phase fails     */
             EPILOG_SUCCESS,   /**< Sent by the TM when the epilog phase succeeds  */
-...
             REBOOT,           /**< Sent by the DM to reboot a running VM          */
             DELETE,           /**< Sent by the DM to delete a VM                  */
             CLEAN,            /**< Sent by the DM to cleanup a VM for resubmission*/
             SCALE_MEMORY,     /**< Sent by the DM to change VM memory size        */
             SCALE_VCPU,       /**< Sent by the DM to change VM number of VCPUs    */
             FINALIZE
         };
-...
         void monitor_done_action(int vid);
         void scale_memory_success_action(int vid);
         void scale_memory_failure_action(int vid);
         void scale_vcpu_success_action(int vid);
         void scale_vcpu_failure_action(int vid);
         void prolog_success_action(int vid);
         void prolog_failure_action(int vid);
-...
         void clean_action(int vid);
         void scale_memory_action(int vid);
         void scale_vcpu_action(int vid);
         void timer_action();
     };

     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     class VirtualMachineMemSet : public RequestManagerVirtualMachine
+    {
     public:
         VirtualMachineMemSet():
             RequestManagerVirtualMachine("VirtualMachineMemSet",
                                "Change the amount of memory of the given VM online",
                                "A:siiss"){}; // FIXME What is that third argument?
         ~VirtualMachineMemSet(){};
         void request_execute(xmlrpc_c::paramList const& _paramList,
                 RequestAttributes& att);
     };
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     class VirtualMachineVcpuSet : public RequestManagerVirtualMachine
+    {
     public:
         VirtualMachineVcpuSet():
             RequestManagerVirtualMachine("VirtualMachineVcpuSet",
                                "Change the number of VCPUs of the given VM online",
                                "A:siiss"){}; // FIXME What is that third argument?
         ~VirtualMachineVcpuSet(){};
         void request_execute(xmlrpc_c::paramList const& _paramList,
                 RequestAttributes& att);
     };
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     #endif

         void update_info(
             const int _memory,
             const int _cpu,
             const int _vcpu,
             const int _net_tx,
             const int _net_rx)
+        {
-...
                 cpu    = _cpu;
+            }
             if (_vcpu != -1)
+            {
                 vcpu    = _vcpu;
+            }
             if (_net_tx != -1)
+            {
                 net_tx = _net_tx;
-...
          *    @return 0 on success.
          */
         int  parse_template_attribute(const string& attribute, string& parsed);
         /**
          *  Factory method for virtual machine templates
          */
-...
          */
         void get_requirements (int& cpu, int& memory, int& disk);
          /**
          *  Get the VM's amount of memory.
          *    @return the amount of memory in MB
          */
         const string get_memory()
+        {
             ostringstream oss;
             oss << memory;
             return oss.str();
+        }
          /**
          *  Get the VM's number of VCPUs.
          *    @return the number of VCPUs
          */
         const string get_vcpu()
+        {
             ostringstream oss;
             oss << vcpu;
             return oss.str();
+        }
         // ------------------------------------------------------------------------
         // Network Leases & Disk Images
         // ------------------------------------------------------------------------
-...
          *    @param  ar the AuthRequest object
          *    @param  tmpl the virtual machine template
          */
         static void set_auth_request(int uid,
                                      AuthRequest& ar,
         static void set_auth_request(int uid,
                                      AuthRequest& ar,
                                      VirtualMachineTemplate *tmpl);
     private:
-...
         int         cpu;
         /**
          *  VCPU number
          */
         int         vcpu;
         /**
          *  Network usage, transmitted Kilobytes
          */
         int         net_tx;
-...
         // Constructor
         //**************************************************************************
         VirtualMachine(int id,
         VirtualMachine(int id,
                        int uid,
                        int gid,
                        int gid,
                        const string& uname,
                        const string& gname,
                        VirtualMachineTemplate * _vm_template);

             VirtualMachinePool *      _vmpool,
             HostPool *                _hpool,
             time_t                    _timer_period,
             time_t                    _poll_period,
             int                       _vm_limit,
             time_t                    _poll_period,
             int                       _vm_limit,
             vector<const Attribute*>& _mads);
         ~VirtualMachineManager(){};
-...
             MIGRATE,
             RESTORE,
             REBOOT,
             SCALE_MEMORY,
             SCALE_VCPU,
             POLL,
             TIMER,
             DRIVER_CANCEL,
-...
          *  Triggers specific actions to the Virtual Machine Manager. This function
          *  wraps the ActionManager trigger function.
          *    @param action the VMM action
          *    @param vid VM unique id. This is the argument of the passed to the
          *    @param vid VM unique id. This is the argument of the passed to the
          *    invoked action.
          */
         virtual void trigger(
-...
             int     vid);
         /**
          *  This functions starts the associated listener thread, and creates a
          *  This functions starts the associated listener thread, and creates a
          *  new thread for the Virtual Machine Manager. This thread will wait in
          *  an action loop till it receives ACTION_FINALIZE.
          *    @return 0 on success.
-...
+        {
             return vmm_thread;
         };
         /**
          *  Loads Virtual Machine Manager Mads defined in configuration file
          *   @param uid of the user executing the driver. When uid is 0 the nebula
          *   @param uid of the user executing the driver. When uid is 0 the nebula
          *   identity will be used. Otherwise the Mad will be loaded through the
          *   sudo application.
          *   sudo application.
          */
         void load_mads(int uid);
     private:
         /**
          *  Thread id for the Virtual Machine Manager
-...
          *  Pointer to the Host Pool, to access hosts
          */
         HostPool *              hpool;
         /**
          *  Timer period for the Virtual Machine Manager.
          */
-...
         ActionManager           am;
         /**
          *  Function to execute the Manager action loop method within a new pthread
          *  Function to execute the Manager action loop method within a new pthread
          * (requires C linkage)
          */
         friend void * vmm_action_loop(void *arg);
-...
         };
         /**
          *  Returns a pointer to a Virtual Machine Manager driver. The driver is
          *  Returns a pointer to a Virtual Machine Manager driver. The driver is
          *  searched by its name.
          *    @param name the name of the driver
          *    @return the VM driver owned by uid with attribute name equal to value
-...
             return static_cast<const VirtualMachineManagerDriver *>
                    (MadManager::get(0,_name,name));
         };
         /**
          *  The action function executed when an action is triggered.
          *    @param action the name of the action
-...
          *    @param hostname of the host to perform the action
          *    @param net_drv name of the vlan driver
          *    @param m_hostname name of the host to migrate the VM
          *    @param m_net_drv name of the vlan driver
          *    @param m_net_drv name of the vlan driver
          *    @param domain domain id as returned by the hypervisor
          *    @param dfile deployment file to boot the VM
          *    @param cfile checkpoint file to save the VM
-...
             const string& m_hostname,
             const string& m_net_drv,
             const string& domain,
             const string& memory,
             const string& vcpu,
             const string& ldfile,
             const string& rdfile,
             const string& cfile,
             const string& tmpl);
         /**
          *  Function executed when a DEPLOY action is received. It deploys a VM on
          *  a Host.
-...
             int vid);
         /**
          *  Function to stop a running VM and generate a checkpoint file. This
          *  Function to stop a running VM and generate a checkpoint file. This
          *  function is executed when a SAVE action is triggered.
          *    @param vid the id of the VM.
          */
-...
             int vid);
         /**
          *  Scale the memory of a running VM.
          *    @param vid the id of the VM.
          */
         void scale_memory_action(
             int vid);
         /**
          *  Scale the number of vcpu of a running VM.
          *    @param vid the id of the VM.
          */
         void scale_vcpu_action(
             int vid);
         /**
          *  Polls a VM.
          *    @param vid the id of the VM.
          */
         void poll_action(
             int vid);
         /**
          *  This function is executed periodically to poll the running VMs
          */

      *  VirtualMachineManagerDriver provides a base class to implement VM Manager
      *  Drivers. This class implements the protocol and recover functions
      *  from the Mad interface. Classes derived from the VirtualMachineManagerDriver
      *  must implement the deployment function to generate specific VM
      *  must implement the deployment function to generate specific VM
      *  deployment information for the unerlying MAD.
      */
     class VirtualMachineManagerDriver : public Mad
-...
             string&     message);
         /**
          *  TODO: What do we need here? just poll the active VMs to recover
          *  TODO: What do we need here? just poll the active VMs to recover
          *  connections? Or an specific recover action from the MAD?
          */
         void recover();
-...
         virtual int deployment_description(
             const VirtualMachine *  vm,
             const string&           file_name) const = 0;
     protected:
     protected:
         /**
          *  Gets a configuration attr from driver configuration file (single
          *  Gets a configuration attr from driver configuration file (single
          *  version)
          *    @param name of config attribute
          *    @param value of the attribute
          */
         void get_default(
         	const char *  name,
           const char *  name,
             string&       value) const
+        {
         	string sn = name;
         	driver_conf.get(sn,value);
+        }
           string sn = name;
           driver_conf.get(sn,value);
+        }
         /**
          *  Gets a configuration attr from driver configuration file (vector
          *  Gets a configuration attr from driver configuration file (vector
          *  version)
          *    @param name of config vector attribute for the domain
          *    @param vname of the attribute
-...
         	const char *  name,
         	const char *  vname,
             string&       value) const;
     private:
     	/**
     private:
     	/**
     	 *  Configuration file for the driver
     	 */
     	Template	driver_conf;
         /**
          *  Pointer to the Virtual Machine Pool, to access VMs
          */
         VirtualMachinePool * vmpool;
         friend class VirtualMachineManager;
         /**
          *  Sends a deploy request to the MAD: "DEPLOY ID XML_DRV_MSG"
          *    @param oid the virtual machine id.
-...
             const string& drv_msg) const;
         /**
          *  Sends a scale memory request to the MAD: "SCALE_MEMORY ID MEMORY"
          *    @param oid the virtual machine id.
          *    @param drv_msg xml data for the mad operation
          */
         void scale_memory (
             const int     oid,
             const string& drv_msg) const;
         /**
          *  Sends a scale vcpu request to the MAD: "SCALE_VCPU ID VCPU"
          *    @param oid the virtual machine id.
          *    @param drv_msg xml data for the mad operation
          */
         void scale_vcpu (
             const int     oid,
             const string& drv_msg) const;
         /**
          *  Sends a poll request to the MAD: "POLL ID XML_DRV_MSG"
          *    @param oid the virtual machine id.
          *    @param drv_msg xml data for the mad operation

                         src/vmm_mad/remotes/xen/save \
                         src/vmm_mad/remotes/xen/poll \
                         src/vmm_mad/remotes/xen/poll_ganglia \
                         src/vmm_mad/remotes/xen/shutdown"
                         src/vmm_mad/remotes/xen/shutdown \
                         src/vmm_mad/remotes/xen/scale_memory \
                         src/vmm_mad/remotes/xen/scale_vcpu"
     #-------------------------------------------------------------------------------
     # VMM Driver VMWARE scripts, to be installed under $REMOTES_LOCATION/vmm/vmware

     .IP "" 0
+    .
     .IP "\(bu" 4
     memset \fIrange|vmid_list\fR \fImemory\fR
+    .
     .IP "" 4
+    .
     .nf
     Change the amount of memory of the given VM online
     States: RUNNING
+    .
     .fi
+    .
     .IP "" 0
+    .
     .IP "\(bu" 4
     vcpuset \fIrange|vmid_list\fR \fIvcpu\fR
+    .
     .IP "" 4
+    .
     .nf
     Change the number of VCPUs of the given VM online
     States: RUNNING
+    .
     .fi
+    .
     .IP "" 0
+    .
     .IP "" 0
+    .
     .SH "ARGUMENT FORMATS"
-...
     .IP "" 0
+    .
     .IP "\(bu" 4
     memory
+    .
     .IP "" 4
+    .
     .nf
     OpenNebula VM amount of memory
+    .
     .fi
+    .
     .IP "" 0
+    .
     .IP "\(bu" 4
     vcpu
+    .
     .IP "" 4
+    .
     .nf
     OpenNebula VM number of VPUs
+    .
     .fi
+    .
     .IP "" 0
+    .
     .IP "" 0
+    .
     .SH "LICENSE"

             end
             table
     		end
         def memory_to_i(memory)
             if memory.match(/^[0123456789]+$/)
                 return 0,memory.to_i
             else
                 return -1,"amount memory must be a positive number"
             end
         end
         def vcpu_to_i(vcpu)
             if vcpu.match(/^[0123456789]+$/)
                 return 0,vcpu.to_i
             else
                 return -1,"number of vcpus must be a positive number"
             end
         end
         def self.memory_to_i_desc
             "OpenNebula VM amount of memory"
         end
         def self.vcpu_to_i_desc
             "OpenNebula VM number of VPUs"
         end
         private

             helper.filterflag_to_i(arg)
         end
         set :format, :memory, OneVMHelper.memory_to_i_desc do |arg|
             helper.memory_to_i(arg)
         end
         set :format, :vcpu, OneVMHelper.vcpu_to_i_desc do |arg|
             helper.vcpu_to_i(arg)
         end
         ########################################################################
         # Commands
         ########################################################################
-...
                 :options=>CLIHelper::OPTIONS+OpenNebulaHelper::OPTIONS do
             helper.list_pool(options, true, args[0])
         end
         memset_desc = <<-EOT.unindent
             Change the amount of memory of the given VM online
             States: RUNNING
         EOT
         command :memset, memset_desc, [:range,:vmid_list], :memory do
             helper.perform_actions(args[0],options,"Hot resizing memory") do |vm|
                 vm.memset(args[1])
             end
         end
         vcpuset_desc = <<-EOT.unindent
             Change the number of VCPUs of the given VM online
             States: RUNNING
         EOT
         command :vcpuset, vcpuset_desc, [:range,:vmid_list], :vcpu do
             helper.perform_actions(args[0],options,"Hotpluging/Hotunplugin VCPUs") do |vm|
                 vm.vcpuset(args[1])
             end
         end
     end

         return rc;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int DispatchManager::memset (
         VirtualMachine *    vm)
+    {
         ostringstream oss;
         int           vid;
         if ( vm == 0 )
+        {
             return -1;
+        }
         vid = vm->get_oid();
         oss << "Scaling memory of VM " << vid;
         NebulaLog::log("DiM",Log::DEBUG,oss);
         if ( vm->get_state() == VirtualMachine::RUNNING )
+        {
             Nebula&             nd  = Nebula::instance();
             LifeCycleManager *  lcm = nd.get_lcm();
             lcm->trigger(LifeCycleManager::SCALE_MEMORY,vid);
+        }
         else
+        {
             goto error;
+        }
         vm->unlock();
         return 0;
     error:
         oss.str("");
         oss << "Could not scale the memory of VM " << vid << ", wrong state.";
         NebulaLog::log("DiM",Log::ERROR,oss);
         vm->unlock();
         return -1;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int DispatchManager::vcpuset (
         VirtualMachine *    vm)
+    {
         ostringstream oss;
         int           vid;
         if ( vm == 0 )
+        {
             return -1;
+        }
         vid = vm->get_oid();
         oss << "Scaling the number of VCPUs of VM " << vid;
         NebulaLog::log("DiM",Log::DEBUG,oss);
         if ( vm->get_state() == VirtualMachine::RUNNING )
+        {
             Nebula&             nd  = Nebula::instance();
             LifeCycleManager *  lcm = nd.get_lcm();
             lcm->trigger(LifeCycleManager::SCALE_VCPU,vid);
+        }
         else
+        {
             goto error;
+        }
         vm->unlock();
         return 0;
     error:
         oss.str("");
         oss << "Could not scale the number of VCPUs of VM " << vid << ", wrong state.";
         NebulaLog::log("DiM",Log::ERROR,oss);
         vm->unlock();
         return -1;
+    }

     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void  LifeCycleManager::scale_memory_action(int vid)
+    {
         VirtualMachine * vm;
         vm = vmpool->get(vid,true);
         if ( vm == 0 )
+        {
             return;
+        }
         if (vm->get_state() == VirtualMachine::ACTIVE &&
             vm->get_lcm_state() == VirtualMachine::RUNNING)
+        {
             Nebula&           nd = Nebula::instance();
             VirtualMachineManager * vmm = nd.get_vmm();
             vm->log("LCM",Log::INFO,"Attempting to scale VM's memory");
             vmm->trigger(VirtualMachineManager::SCALE_MEMORY,vid);
+        }
         else
+        {
             vm->log("LCM", Log::ERROR, "scale_memory_action, VM in a wrong state.");
+        }
         vm->unlock();
         return;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void  LifeCycleManager::scale_vcpu_action(int vid)
+    {
         VirtualMachine * vm;
         vm = vmpool->get(vid,true);
         if ( vm == 0 )
+        {
             return;
+        }
         if (vm->get_state() == VirtualMachine::ACTIVE &&
             vm->get_lcm_state() == VirtualMachine::RUNNING)
+        {
             Nebula&           nd = Nebula::instance();
             VirtualMachineManager * vmm = nd.get_vmm();
             vm->log("LCM",Log::INFO,"Attempting to scale VM's number of VCPUs");
             vmm->trigger(VirtualMachineManager::SCALE_VCPU,vid);
+        }
         else
+        {
             vm->log("LCM", Log::ERROR, "scale_vcpu_action, VM in a wrong state.");
+        }
         vm->unlock();
         return;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void  LifeCycleManager::clean_up_vm(VirtualMachine * vm)
+    {
-...
             case VirtualMachine::FAILURE:
                 tm->trigger(TransferManager::EPILOG_DELETE,vid);
             break;
             default: //LCM_INIT,CLEANUP
             break;
+        }

             aname = "MONITOR_DONE";
             break;
         case SCALE_MEMORY_SUCCESS:
             aname = "SCALE_MEMORY_SUCCESS";
             break;
         case SCALE_MEMORY_FAILURE:
             aname = "SCALE_MEMORY_FAILURE";
             break;
         case SCALE_VCPU_SUCCESS:
             aname = "SCALE_VCPU_SUCCESS";
             break;
         case SCALE_VCPU_FAILURE:
             aname = "SCALE_VCPU_FAILURE";
             break;
         case PROLOG_SUCCESS:
             aname = "PROLOG_SUCCESS";
             break;
-...
             aname = "CLEAN";
             break;
         case SCALE_MEMORY:
             aname = "SCALE_MEMORY";
             break;
         case SCALE_VCPU:
             aname = "SCALE_VCPU";
             break;
         case FINALIZE:
             aname = ACTION_FINALIZE;
             break;
-...
+        {
             monitor_done_action(vid);
+        }
         else if (action == "SCALE_MEMORY_SUCCESS")
+        {
             scale_memory_success_action(vid);
+        }
         else if (action == "SCALE_MEMORY_FAILURE")
+        {
             scale_memory_failure_action(vid);
+        }
         else if (action == "SCALE_VCPU_SUCCESS")
+        {
             scale_vcpu_success_action(vid);
+        }
         else if (action == "SCALE_VCPU_FAILURE")
+        {
             scale_vcpu_failure_action(vid);
+        }
         else if (action == "PROLOG_SUCCESS")
+        {
             prolog_success_action(vid);
-...
+        {
             clean_action(vid);
+        }
         else if (action == "SCALE_MEMORY")
+        {
             scale_memory_action(vid);
+        }
         else if (action == "SCALE_VCPU")
+        {
             scale_vcpu_action(vid);
+        }
         else if (action == ACTION_FINALIZE)
+        {
             NebulaLog::log("LCM",Log::INFO,"Stopping Life-cycle Manager...");

         vm->unlock();
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void  LifeCycleManager::scale_memory_success_action(int vid)
+    {
         Nebula&             nd = Nebula::instance();
         VirtualMachine *    vm;
         vm = vmpool->get(vid,true);
         if ( vm == 0 )
+        {
             return;
+        }
         vm->log("LCM", Log::INFO, "Attempt to scale VM memory succeed");
         vm->unlock();
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void  LifeCycleManager::scale_memory_failure_action(int vid)
+    {
         Nebula&             nd = Nebula::instance();
         VirtualMachine *    vm;
         vm = vmpool->get(vid,true);
         if ( vm == 0 )
+        {
             return;
+        }
         /**
          * In case of failure, we can't do much...
          * - In case the VM's still running, we don't want to mark it
          *   as failed and/or unsable.
          * - If the amount of memory effectively changed but not enought
          *   to reach the target, we want to take into account the biggest
          *   possible amount of memory the VM is using to not mess with
          *   the scheduler.
+         *
          * I'm not aware of a better way to inform the user of the failure
          * than using the logging mechanism.
+         *
          * FIXME Better inform the user of the failure
          */
         // FIXME In case of scaling down, save the previous amount of memory
         vm->log("LCM", Log::ERROR, "Attempt to scale VM memory failed");
         vm->unlock();
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void  LifeCycleManager::scale_vcpu_success_action(int vid)
+    {
         Nebula&             nd = Nebula::instance();
         VirtualMachine *    vm;
         vm = vmpool->get(vid,true);
         if ( vm == 0 )
+        {
             return;
+        }
         vm->log("LCM", Log::INFO, "Attempt to scale VM number of VCPUs succeed");
         vm->unlock();
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void  LifeCycleManager::scale_vcpu_failure_action(int vid)
+    {
         Nebula&             nd = Nebula::instance();
         VirtualMachine *    vm;
         int memory = -1;
         int cpu    = -1;
         int net_tx = -1;
         int net_rx = -1;
         vm = vmpool->get(vid,true);
         if ( vm == 0 )
+        {
             return;
+        }
          /**
          * In case of failure, we can't do much...
          * - In case the VM's still running, we don't want to mark it
          *   as failed and/or unsable.
          * - We don't know how many VCPUs the VM has access to. As the
          *   number of VCPUs doesn't have an impact on VM scheduling (AFAIK)
          *   we set it to 0 so that the user might see that something went
          *   wrong.
+         *
          * I'm not aware of a better way to inform the user of the failure
          * than using the logging mechanism.
+         *
          * FIXME Better inform the user of the failure
          */
         vm->get_template_attribute("MEMORY",memory);
         vm->get_template_attribute("CPU",cpu);
         vm->get_template_attribute("NET_TX",net_tx);
         vm->get_template_attribute("NET_RX",net_rx);
         vm->update_info(memory,cpu,0,net_tx,net_rx);
         vm->log("LCM", Log::ERROR, "Attempt to scale VM number of VCPUs failed");
         vm->unlock();
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */

         # Virtual Machine Driver Protocol constants
         ACTION = {
             :deploy     => "DEPLOY",
             :shutdown   => "SHUTDOWN",
             :reboot     => "REBOOT",
             :cancel     => "CANCEL",
             :save       => "SAVE",
             :restore    => "RESTORE",
             :migrate    => "MIGRATE",
             :poll       => "POLL",
             :log        => "LOG"
             :deploy         => "DEPLOY",
             :shutdown       => "SHUTDOWN",
             :reboot         => "REBOOT",
             :cancel         => "CANCEL",
             :save           => "SAVE",
             :restore        => "RESTORE",
             :migrate        => "MIGRATE",
             :poll           => "POLL",
             :log            => "LOG",
             :scale_memory   => "SCALE_MEMORY",
             :scale_vcpu     => "SCALE_VCPU"
+        }
         POLL_ATTRIBUTE = {
-...
             @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[: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[:deploy].to_sym,         method("deploy"))
             register_action(ACTION[:shutdown].to_sym,       method("shutdown"))
             register_action(ACTION[:reboot].to_sym,         method("reboot"))
             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[:scale_memory].to_sym,   method("scale_memory"))
             register_action(ACTION[:scale_vcpu].to_sym,     method("scale_vcpu"))
             register_action(ACTION[:poll].to_sym,           method("poll"))
         end
         # Decodes the encoded XML driver message received from the core
-...
             send_message(ACTION[:migrate],RESULT[:failure],id,error)
         end
         def scale_memory(id, drv_message)
             error = "Action not implemented by driver #{self.class}"
             send_message(ACTION[:scale_memory],RESULT[:failure],id,error)
         end
         def scale_vcpu(id, drv_message)
             error = "Action not implemented by driver #{self.class}"
             send_message(ACTION[:scale_vcpu],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)
-...
                 send_message(ACTION[:migrate],RESULT[:success],id)
             end
             def scale_memory(id, host, deploy_id, memory)
                 send_message(ACTION[:scale_memory],RESULT[:success],id)
             end
             def scale_vcpu(id, host, deploy_id, vcpu)
                 send_message(ACTION[:scale_vcpu],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

                 :savedisk => "vm.savedisk",
                 :chown    => "vm.chown",
                 :chmod    => "vm.chmod",
                 :memset   => "vm.memset",
                 :vcpuset  => "vm.vcpuset",
+            }
             VM_STATE=%w{INIT PENDING HOLD ACTIVE STOPPED SUSPENDED DONE FAILED}
             VM_STATE=%w{INIT PENDING HOLD ACTIVE STOPPED SUSPENDED DONE FAILED MUTATING}
             LCM_STATE=%w{LCM_INIT PROLOG BOOT RUNNING MIGRATE SAVE_STOP SAVE_SUSPEND
                 SAVE_MIGRATE PROLOG_MIGRATE PROLOG_RESUME EPILOG_STOP EPILOG
-...
                 "STOPPED"   => "stop",
                 "SUSPENDED" => "susp",
                 "DONE"      => "done",
                 "FAILED"    => "fail"
                 "FAILED"    => "fail",
                 "MUTATING"  => "muta"
+            }
             SHORT_LCM_STATES={
-...
                     group_m, group_a, other_u, other_m, other_a)
             end
             # Change the amount of memory of the given VM online
             def memset(memory)
                 return Error.new('ID not defined') if !@pe_id
                 rc = @client.call(VM_METHODS[:memset], @pe_id, memory.to_i)
                 rc = nil if !OpenNebula.is_error?(rc)
                 return rc
             end
             # Change the number of VPUs of the given VM online
             def vcpuset(vcpu)
                 return Error.new('ID not defined') if !@pe_id
                 rc = @client.call(VM_METHODS[:vcpuset], @pe_id, vcpu.to_i)
                 rc = nil if !OpenNebula.is_error?(rc)
                 return rc
             end
             #######################################################################
             # Helpers to get VirtualMachine information
             #######################################################################

         xmlrpc_c::methodPtr vm_migrate(new VirtualMachineMigrate());
         xmlrpc_c::methodPtr vm_action(new VirtualMachineAction());
         xmlrpc_c::methodPtr vm_savedisk(new VirtualMachineSaveDisk());
         xmlrpc_c::methodPtr vm_memset(new VirtualMachineMemSet());
         xmlrpc_c::methodPtr vm_vcpuset(new VirtualMachineVcpuSet());
         // VirtualNetwork Methods
         xmlrpc_c::methodPtr vn_addleases(new VirtualNetworkAddLeases());
-...
         RequestManagerRegistry.addMethod("one.vm.info", vm_info);
         RequestManagerRegistry.addMethod("one.vm.chown", vm_chown);
         RequestManagerRegistry.addMethod("one.vm.chmod", vm_chmod);
         RequestManagerRegistry.addMethod("one.vm.memset", vm_memset);
         RequestManagerRegistry.addMethod("one.vm.vcpuset", vm_vcpuset);
         RequestManagerRegistry.addMethod("one.vmpool.info", vm_pool_info);

     #include "RequestManagerVirtualMachine.h"
     #include "PoolObjectAuth.h"
     #include "Nebula.h"
     #include "ostream"
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int RequestManagerVirtualMachine::get_host_information(int hid,
                                                     string& name,
     int RequestManagerVirtualMachine::get_host_information(int hid,
                                                     string& name,
                                                     string& vmm,
                                                     string& vnm,
                                                     RequestAttributes& att,
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void VirtualMachineMemSet::request_execute(xmlrpc_c::paramList const& paramList,
                                                  RequestAttributes& att)
+    {
         Nebula&     nd    = Nebula::instance();
         DispatchManager *   dm = nd.get_dm();
         int    id      = xmlrpc_c::value_int(paramList.getInt(1));
         int    memory  = xmlrpc_c::value_int(paramList.getInt(2));
         VirtualMachine * vm;
         string           vm_owner;
         int           rc;
         string        error_str;
         char *        error_char;
         if ( vm_authorization(id, 0, att, 0, 0) == false )
+        {
             return;
+        }
         if ( (vm = get_vm(id, att)) == 0 )
+        {
             return;
+        }
         if ( vm->get_state() != VirtualMachine::RUNNING )
+        {
             failure_response(ACTION,
                     request_error("Wrong state to perform action",""),
                     att);
             vm->unlock();
             return;
+        }
         // TODO Log action in VM History or in other VM attributes
         vm->update_info(memory,-1,-1,-1,-1);
         dm->memset(vm);
         vm->unlock();
         success_response(id, att);
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void VirtualMachineVcpuSet::request_execute(xmlrpc_c::paramList const& paramList,
                                                  RequestAttributes& att)
+    {
         Nebula&     nd    = Nebula::instance();
         DispatchManager *   dm = nd.get_dm();
         int    id      = xmlrpc_c::value_int(paramList.getInt(1));
         int    vcpu  = xmlrpc_c::value_int(paramList.getInt(2));
         VirtualMachine * vm;
         string           vm_owner;
         int           rc;
         string        error_str;
         char *        error_char;
         if ( vm_authorization(id, 0, att, 0, 0) == false )
+        {
             return;
+        }
         if ( (vm = get_vm(id, att)) == 0 )
+        {
             return;
+        }
         if ( vm->get_state() != VirtualMachine::RUNNING )
+        {
             failure_response(ACTION,
                     request_error("Wrong state to perform action",""),
                     att);
             vm->unlock();
             return;
+        }
         // TODO Log action in VM History or in other VM attributes
         vm->update_info(-1,-1,vcpu,-1,-1);
         dm->vcpuset(vm);
         vm->unlock();
         success_response(id, att);
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */

             deploy_id(""),
             memory(0),
             cpu(0),
             vcpu(0),
             net_tx(0),
             net_rx(0),
             history(0),
-...
             << "<DEPLOY_ID>" << deploy_id << "</DEPLOY_ID>"
             << "<MEMORY>"    << memory    << "</MEMORY>"
             << "<CPU>"       << cpu       << "</CPU>"
             << "<VCPU>"      << vcpu      << "</VCPU>"
             << "<NET_TX>"    << net_tx    << "</NET_TX>"
             << "<NET_RX>"    << net_rx    << "</NET_RX>"
             << obj_template->to_xml(template_xml);
-...
         rc += xpath(memory,    "/VM/MEMORY",   0);
         rc += xpath(cpu,       "/VM/CPU",      0);
         rc += xpath(vcpu,      "/VM/VCPU",     0);
         rc += xpath(net_tx,    "/VM/NET_TX",   0);
         rc += xpath(net_rx,    "/VM/NET_RX",   0);

             aname = "MIGRATE";
             break;
         case SCALE_MEMORY:
             aname = "SCALE_MEMORY";
             break;
         case SCALE_VCPU:
             aname = "SCALE_VCPU";
             break;
         case POLL:
             aname = "POLL";
             break;
-...
+            {
                 return;
+            }
             vid = -1;
+        }
         else
-...
+        {
             migrate_action(vid);
+        }
         else if (action == "SCALE_MEMORY")
+        {
             scale_memory_action(vid);
+        }
         else if (action == "SCALE_VCPU")
+        {
             scale_vcpu_action(vid);
+        }
         else if (action == "POLL")
+        {
             poll_action(vid);
-...
         const string& m_hostname,