opennebula-lease-reservation-v1.patch - OpenNebula - OpenNebula Development pages

          *  @param vid identifier of the VM getting this lease
          *  @param ip ip of lease requested
          *  @param mac mac of the lease
          *  @param uid of the owner of the VM getting this lease
          *  @return 0 if success
          */
         int set(int vid, const string&  ip, string&  mac, unsigned int eui64[]);
         int set(int vid, const string&  ip, string&  mac, unsigned int eui64[], int uid);
         /**
          * Release an used lease, which becomes unused
          *   @param ip of the lease in use
          *  @param ip of the lease in use
          *  @return 0 if success
          */
         void release(const string& ip)
         int release(const string& ip)
+        {
             unset(ip);
             return unset(ip);
+        }
         /**
-...
         int remove_leases(vector<const Attribute*>& leases, string& error_msg);
         /**
          *  Reserves leases for user or group
          *   @param vector_leases vector of VectorAttribute objects. For the
          *          moment, the vector can only contain one LEASE.
          *   @param error_msg If the action fails, this message contains
          *          the reason.
          *   @param uid of the user to reserve lease
          *   @param gid of the group to reserve lease
          *   @return 0 on success
          */
         int reserve_leases(vector<const Attribute*>& vector_leases, string& error_msg, int uid, int gid);
         /**
          *  Loads the leases from the DB.
          */
         int select(SqlDB * db)

          *  @param eui64 extended unique identifier
          *  @return 0 if success
          */
          virtual int get(int vid, string& ip, string& mac, unsigned int *eui64) = 0;
          /**
           * Ask for a specific lease in the network
           *  @param vid identifier of the VM getting this lease
           *  @param ip ip of lease requested
           *  @param mac mac of the lease
           *  @param eui64 extended unique identifier
           *  @return 0 if success
           */
          virtual int set(int vid, const string&  ip, string&  mac, unsigned int *eui64) = 0;
          /**
           * Release an used lease, which becomes unused
           *   @param ip of the lease in use
           */
          virtual void release(const string& ip) = 0;
         virtual int get(int vid, string& ip, string& mac, unsigned int *eui64) = 0;
         /**
          * Ask for a specific lease in the network
          *  @param vid identifier of the VM getting this lease
          *  @param ip ip of lease requested
          *  @param mac mac of the lease
          *  @param eui64 extended unique identifier
          *  @param uid of the owner of the VM getting this lease
          *  @return 0 if success
          */
         virtual int set(int vid, const string&  ip, string&  mac, unsigned int *eui64, int uid) = 0;
         /**
          * Releases a used lease, which becomes unused
          *  @param ip of the lease in use
          *  @return 0 if success
          */
         virtual int release(const string& ip) = 0;
         /**
          * Adds New leases. (Only implemented for FIXED networks)
-...
          */
         int free_leases(vector<const Attribute*>& vector_leases, string& error_msg);
         /**
          * Reserves a Lease for user or group. (Only available for FIXED networks)
          *  @param vector_leases vector of VectorAttribute objects. For the
          *         moment, the vector can only contain one LEASE.
          *  @param error_msg If the action fails, this message contains
          *         the reason.
          *  @param uid of the user to reserve lease
          *  @param gid of the group to reserve lease
          *  @return 0 on success
          */
         virtual int reserve_leases(vector<const Attribute*>& vector_leases, string& error_msg, int uid, int gid) = 0;
     protected:
         /**
          *  The Lease class, it represents a pair of IP and MAC assigned to
-...
             static int prefix6_to_number(const string& prefix, unsigned int ip[]);
             /**
              * Function to check if the Lease is used
              * @return true if the lease is used
              */
             bool is_used() { return used && vid != -1; }
             /**
              * Function to check if the Lease is reserved
              * @return true if the lease is reserved
              */
             bool is_reserved() { return used && (uid != -1 || gid != -1); }
             /**
              * Function to check if the Lease is held
              * @return true if the lease is held
              */
             bool is_held() { return used && vid == -1; }
             /**
              * Function to print the Lease object into a string in
              * XML format
              *  @param xml the resulting XML string
-...
             int  vid;
             bool used;
             int uid;
             int gid;
         };
         friend class VirtualNetwork;

          *  @param vid identifier of the VM getting this lease
          *  @param ip ip of lease requested
          *  @param mac mac of the lease
          *  @param uid of the owner of the VM getting this lease
          *  @return 0 if success
          */
         int set(int vid, const string&  ip, string&  mac, unsigned int eui64[]);
         int set(int vid, const string&  ip, string&  mac, unsigned int eui64[], int uid);
         /**
          * Release an used lease, which becomes unused
          *   @param ip of the lease in use
          *  @param ip of the lease in use
          *  @return 0 if success
          */
         void release(const string& ip)
         int release(const string& ip)
+        {
             del(ip);
             return del(ip);
+        }
         /**
-...
+        }
         /**
          *  Reserves leases for user or group
          *  Only available for FIXED networks.
          *    @param vector_leases vector of VectorAttribute objects. For the
          *      moment, the vector can only contain one LEASE.
          *    @param error_msg If the action fails, this message contains
          *      the reason.
          *    @param uid of the user to reserve lease
          *    @param gid of the group to reserve lease
          *    @return 0 on success
          */
         int reserve_leases(vector<const Attribute*>& vector_leases, string& error_msg, int uid, int gid)
+        {
             error_msg = "Reserving leases is only supported for FIXED networks.";
             return -1;
+        }
         /**
          *  Loads the leases from the DB.
          */
         int select(SqlDB * db)

+    {
     protected:
         RequestManagerVirtualNetwork(const string& method_name,
                                      const string& help)
             :Request(method_name,"A:sis",help)
                                      const string& help,
                                      const string& params = "A:sis")
             :Request(method_name,params,help)
+        {
             Nebula& nd  = Nebula::instance();
             pool        = nd.get_vnpool();
-...
+        }
     };
     /* ------------------------------------------------------------------------- */
     /* ------------------------------------------------------------------------- */
     class VirtualNetworkReserve : public RequestManagerVirtualNetwork
+    {
     public:
         VirtualNetworkReserve():
             RequestManagerVirtualNetwork("VirtualNetworkReserve",
                                          "Reserves a virtual network Lease for user or group",
                                          "A:sisii") {};
         ~VirtualNetworkReserve(){};
         void request_execute(xmlrpc_c::paramList const& _paramList,
                 RequestAttributes& att) {
             uid = xmlrpc_c::value_int(_paramList.getInt(3));
             gid = xmlrpc_c::value_int(_paramList.getInt(4));
             RequestManagerVirtualNetwork::request_execute(_paramList, att);
+        }
         int leases_action(VirtualNetwork * vn,
                           VirtualNetworkTemplate * tmpl,
                           string& error_str)
+        {
             return vn->reserve_leases(tmpl, error_str, uid, gid);
+        }
     private:
         int uid;
         int gid;
     };
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */

          */
         int free_leases(VirtualNetworkTemplate* leases, string& error_msg);
          /**
          * Reserves a Lease for user or group
          *  @param leases template in the form LEASES = [IP=XX].
          *          The template can only contain one LEASE definition.
          *  @param error_msg If the action fails, this message contains
          *         the reason.
          *  @param uid of the user to reserve lease
          *  @param gid of the group to reserve lease
          *  @return 0 on success
          */
         int reserve_leases(VirtualNetworkTemplate* leases, string& error_msg, int uid, int gid);
         /**
          *    Gets a new lease for a specific VM
          *    @param vid VM identifier
-...
          *    @param _ip the ip of the requested lease
          *    @param _mac pointer to string for MAC to be stored into
          *    @param _bridge name of the physical bridge this VN binds to
          *    @param _uid of the owner of the VM getting the lease
          *    @return 0 if success
          */
         int set_lease(int vid, const string& _ip, string& _mac, string& _bridge)
         int set_lease(int vid, const string& _ip, string& _mac, string& _bridge, int _uid)
+        {
             unsigned int eui64[2];
             _bridge = bridge;
             return leases->set(vid, _ip, _mac, eui64);
             return leases->set(vid, _ip, _mac, eui64, _uid);
         };
         /**
-...
          *    @param _ip IP identifying the lease
          *    @return 0 if success
          */
         void release_lease(const string& ip)
         int release_lease(const string& ip)
+        {
             return leases->release(ip);
         };
-...
          *  * BRIDGE: for this virtual network
          *  @param nic attribute for the VM template
          *  @param vid of the VM getting the lease
          *  @param uid of the owner of the VM getting the lease
          *  @return 0 on success
          */
         int nic_attribute(VectorAttribute * nic, int vid);
         int nic_attribute(VectorAttribute * nic, int vid, int uid);
     private:

         xmlrpc_c::methodPtr vn_rmleases(new VirtualNetworkRemoveLeases());
         xmlrpc_c::methodPtr vn_hold(new VirtualNetworkHold());
         xmlrpc_c::methodPtr vn_release(new VirtualNetworkRelease());
         xmlrpc_c::methodPtr vn_reserve(new VirtualNetworkReserve());
         // Update Template Methods
         xmlrpc_c::methodPtr image_update(new ImageUpdateTemplate());
-...
         RequestManagerRegistry.addMethod("one.vn.rmleases", vn_rmleases);
         RequestManagerRegistry.addMethod("one.vn.hold", vn_hold);
         RequestManagerRegistry.addMethod("one.vn.release", vn_release);
         RequestManagerRegistry.addMethod("one.vn.reserve", vn_reserve);
         RequestManagerRegistry.addMethod("one.vn.allocate", vn_allocate);
         RequestManagerRegistry.addMethod("one.vn.update", vn_update);
         RequestManagerRegistry.addMethod("one.vn.delete", vn_delete);

     #include "FixedLeases.h"
     #include "NebulaLog.h"
     #include "Nebula.h"
     #include <string.h>
-...
             return 0; //Not in the map, not leased
+        }
         // Flip used flag to false
         it_ip->second->used = false;
         if ( !it_ip->second->is_reserved() )
+        {
             // Flip used flag to false
             it_ip->second->used = false;
             n_used--;
+        }
         it_ip->second->vid  = -1;
         // Update the lease
-...
             if (current->second->used == false)
+            {
                 ostringstream oss;
                 current->second->used = true;
                 current->second->vid  = vid;
                 n_used++;
                 rc = update_lease(current->second);
                 Leases::Lease::mac_to_string(current->second->mac, mac);
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int FixedLeases::set(int vid, const string&  ip, string&  mac, unsigned int eui64[])
     int FixedLeases::set(int vid, const string&  ip, string&  mac, unsigned int eui64[], int uid)
+    {
         map<unsigned int,Lease *>::iterator it;
         unsigned int    num_ip;
         int             rc;
         User *          user;
         UserPool *      upool = Nebula::instance().get_upool();
         rc = Leases::Lease::ip_to_number(ip,num_ip);
         if (rc != 0)
-...
+        {
             return -1;
+        }
         else if (it->second->used) //it is in use
         else if (it->second->is_used()) //it is in use
+        {
             return -1;
+        }
         it->second->used = true;
         if (it->second->is_reserved()) // check reservation
+        {
             user = upool->get(uid, false);
             if ( user == 0 )
+            {
                 return -1;
+            }
             int gid = user->get_gid();
             if (gid != GroupPool::ONEADMIN_ID &&
                 it->second->uid != uid && it->second->gid != gid)
+            {
                 return -1; //it is reserved for another user/group
+            }
+        }
         else
+        {
             it->second->used = true;
             n_used++;
+        }
         it->second->vid  = vid;
         Leases::Lease::mac_to_string(it->second->mac,mac);
-...
             return -1;
+        }
         if( lease->used )
+        {
             n_used++;
+        }
         else
+        {
             n_used--;
+        }
         oss << "UPDATE " << table << " SET body='" << sql_xml << "'"
             << " WHERE oid=" << oid << " AND ip='" << lease->ip <<"'";
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int FixedLeases::reserve_leases(vector<const Attribute*>&   vector_leases,
                                     string&                     error_msg,
                                     int uid, int gid)
+    {
         const VectorAttribute * single_attr_lease = 0;
         map<unsigned int, Lease *>::iterator  it;
         unsigned int     i_ip;
         string           st_ip;
         if ( vector_leases.size() > 0 )
+        {
             single_attr_lease =
                     dynamic_cast<const VectorAttribute *>(vector_leases[0]);
+        }
         if( single_attr_lease == 0 )
+        {
             error_msg = "Empty lease description.";
             return -1;
+        }
         st_ip  = single_attr_lease->vector_value("IP");
         if ( Leases::Lease::ip_to_number(st_ip,i_ip) != 0 )
+        {
             error_msg = "Wrong Lease format.";
             return -1;
+        }
         it = leases.find(i_ip);
         if ( it == leases.end() )
+        {
             error_msg = "Lease is not part of the NET.";
             return -1;
+        }
         if ( !it->second->is_used() )
+        {
             it->second->used = true;
             it->second->vid = -1;
             n_used++;
+        }
         it->second->uid = uid;
         it->second->gid = gid;
         return update_lease(it->second);
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */

         os << "<USED>"<< used  << "</USED>"<<
               "<VID>" << vid   << "</VID>" <<
               "<UID>" << uid   << "</UID>" <<
               "<GID>" << gid   << "</GID>" <<
             "</LEASE>";
         str = os.str();
-...
                 "<MAC_SUFFIX>" << mac[0] << "</MAC_SUFFIX>" <<
                 "<USED>"       << used   << "</USED>"<<
                 "<VID>"        << vid    << "</VID>" <<
                 "<UID>"        << uid    << "</UID>" <<
                 "<GID>"        << gid    << "</GID>" <<
             "</LEASE>";
         str = os.str();
-...
         rc += xpath(int_used, "/LEASE/USED", 0);
         rc += xpath(vid, "/LEASE/VID", 0);
         xpath(uid, "/LEASE/UID", -1);
         xpath(gid, "/LEASE/GID", -1);
         used = static_cast<bool>(int_used);
         if (rc != 0)
-...
             return -1;
+        }
         rc = set(-1, ip, mac, tmp);
         rc = set(-1, ip, mac, tmp, -1);
         if ( rc != 0 )
+        {
-...
         const VectorAttribute * single_attr_lease = 0;
         map<unsigned int,Lease *>::iterator it;
         int             rc = 0;
         unsigned int    i_ip;
         string          st_ip;
         string          mac;
         if ( vector_leases.size() > 0 )
+        {
-...
         it = leases.find(i_ip);
         if ( it == leases.end() || !it->second->used || it->second->vid != -1 )
         if ( it == leases.end() )
+        {
             error_msg = "Lease is not part of the NET.";
             return -1;
+        }
         else if ( !it->second->is_held() && !it->second->is_reserved() )
+        {
             error_msg = "Lease is not on hold.";
             error_msg = "Lease is not on hold or reserved.";
             return -1;
+        }
         release(st_ip);
         if ( it->second->is_reserved() )
+        {
             rc += reserve_leases(vector_leases, error_msg, -1, -1); //unreserve
+        }
         return 0;
         if ( it->second->is_held() )
+        {
             rc += release(st_ip);
+        }
         return rc;
+    }
     /* ************************************************************************** */

     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int RangedLeases::set(int vid, const string&  ip, string&  mac, unsigned int eui64[])
     int RangedLeases::set(int vid, const string&  ip, string&  mac, unsigned int eui64[], int uid)
+    {
         unsigned int num_ip;
         unsigned int num_mac[2];

     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int VirtualNetwork::nic_attribute(VectorAttribute *nic, int vid)
     int VirtualNetwork::nic_attribute(VectorAttribute *nic, int vid, int uid)
+    {
         int rc;
-...
+        }
         else
+        {
             rc = leases->set(vid,ip,mac, eui64);
             rc = leases->set(vid,ip,mac, eui64, uid);
+        }
         if ( rc != 0 )
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int VirtualNetwork::reserve_leases(VirtualNetworkTemplate * leases_template,
                                       string&                   error_msg,
                                       int uid, int gid)
+    {
         vector<const Attribute *> vector_leases;
         leases_template->get("LEASES", vector_leases);
         return leases->reserve_leases(vector_leases, error_msg, uid, gid);
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */

src/vnm/VirtualNetworkPool.cc
250	250	return -1;
251	251	}
252	252
253		int rc = vnet->nic_attribute(nic,vid);
	253	int rc = vnet->nic_attribute(nic,vid,uid);
254	254
255	255	if ( rc == 0 )
256	256	{
257		-