mirror of
https://github.com/OpenNebula/one.git
synced 2024-12-24 21:34:01 +03:00
565094961a
* Remove duplicit methods from NebulaUtil
* Const correctness
* Fix minor code quality issues
* Remove ObjectCollection::clone()
* Minor SSLUtil interface change
co-authored-by: Pavel Czerný <pczerny@opennebula.systems>
396 lines
15 KiB
C++
396 lines
15 KiB
C++
/* -------------------------------------------------------------------------- */
|
|
/* Copyright 2002-2020, 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. */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
#ifndef ADDRESS_RANGE_POOL_H_
|
|
#define ADDRESS_RANGE_POOL_H_
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <set>
|
|
|
|
#include "VirtualNetworkTemplate.h"
|
|
#include "PoolObjectSQL.h"
|
|
|
|
class VectorAttribute;
|
|
class AddressRange;
|
|
|
|
|
|
class AddressRangePool
|
|
{
|
|
public:
|
|
AddressRangePool();
|
|
|
|
virtual ~AddressRangePool();
|
|
|
|
// *************************************************************************
|
|
// Inititalization functions
|
|
// *************************************************************************
|
|
|
|
/**
|
|
* Builds the address range from a VectorAttribute. This function is used
|
|
* to create address ranges.
|
|
* @param ars the vector of address ranges
|
|
* @param error_msg describing the error
|
|
* @return 0 on success
|
|
*/
|
|
int from_vattr(VectorAttribute * ar, std::string& error_msg);
|
|
|
|
/**
|
|
* Builds the address range set from its XML representation. This function
|
|
* is used to rebuild the address ranges from the DB.
|
|
* @param node xmlNode for the template
|
|
* @return 0 on success
|
|
*/
|
|
int from_xml_node(const xmlNodePtr node);
|
|
|
|
// *************************************************************************
|
|
// Address Range management interface
|
|
// *************************************************************************
|
|
|
|
/**
|
|
* Removes an address range from the pool if it does not contain any used
|
|
* leases
|
|
* @param arid of the address range to be removed
|
|
* @param force force remove, even if active leases exists
|
|
* @return 0 on success, -1 if not exists or has used addresses
|
|
*/
|
|
int rm_ar(unsigned int ar_id, bool force, std::string& error_msg);
|
|
|
|
/**
|
|
* Removes all address ranges from the pool if it does not contain any used
|
|
* leases
|
|
* @return 0 on success, -1 if not exists or has used addresses
|
|
*/
|
|
int rm_ars(std::string& error_msg);
|
|
|
|
/**
|
|
* Updates the given address ranges
|
|
* @param ars vector of address ranges as VectorAttributes obtained from
|
|
* template in the form AR = [...]. Only one AR is processed.
|
|
* @param keep_restricted If true, the restricted attributes of the
|
|
* current template will override the new template
|
|
* @param error_msg If the action fails, this message contains
|
|
* the reason.
|
|
* @return 0 on success
|
|
*/
|
|
int update_ar(std::vector<VectorAttribute *> ars, bool keep_restricted,
|
|
std::string& error_msg);
|
|
/**
|
|
* Allocates a new *empty* address range. It is not added to the pool as it
|
|
* needs to be initialized. Only the AR_ID is set.
|
|
* @param ipam_mad sets the type of AddressRange to be created: internal,
|
|
* IPAM...
|
|
* @return the new address range.
|
|
*/
|
|
AddressRange * allocate_ar(const std::string& ipam_mad);
|
|
|
|
/**
|
|
* Adds a new address range to the pool. It should be allocated by the
|
|
* allocate_ar() function.
|
|
* @param ar the new address range;
|
|
* @return 0 on success
|
|
*/
|
|
int add_ar(AddressRange * ar);
|
|
|
|
// *************************************************************************
|
|
// Address allocation interface
|
|
// *************************************************************************
|
|
|
|
/**
|
|
* Allocates an address in a suitable address range from the pool
|
|
* @param ot the type of the object requesting the address (VM or NET)
|
|
* @param obid the id of the object requesting the address
|
|
* @param nic the NIC attribute to be filled with lease attributes
|
|
* @param inherit attributes to be added to the NIC
|
|
* @return 0 if success
|
|
*/
|
|
int allocate_addr(PoolObjectSQL::ObjectType ot, int obid,
|
|
VectorAttribute * nic, const std::vector<std::string> &inherit);
|
|
|
|
/**
|
|
* Allocates an address in a suitable address range from the pool by mac/ip
|
|
* @param mac/ip the specific MAC/IP address requested
|
|
* @param ot the type of the object requesting the address (VM or NET)
|
|
* @param obid the id of the object requesting the address
|
|
* @param nic the NIC attribute to be filled with lease attributes
|
|
* @param inherit attributes to be added to the NIC
|
|
* @return 0 if success
|
|
*/
|
|
int allocate_by_mac(const std::string &mac, PoolObjectSQL::ObjectType ot,
|
|
int obid, VectorAttribute * nic,
|
|
const std::vector<std::string> &inherit);
|
|
|
|
int allocate_by_ip(const std::string &ip, PoolObjectSQL::ObjectType ot,
|
|
int obid, VectorAttribute * nic,
|
|
const std::vector<std::string> &inherit);
|
|
|
|
int allocate_by_ip6(const std::string &ip, PoolObjectSQL::ObjectType ot,
|
|
int obid, VectorAttribute * nic,
|
|
const std::vector<std::string> &inherit);
|
|
|
|
/**
|
|
* Holds an address from the specified address range.
|
|
* @param arid of the address range
|
|
* @param mac/ip the mac/ip to hold
|
|
* @return 0 on success
|
|
*/
|
|
int hold_by_mac(unsigned int arid, const std::string& mac);
|
|
|
|
int hold_by_ip(unsigned int arid, const std::string& ip);
|
|
|
|
int hold_by_ip6(unsigned int arid, const std::string& ip);
|
|
|
|
/**
|
|
* Holds an address from the first address range containing the MAC
|
|
* @param mac/ip the mac/ip to hold
|
|
* @return 0 on success
|
|
*/
|
|
int hold_by_mac(const std::string& mac);
|
|
|
|
int hold_by_ip(const std::string& ip);
|
|
|
|
int hold_by_ip6(const std::string& ip);
|
|
|
|
/**
|
|
* Frees the given address by MAC/IP on the given address range
|
|
* @param arid the ID of the address range
|
|
* @param ot the type of the object requesting the address (VM or NET)
|
|
* @param obid the id of the object requesting the address
|
|
* @param mac/ip the specific MAC/IP address requested
|
|
*/
|
|
void free_addr(unsigned int arid, PoolObjectSQL::ObjectType ot, int obid,
|
|
const std::string& mac);
|
|
|
|
void free_addr_by_ip(unsigned int arid, PoolObjectSQL::ObjectType ot,
|
|
int obid, const std::string& ip);
|
|
|
|
void free_addr_by_ip6(unsigned int arid, PoolObjectSQL::ObjectType ot,
|
|
int obid, const std::string& ip);
|
|
|
|
/**
|
|
* Frees the given address by MAC/IP from all address ranges containing
|
|
* the MAC/IP
|
|
* @param ot the type of the object requesting the address (VM or NET)
|
|
* @param obid the id of the object requesting the address
|
|
* @param mac/ip the specific MAC/IP address requested
|
|
*/
|
|
void free_addr(PoolObjectSQL::ObjectType ot, int obid,
|
|
const std::string& mac);
|
|
|
|
void free_addr_by_ip(PoolObjectSQL::ObjectType ot, int id,
|
|
const std::string& ip);
|
|
|
|
void free_addr_by_ip6(PoolObjectSQL::ObjectType ot, int id,
|
|
const std::string& ip);
|
|
|
|
/**
|
|
* Frees all the addressed owned by the given object
|
|
* @param ot the type of the object requesting the address (VM or NET)
|
|
* @param obid the id of the object requesting the address
|
|
* @return the number of addresses freed
|
|
*/
|
|
int free_addr_by_owner(PoolObjectSQL::ObjectType ot, int obid);
|
|
|
|
/**
|
|
* Frees the given address range
|
|
* @param arid the ID of the address range
|
|
* @param ot the type of the object requesting the address (VM or NET)
|
|
* @param obid the id of the object requesting the address
|
|
* @param mac the first MAC address in the range
|
|
* @param rsize size of the address range
|
|
*/
|
|
int free_addr_by_range(unsigned int arid, PoolObjectSQL::ObjectType ot,
|
|
int obid, const std::string& mac, unsigned int rsize);
|
|
|
|
/**
|
|
* From a Security Group rule that uses this vnet, creates a new rule
|
|
* copy for each AR.
|
|
*
|
|
* @param rule original rule
|
|
* @param new_rules vector where the new rules will be placed. Rules must
|
|
* be deleted by the caller
|
|
*/
|
|
void process_security_rule(
|
|
VectorAttribute * rule,
|
|
std::vector<VectorAttribute*> &new_rules);
|
|
|
|
// *************************************************************************
|
|
// Address reservation
|
|
// *************************************************************************
|
|
|
|
/**
|
|
* Reserve a given number of addresses from the first address range with
|
|
* enough free addresses to allocate the reservation
|
|
* @param vid the id of the VNET making the reservation
|
|
* @param size number of addresses to reserve
|
|
* @param rar a new address range to place the reservation
|
|
* @return 0 on success
|
|
*/
|
|
int reserve_addr(int vid, unsigned int rsize, AddressRange *rar);
|
|
|
|
/**
|
|
* Reserve a given number of addresses from the given address range
|
|
* @param vid the id of the VNET making the reservation
|
|
* @param rsize number of addresses to reserve
|
|
* @param ar_id the address range to reserve the addresses from
|
|
* @param rar a new address range to place the reservation
|
|
* @return 0 on success
|
|
*/
|
|
int reserve_addr(int vid, unsigned int rsize, unsigned int ar_id,
|
|
AddressRange *rar);
|
|
|
|
/**
|
|
* Reserve a number of addresses from an address range from a given ip/mac
|
|
* @param vid the id of the VNET making the reservation
|
|
* @param rsize number of addresses to reserve
|
|
* @param ar_id the address range to reserve the addresses from
|
|
* @param mac/ip the first MAC/IP in the reservation
|
|
* @param rar a new address range to place the reservation
|
|
* @return 0 on success
|
|
*/
|
|
int reserve_addr_by_mac(int vid, unsigned int rsize, unsigned int ar_id,
|
|
const std::string& mac, AddressRange *rar);
|
|
|
|
int reserve_addr_by_ip(int vid, unsigned int rsize, unsigned int ar_id,
|
|
const std::string& ip, AddressRange *rar);
|
|
|
|
int reserve_addr_by_ip6(int vid, unsigned int rsize, unsigned int ar_id,
|
|
const std::string& ip, AddressRange *rar);
|
|
|
|
|
|
// *************************************************************************
|
|
// Helpers & Formatting
|
|
// *************************************************************************
|
|
|
|
/**
|
|
* Return the number of used addresses
|
|
*/
|
|
unsigned int get_used_addr() const
|
|
{
|
|
return used_addr;
|
|
}
|
|
|
|
/**
|
|
* Return the total number addresses
|
|
*/
|
|
unsigned int get_size() const;
|
|
|
|
/**
|
|
* Return the parent id of an address range
|
|
* @param ar_id of the address range
|
|
* @return the parent ar id, -1 if none
|
|
*/
|
|
int get_ar_parent(int ar_id) const;
|
|
|
|
/**
|
|
* Gets an attribute from the Address Range
|
|
* @param name of the attribute
|
|
* @param value of the attribute
|
|
* @param ar_id to get the attribute from
|
|
*/
|
|
void get_attribute(const std::string& name, std::string& value, int ar_id) const;
|
|
|
|
/**
|
|
* Gets an attribute from the Address Range, int version
|
|
* @param name of the attribute
|
|
* @param value of the attribute
|
|
* @param ar_id to get the attribute from
|
|
* @return 0 on success
|
|
*/
|
|
int get_attribute(const std::string& name, int& value, int ar_id) const;
|
|
|
|
/**
|
|
* Gets a reference to a the security group set of an AR
|
|
* @return a reference to the security group set or empty set if error
|
|
*/
|
|
const std::set<int>& get_security_groups(int ar_id) const;
|
|
|
|
/**
|
|
* Gets a the security group set of all ARs
|
|
* @param sgs set with all the SG ids
|
|
*/
|
|
void get_all_security_groups(std::set<int>& sgs) const;
|
|
|
|
/**
|
|
* Generate a XML representation of the Address Range Pool
|
|
* @param sstream where the ARPool is written
|
|
* @param extended true to include lease information
|
|
* @param vm_ids list of VM the user can access VNET usage info from.
|
|
* A vector containing just -1 means all VMs.
|
|
* @param vnet_ids list of VNET the user can access reservation info from.
|
|
* A vector containing just -1 means all VNETs.
|
|
* @param vrs list of VRouter the user can access VNET usage info from.
|
|
* A vector containing just -1 means all VRouters.
|
|
* @return the string with the XML
|
|
*/
|
|
std::string& to_xml(std::string& sstream,
|
|
bool extended,
|
|
const std::vector<int>& vms,
|
|
const std::vector<int>& vnets,
|
|
const std::vector<int>& vrs) const;
|
|
|
|
/**
|
|
* Encrypt all secret attributes
|
|
*/
|
|
void encrypt(const std::string& one_key)
|
|
{
|
|
ar_template.encrypt(one_key);
|
|
};
|
|
|
|
/**
|
|
* Decrypt all secret attributes
|
|
*/
|
|
void decrypt(const std::string& one_key)
|
|
{
|
|
ar_template.decrypt(one_key);
|
|
};
|
|
|
|
private:
|
|
/**
|
|
* Stores the Address Ranges in a template form. This template is used
|
|
* to store the pool in the DB
|
|
*/
|
|
VirtualNetworkTemplate ar_template;
|
|
|
|
/**
|
|
* ID for the next Address Range
|
|
*/
|
|
unsigned int next_ar;
|
|
|
|
/**
|
|
* Map to access each range
|
|
*/
|
|
std::map<unsigned int, AddressRange *> ar_pool;
|
|
|
|
/**
|
|
* Used addresses
|
|
*/
|
|
unsigned int used_addr;
|
|
|
|
/**
|
|
* Allocates a new *empty* address range. It is not added to the pool as it
|
|
* needs to be initialized.
|
|
* @param ipam_mad sets the type of AddressRange to be created: internal,
|
|
* IPAM...
|
|
* @param ar_id for the AddressRange
|
|
* @return the new address range.
|
|
*/
|
|
AddressRange * allocate_ar(const std::string& ipam_mad, unsigned int ar_id);
|
|
};
|
|
|
|
#endif
|