opennebula-3.3.80-nichotplug.patch - OpenNebula - OpenNebula Development pages

                 RequestAttributes& att);
     };
     /* ------------------------------------------------------------------------- */
     /* ------------------------------------------------------------------------- */
     class VirtualMachineAddNic : public RequestManagerVirtualMachine
+    {
     public:
         VirtualMachineAddNic():
             RequestManagerVirtualMachine("VirtualMachineAddNic",
                                "Add NIC to running virtual machine",
                                "A:sis"){};
         ~VirtualMachineAddNic(){};
         void request_execute(xmlrpc_c::paramList const& _paramList,
                 RequestAttributes& att);
     };
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     class VirtualMachineRemoveNic : public RequestManagerVirtualMachine
+    {
     public:
         VirtualMachineRemoveNic():
             RequestManagerVirtualMachine("VirtualMachineRemoveNic",
                                "Remove NIC from running virtual machine",
                                "A:sis"){};
         ~VirtualMachineRemoveNic(){};
         void request_execute(xmlrpc_c::paramList const& _paramList,
                 RequestAttributes& att);
     };
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */

             const string& drv_msg) const;
         /**
          *  Sends a save request to the MAD: "RESTORE ID XML_DRV_MSG"
          *  Sends a restore request to the MAD: "RESTORE ID XML_DRV_MSG"
          *    @param oid the virtual machine id.
          *    @param drv_msg xml data for the mad operation
          */
-...
         void poll (
             const int     oid,
             const string& drv_msg) const;
         /**
          *  Sends a addnic request to the MAD: "ADDNIC ID XML_DRV_MSG"
          *    @param oid the virtual machine id.
          *    @param drv_msg xml data for the mad operation
          */
         void addnic (
             const int     oid,
             const string& drv_msg) const;
         /**
          *  Sends a rmnic request to the MAD: "RMNIC ID XML_DRV_MSG"
          *    @param oid the virtual machine id.
          *    @param drv_msg xml data for the mad operation
          */
         void rmnic (
             const int     oid,
             const string& drv_msg) const;
     };
     /* -------------------------------------------------------------------------- */

             RESTORE,
             REBOOT,
             POLL,
     	ADDNIC,
     	RMNIC,
             TIMER,
             DRIVER_CANCEL,
             FINALIZE
-...
             int vid);
         /**
          *  Add NIC to a running VM.
          *    @param vid the id of the VM.
          */
         void addnic_action(
             int vid);
         /**
          *  Remove NIC from a running VM.
          *    @param vid the id of the VM.
          */
         void rmnic_action(
             int vid);
         /**
          *  This function is executed periodically to poll the running VMs
          */
         void timer_action();

             :restore    => "RESTORE",
             :migrate    => "MIGRATE",
             :poll       => "POLL",
             :log        => "LOG"
             :log        => "LOG",
             :addnic     => "ADDNIC",
             :rmnic      => "RMNIC"
+        }
         POLL_ATTRIBUTE = {
-...
             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[:addnic].to_sym,     method("addnic"))
             register_action(ACTION[:rmnic].to_sym,     method("rmnic"))
         end
         # Decodes the encoded XML driver message received from the core
-...
             send_message(ACTION[:poll],RESULT[:failure],id,error)
         end
         def addnic(id, drv_message)
             error = "Action not implemented by driver #{self.class}"
             send_message(ACTION[:addnic],RESULT[:failure],id,error)
         end
         def rmnic(id, drv_message)
             error = "Action not implemented by driver #{self.class}"
             send_message(ACTION[:rmnic],RESULT[:failure],id,error)
         end
     private
         # Interface to handle the pending events from the ActionManager Interface
         def delete_running_action(action_id)

         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_addnic(new VirtualMachineAddNic());
         xmlrpc_c::methodPtr vm_rmnic(new VirtualMachineRemoveNic());
         // 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.addnic", vm_addnic);
         RequestManagerRegistry.addMethod("one.vm.rmnic", vm_rmnic);
         RequestManagerRegistry.addMethod("one.vmpool.info", vm_pool_info);

     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void VirtualMachineAddNic::request_execute(xmlrpc_c::paramList const& paramList,
                                            RequestAttributes& att)
+    {
         Nebula& nd = Nebula::instance();
         int id = xmlrpc_c::value_int(paramList.getInt(1));
         string str_tmpl = xmlrpc_c::value_string(paramList.getString(2));
         VirtualMachinePool * vmpool = nd.get_vmpool();
         VirtualNetworkPool * vnpool = nd.get_vnpool();
         VirtualMachineManager * vmm = nd.get_vmm();
         VirtualMachine * vm;
         VirtualNetworkTemplate tmpl;
         string error_str;
         int rc;
         // -------------------------------------------------------------------------
         // Authorize the operation
         // -------------------------------------------------------------------------
         if ( vm_authorization(id, 0, att, 0, 0) == false )
+        {
             return;
+        }
         if ( (vm = get_vm(id, att)) == 0 )
+        {
             return;
+        }
         if (vm->get_state() != VirtualMachine::ACTIVE) {
                      failure_response(ACTION, request_error("Wrong state to perform action",""), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Parse passed template into a NIC description
         // -------------------------------------------------------------------------
         rc = tmpl.parse_str_or_xml(str_tmpl, error_str);
         if ( rc != 0 )
+        {
             failure_response(INTERNAL, request_error(error_str, ""), att);
             vm->unlock();
             return;
+        }
         vector<Attribute*> vector_nic;
         tmpl.get(string("NIC"), vector_nic);
         VectorAttribute * single_attr_nic = 0;
         if ( vector_nic.size() > 0 )
+        {
             single_attr_nic = dynamic_cast<VectorAttribute *>(vector_nic[0]);
+        }
         if( single_attr_nic == 0 )
+        {
             failure_response(INTERNAL, request_error("Empty NIC description.", ""), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Obtain auth for the requested Virtual network
         // -------------------------------------------------------------------------
         AuthRequest ar(att.uid, att.gid);
         vnpool->authorize_nic(single_attr_nic,att.uid,&ar);
         if (UserPool::authorize(ar) == -1)
+        {
             failure_response(AUTHORIZATION, authorization_error(ar.message, att), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Assign new NIC to VM
         // -------------------------------------------------------------------------
         rc = vnpool->nic_attribute(single_attr_nic, att.uid, id, error_str);
         if (rc != 0) {
             if (error_str.empty()) {
                 error_str = "Invalid network or no leases available.";
+            }
             failure_response(INTERNAL,request_error(error_str,""), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Append new NIC to VM template
         // -------------------------------------------------------------------------
         string vm_xml;
         vm->to_xml(vm_xml);
         vm_xml = vm_xml.substr(vm_xml.find("<TEMPLATE>"));
         vm_xml = vm_xml.substr(0, vm_xml.rfind("</TEMPLATE>"));
         string * nic_xml = single_attr_nic->to_xml();
         vm_xml.append(*nic_xml).append("</TEMPLATE>");
         delete nic_xml;
         // -------------------------------------------------------------------------
         // Update the VM template
         // -------------------------------------------------------------------------
         rc = vm->replace_template(vm_xml, error_str);
         vmpool->update(vm);
         if (rc != 0) {
             failure_response(INTERNAL,request_error(error_str,""), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Trigger the ADDNIC action
         // -------------------------------------------------------------------------
         vmm->trigger(VirtualMachineManager::ADDNIC, id);
         vm->unlock();
         success_response(true, att);
+    }
     /* ------------------------------------------------------------------------- */
     /* ------------------------------------------------------------------------- */
     void VirtualMachineRemoveNic::request_execute(xmlrpc_c::paramList const& paramList,
                                            RequestAttributes& att)
+    {
         Nebula& nd = Nebula::instance();
         int id = xmlrpc_c::value_int(paramList.getInt(1));
         string str_tmpl = xmlrpc_c::value_string(paramList.getString(2));
         VirtualMachinePool * vmpool = nd.get_vmpool();
         VirtualNetworkPool * vnpool = nd.get_vnpool();
         VirtualMachineManager * vmm = nd.get_vmm();
         VirtualMachine * vm;
         VirtualNetworkTemplate tmpl;
         string error_str;
         int rc;
         string ip;
         string vnid;
         // -------------------------------------------------------------------------
         // Authorize the operation
         // -------------------------------------------------------------------------
         if ( vm_authorization(id, 0, att, 0, 0) == false )
+        {
             return;
+        }
         if ( (vm = get_vm(id, att)) == 0 )
+        {
             return;
+        }
         if (vm->get_state() != VirtualMachine::ACTIVE) {
             failure_response(ACTION, request_error("Wrong state to perform action",""), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Parse passed template into a NIC description
         // -------------------------------------------------------------------------
         rc = tmpl.parse_str_or_xml(str_tmpl, error_str);
         if ( rc != 0 )
+        {
             failure_response(INTERNAL, request_error(error_str, ""), att);
             vm->unlock();
             return;
+        }
         vector<Attribute*> vector_nic;
         tmpl.get(string("NIC"), vector_nic);
         VectorAttribute * single_attr_nic = 0;
         if ( vector_nic.size() > 0 )
+        {
             single_attr_nic = dynamic_cast<VectorAttribute *>(vector_nic[0]);
+        }
         if( single_attr_nic == 0 )
+        {
             failure_response(INTERNAL, request_error("Empty NIC description.", ""), att);
             vm->unlock();
             return;
+        }
         ip  = single_attr_nic->vector_value("IP");
         vnid = single_attr_nic->vector_value("NETWORK_ID");
         if( ip.empty() || vnid.empty() )
+        {
             failure_response(INTERNAL, request_error("Missing IP and/or NETWORK_ID from NIC description.", ""), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Search VM template for requested NIC to be removed
         // -------------------------------------------------------------------------
         vector<Attribute const  * > nics;
         int num_nics  = vm->get_template_attribute("NIC",nics);
         const VectorAttribute * nic;
         bool found = false;
         for(int i=0; i<num_nics; i++)
+        {
             nic = dynamic_cast<VectorAttribute const * >(nics[i]);
             if (nic->vector_value("IP") == ip && nic->vector_value("NETWORK_ID") == vnid) {
                 found = true;
                 break;
+            }
+        }
         if ( found == false ) {
             failure_response(INTERNAL, request_error("No leases matched the requested network.",""), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Release IP address back into the pool
         // -------------------------------------------------------------------------
         VirtualNetwork * vn = vnpool->get(atoi(vnid.c_str()),true);
         vn->release_lease(ip);
         vnpool->update(vn);
         vn->unlock();
         // -------------------------------------------------------------------------
         // Remove NIC from VM template
         // -------------------------------------------------------------------------
         string vm_xml;
         vm->to_xml(vm_xml);
         vm_xml = vm_xml.substr(vm_xml.find("<TEMPLATE>"));
         vm_xml = vm_xml.substr(0, vm_xml.rfind("</TEMPLATE>") + 11);
         string * nic_xml = nic->to_xml();
         vm_xml.replace(vm_xml.find(*nic_xml), nic_xml->length(), "");
         delete nic_xml;
         // -------------------------------------------------------------------------
         // Update the VM template
         // -------------------------------------------------------------------------
         rc = vm->replace_template(vm_xml, error_str);
         vmpool->update(vm);
         if (rc != 0) {
             failure_response(INTERNAL,request_error(error_str,""), att);
             vm->unlock();
             return;
+        }
         // -------------------------------------------------------------------------
         // Trigger the RMNIC action
         // -------------------------------------------------------------------------
         vmm->trigger(VirtualMachineManager::RMNIC,id);
         vm->unlock();
         success_response(true, att);
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */

             aname = "REBOOT";
             break;
         case ADDNIC:
             aname = "ADDNIC";
             break;
         case RMNIC:
             aname = "RMNIC";
             break;
         case SHUTDOWN:
             aname = "SHUTDOWN";
             break;
-...
+        {
             poll_action(vid);
+        }
         else if (action == "ADDNIC")
+        {
             addnic_action(vid);
+        }
         else if (action == "RMNIC")
+        {
             rmnic_action(vid);
+        }
         else if (action == "DRIVER_CANCEL")
+        {
             driver_cancel_action(vid);
-...
     error_common:
         vm->log("VMM", Log::ERROR, os);
         vm->unlock();
         return;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void VirtualMachineManager::addnic_action(
         int vid)
+    {
         VirtualMachine *                    vm;
         const VirtualMachineManagerDriver * vmd;
         string        vm_tmpl;
         string *      drv_msg;
         ostringstream os;
         // Get the VM from the pool
         vm = vmpool->get(vid,true);
         if (vm == 0)
+        {
             return;
+        }
         if (!vm->hasHistory())
+        {
             goto error_history;
+        }
         // Get the driver for this VM
         vmd = get(vm->get_vmm_mad());
         if ( vmd == 0 )
+        {
             goto error_driver;
+        }
         // Invoke driver method
         drv_msg = format_message(
             vm->get_hostname(),
             vm->get_vnm_mad(),
             "",
             "",
             vm->get_deploy_id(),
             "",
             "",
             "",
             vm->to_xml(vm_tmpl));
         vmd->addnic(vid, *drv_msg);
         delete drv_msg;
         vm->unlock();
         return;
     error_history:
         os.str("");
         os << "addnic_action, VM has no history";
         goto error_common;
     error_driver:
         os.str("");
         os << "addnic_action, error getting driver " << vm->get_vmm_mad();
     error_common:
         vm->log("VMM", Log::ERROR, os);
         vm->unlock();
         return;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void VirtualMachineManager::rmnic_action(
         int vid)
+    {
         VirtualMachine *                    vm;
         const VirtualMachineManagerDriver * vmd;
         string        vm_tmpl;
         string *      drv_msg;
         ostringstream os;
         // Get the VM from the pool
         vm = vmpool->get(vid,true);
         if (vm == 0)
+        {
             return;
+        }
         if (!vm->hasHistory())
+        {
             goto error_history;
+        }
         // Get the driver for this VM
         vmd = get(vm->get_vmm_mad());
         if ( vmd == 0 )
+        {
             goto error_driver;
+        }
         // Invoke driver method
         drv_msg = format_message(
             vm->get_hostname(),
             vm->get_vnm_mad(),
             "",
             "",
             vm->get_deploy_id(),
             "",
             "",
             "",
             vm->to_xml(vm_tmpl));
         vmd->rmnic(vid, *drv_msg);
         delete drv_msg;
         vm->unlock();
         return;
     error_history:
         os.str("");
         os << "rmnic_action, VM has no history";
         goto error_common;
     error_driver:
         os.str("");
         os << "rmnic_action, error getting driver " << vm->get_vmm_mad();
     error_common:
         vm->log("VMM", Log::ERROR, os);
         vm->unlock();
         return;
+    }

         write(os);
     };
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void VirtualMachineManagerDriver::addnic (
         const int     oid,
         const string& drv_msg) const
+    {
         ostringstream os;
         os << "ADDNIC " << oid << " " << drv_msg << endl;
         write(os);
     };
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void VirtualMachineManagerDriver::rmnic (
         const int     oid,
         const string& drv_msg) const
+    {
         ostringstream os;
         os << "RMNIC " << oid << " " << drv_msg << endl;
         write(os);
     };
     /* ************************************************************************** */
     /* MAD Interface                                                              */
     /* ************************************************************************** */

             do_action("#{deploy_id} #{host}", id, host, ACTION[:reboot])
         end
+        #
         # ADDNIC action, add NIC to a running VM
+        #
         def addnic(id, drv_message)
             action=VmmAction.new(self, id, :addnic, drv_message)
             steps=[
                 # Execute networking addnic operations
+                {
                     :driver      => :vnm,
                     :action      => :addnic,
                 },
+            ]
             action.run(steps)
         end
+        #
         # RMNIC action, remove NIC from a running VM
+        #
         def rmnic(id, drv_message)
             action=VmmAction.new(self, id, :rmnic, drv_message)
             steps=[
                 # Execute networking rmnic operations
+                {
                     :driver      => :vnm,
                     :action      => :rmnic,
                 },
+            ]
             action.run(steps)
         end
     end
     ################################################################################