shaba/one
1
0
Fork 0
mirror of https://github.com/OpenNebula/one.git synced 2025-01-03 01:17:41 +03:00
Code Releases Wiki Activity

feature #407: Refactor of base classes to include names and uid. Also the pool now has an index to get objects by name

Browse Source
This commit is contained in:
Ruben S. Montero 2011-03-04 22:37:21 +01:00
parent 0bcf29fb4b
commit e18675bf67
33 changed files with 308 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
include/Host.h
View File

@ -64,15 +64,6 @@ public:
*/ */
int from_xml(const string &xml_str); int from_xml(const string &xml_str);
/**
* Get the Host unique identifier HID, that matches the OID of the object
* @return HID Host identifier
*/
int get_hid() const
{
return oid;
};
/** /**
* Check if the host is enabled * Check if the host is enabled
* @return true if the host is enabled * @return true if the host is enabled
@ -121,15 +112,6 @@ public:
state = INIT; state = INIT;
}; };
/**
* Returns host host_name
* @return host_name Host's hostname
*/
const string& get_hostname() const
{
return hostname;
};
/** Update host counters and update the whole host on the DB /** Update host counters and update the whole host on the DB
* @param parse_str string with values to be parsed * @param parse_str string with values to be parsed
* @return 0 on success * @return 0 on success
@ -379,9 +361,6 @@ private:
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// Host Description // Host Description
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
string hostname;
/** /**
* The state of the Host * The state of the Host
*/ */

2
include/HostPool.h
View File

@ -68,7 +68,7 @@ public:
{ {
return static_cast<Host *>(PoolSQL::get(oid,lock)); return static_cast<Host *>(PoolSQL::get(oid,lock));
}; };
/** /**
* Bootstraps the database table(s) associated to the Host pool * Bootstraps the database table(s) associated to the Host pool
*/ */

37
include/Image.h
View File

@ -74,33 +74,6 @@ public:
*/ */
int from_xml(const string &xml_str); int from_xml(const string &xml_str);
/**
* Get the Image unique identifier IID, that matches the OID of the object
* @return IID Image identifier
*/
int get_iid() const
{
return oid;
};
/**
* Gets the uid of the owner of the Image
* @return uid
**/
int get_uid()
{
return uid;
}
/**
* Returns Image's name
* @return name Image's name
*/
const string& get_name() const
{
return name;
};
/** /**
* Returns true if the image is public * Returns true if the image is public
* @return true if the image is public * @return true if the image is public
@ -356,21 +329,11 @@ private:
// Image Description // Image Description
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/**
* Owner of the image
*/
int uid;
/** /**
* Image owner's name * Image owner's name
*/ */
string user_name; string user_name;
/**
* The name of the Image
*/
string name;
/** /**
* Type of the Image * Type of the Image
*/ */

33
include/ImagePool.h
View File

@ -83,18 +83,10 @@ public:
*/ */
Image * get( Image * get(
const string& name, const string& name,
int uid,
bool lock) bool lock)
{ {
map<string, int>::iterator index; return static_cast<Image *>(PoolSQL::get(name,uid,lock));
index = image_names.find(name);
if ( index != image_names.end() )
{
return get((int)index->second,lock);
}
return 0;
} }
/** Update a particular Image /** Update a particular Image
@ -112,14 +104,7 @@ public:
*/ */
int drop(Image * image) int drop(Image * image)
{ {
int rc = PoolSQL::drop(image); return PoolSQL::drop(image);
if ( rc == 0)
{
image_names.erase(image->get_name());
}
return rc;
}; };
/** /**
@ -146,18 +131,21 @@ public:
* @param index number of datablock images used by the same VM. Will be * @param index number of datablock images used by the same VM. Will be
* automatically increased. * automatically increased.
* @param img_type will be set to the used image's type * @param img_type will be set to the used image's type
* @param uid owner of the VM (to look for the image id within its images)
* @return 0 on success, -1 error, -2 not using the pool * @return 0 on success, -1 error, -2 not using the pool
*/ */
int disk_attribute(VectorAttribute * disk, int disk_attribute(VectorAttribute * disk,
int disk_id, int disk_id,
int * index, int * index,
Image::ImageType * img_type); Image::ImageType * img_type,
int uid);
/** /**
* Generates an Authorization token for the DISK attribute * Generates an Authorization token for the DISK attribute
* @param disk the disk to be authorized * @param disk the disk to be authorized
* @param uid owner of the VM (to look for the image id within its images)
* @param ar the AuthRequest * @param ar the AuthRequest
*/ */
void authorize_disk(VectorAttribute * disk, AuthRequest * ar); void authorize_disk(VectorAttribute * disk, int uid, AuthRequest * ar);
static const string& source_prefix() static const string& source_prefix()
{ {
@ -196,11 +184,6 @@ private:
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
// Pool Attributes // Pool Attributes
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/**
* This map stores the association between IIDs and Image names
*/
map<string, int> image_names;
/** /**
* Factory method to produce Image objects * Factory method to produce Image objects
* @return a pointer to the new Image * @return a pointer to the new Image

2
include/ObjectXML.h
View File

@ -122,7 +122,7 @@ public:
* returned as pointers to the object nodes. * returned as pointers to the object nodes.
* @return the number of nodes found * @return the number of nodes found
*/ */
int get_nodes (const char * xpath_expr, vector<xmlNodePtr>& content); int get_nodes(const char * xpath_expr, vector<xmlNodePtr>& content);
/** /**
* Updates the object representation with a new XML document. Previous * Updates the object representation with a new XML document. Previous

33
include/PoolObjectSQL.h
View File

@ -38,8 +38,9 @@ class PoolObjectSQL : public ObjectSQL, public ObjectXML
public: public:
//TODO remove Defaults for Constructor Attributes //TODO remove Defaults for Constructor Attributes
PoolObjectSQL(int id=-1, const char * _table = 0) PoolObjectSQL(int id=-1, const string& _name ="", int _uid=0,const char *_table = 0)
:ObjectSQL(),ObjectXML(),oid(id),valid(true),table(_table) :ObjectSQL(),ObjectXML(),oid(id),name(_name),uid(_uid),
valid(true),table(_table)
{ {
pthread_mutex_init(&mutex,0); pthread_mutex_init(&mutex,0);
}; };
@ -51,11 +52,25 @@ public:
pthread_mutex_destroy(&mutex); pthread_mutex_destroy(&mutex);
}; };
/* --------------------------------------------------------------------- */
int get_oid() const int get_oid() const
{ {
return oid; return oid;
}; };
const string& get_name() const
{
return name;
};
int get_uid()
{
return uid;
};
/* --------------------------------------------------------------------- */
/** /**
* Check if the object is valid * Check if the object is valid
* @return true if object is valid * @return true if object is valid
@ -209,12 +224,22 @@ protected:
/** /**
* The object's unique ID * The object's unique ID
*/ */
int oid; int oid;
/**
* The object's name
*/
string name;
/**
* Object's owner
*/
int uid;
/** /**
* The contents of this object are valid * The contents of this object are valid
*/ */
bool valid; bool valid;
private: private:

103
include/PoolSQL.h
View File

@ -45,8 +45,10 @@ public:
* @param _db a pointer to the database * @param _db a pointer to the database
* @param table the name of the table supporting the pool (to set the oid * @param table the name of the table supporting the pool (to set the oid
* counter). If null the OID counter is not updated. * counter). If null the OID counter is not updated.
* @param with_uid the Pool objects have an owner id (uid)
*/ */
PoolSQL(SqlDB * _db, const char * table); //TODO REmove defaults
PoolSQL(SqlDB * _db, const char * table, bool with_uid=false);
virtual ~PoolSQL(); virtual ~PoolSQL();
@ -68,10 +70,33 @@ public:
* *
* @return a pointer to the object, 0 in case of failure * @return a pointer to the object, 0 in case of failure
*/ */
virtual PoolObjectSQL * get( PoolObjectSQL * get(
int oid, int oid,
bool lock); bool lock);
/**
* Gets an object from the pool (if needed the object is loaded from the
* database).
* @param name of the object
* @param uid id of owner
* @param lock locks the object if true
*
* @return a pointer to the object, 0 in case of failure
*/
PoolObjectSQL * get(const string& name, int uid, bool lock)
{
int oid;
oid = get_oid_by_name(name, uid);
if (oid == -1)
{
return 0;
}
return get(oid,lock);
}
/** /**
* Finds a set objects that satisfies a given condition * Finds a set objects that satisfies a given condition
* @param oids a vector with the oids of the objects. * @param oids a vector with the oids of the objects.
@ -116,6 +141,8 @@ public:
virtual int drop( virtual int drop(
PoolObjectSQL * objsql) PoolObjectSQL * objsql)
{ {
erase(objsql->name,objsql->uid);
return objsql->drop(db); return objsql->drop(db);
}; };
@ -164,6 +191,12 @@ private:
*/ */
map<int,PoolObjectSQL *> pool; map<int,PoolObjectSQL *> pool;
/**
* This is a name index for the pool map. The key is the name of the object
* , that may be combained with the owner id.
*/
map<string,int> name_index;
/** /**
* Factory method, must return an ObjectSQL pointer to an allocated pool * Factory method, must return an ObjectSQL pointer to an allocated pool
* specific object. * specific object.
@ -200,6 +233,72 @@ private:
*/ */
void replace(); void replace();
/* ------------------------------------------------------------------------ */
/* Functions to manage the name index */
/* ------------------------------------------------------------------------ */
/**
* Generate an index key for the object
* @param name of the object
* @param uid owner of the object, only used if needed
*
* @return the key, a string
*/
string key(const string& name, int uid)
{
ostringstream key;
key << name << ':' << uid;
return key.str();
};
/**
* Adds a new key-object_oid entry in the index
* @param name of the object
* @param oid of the object
* @param uid owner of the object, only used if needed
*/
void insert(const string& name, int oid, int uid)
{
name_index.insert(make_pair(key(name,uid),oid));
};
/**
* Deletes a key-object_oid entry in the index
* @param name of the object
* @param uid owner of the object, only used if needed
*/
void erase(const string& name, int uid)
{
name_index.erase(key(name,uid));
};
/**
* Looks for the oid of an object in the in memory index
* @param name of the object
* @param uid owner of the object, only used if needed
*
* @returns oid or -1 if the object was not found
*/
int get_oid_by_name(const string& name, int uid)
{
map<string, int>::iterator index;
int oid = -1;
index = name_index.find(key(name,uid));
if ( index != name_index.end() )
{
oid = static_cast<int>(index->second);
}
return oid;
};
/* ------------------------------------------------------------------------ */
/* ------------------------------------------------------------------------ */
/** /**
* Callback to set the lastOID (PoolSQL::PoolSQL) * Callback to set the lastOID (PoolSQL::PoolSQL)
*/ */

32
include/VirtualNetwork.h
View File

@ -58,24 +58,6 @@ public:
// Virtual Network Public Methods // Virtual Network Public Methods
// ************************************************************************* // *************************************************************************
/**
* Get the Vnet unique identifier VNID, that matches the OID of the object
* @return VNID Image identifier
*/
int get_vnid() const
{
return oid;
};
/**
* Gets the uid of the owner of the Virtual Network
* @return uid
**/
int get_uid()
{
return uid;
}
/** /**
* Returns true if the Virtual Network is public * Returns true if the Virtual Network is public
* @return true if the Virtual Network is public * @return true if the Virtual Network is public
@ -265,16 +247,6 @@ private:
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// Identification variables // Identification variables
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/**
* Name of the Virtual Network
*/
string name;
/**
* Owner of the Virtual Network
*/
int uid;
/** /**
* Owner's name * Owner's name
*/ */
@ -369,7 +341,9 @@ protected:
// Constructor // Constructor
//************************************************************************** //**************************************************************************
VirtualNetwork(string _user_name,VirtualNetworkTemplate * _vn_template = 0); VirtualNetwork(int uid,
string _user_name,
VirtualNetworkTemplate * _vn_template = 0);
~VirtualNetwork(); ~VirtualNetwork();

23
include/VirtualNetworkPool.h
View File

@ -71,12 +71,17 @@ public:
* Function to get a VN from the pool using the network name * Function to get a VN from the pool using the network name
* If the object is not in memory it is loaded from the DB * If the object is not in memory it is loaded from the DB
* @param name VN unique name * @param name VN unique name
* @param uid of the VN owner
* @param lock locks the VN mutex * @param lock locks the VN mutex
* @return a pointer to the VN, 0 if the VN could not be loaded * @return a pointer to the VN, 0 if the VN could not be loaded
*/ */
VirtualNetwork * get( VirtualNetwork * get(
const string& name, const string& name,
bool lock); int uid,
bool lock)
{
return static_cast<VirtualNetwork *>(PoolSQL::get(name,uid,lock));
};
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
// Virtual Network DB access functions // Virtual Network DB access functions
@ -89,14 +94,14 @@ public:
* @param vid of the VM requesting the lease * @param vid of the VM requesting the lease
* @return 0 on success, -1 error, -2 not using the pool * @return 0 on success, -1 error, -2 not using the pool
*/ */
int nic_attribute(VectorAttribute * nic, int vid); int nic_attribute(VectorAttribute * nic, int uid, int vid);
/** /**
* Generates an Authorization token for a NIC attribute * Generates an Authorization token for a NIC attribute
* @param nic the nic to be authorized * @param nic the nic to be authorized
* @param ar the AuthRequest * @param ar the AuthRequest
*/ */
void authorize_nic(VectorAttribute * nic, AuthRequest * ar); void authorize_nic(VectorAttribute * nic, int uid, AuthRequest * ar);
/** /**
* Bootstraps the database table(s) associated to the VirtualNetwork pool * Bootstraps the database table(s) associated to the VirtualNetwork pool
@ -151,7 +156,7 @@ private:
*/ */
PoolObjectSQL * create() PoolObjectSQL * create()
{ {
return new VirtualNetwork("", 0); return new VirtualNetwork(0,"",0);
}; };
/** /**
@ -163,16 +168,6 @@ private:
* @return 0 on success * @return 0 on success
*/ */
int dump_cb(void * _oss, int num, char **values, char **names); int dump_cb(void * _oss, int num, char **values, char **names);
/**
* Callback function to get the ID of a given virtual network
* (VirtualNetworkPool::get)
* @param num the number of columns read from the DB
* @param names the column names
* @param vaues the column values
* @return 0 on success
*/
int get_cb(void * _oss, int num, char **values, char **names);
}; };
#endif /*VIRTUAL_NETWORK_POOL_H_*/ #endif /*VIRTUAL_NETWORK_POOL_H_*/

9
src/host/Host.cc
View File

@ -33,8 +33,7 @@ Host::Host(
string _im_mad_name, string _im_mad_name,
string _vmm_mad_name, string _vmm_mad_name,
string _tm_mad_name): string _tm_mad_name):
PoolObjectSQL(id,table), PoolObjectSQL(id,_hostname,0,table),
hostname(_hostname),
state(INIT), state(INIT),
im_mad_name(_im_mad_name), im_mad_name(_im_mad_name),
vmm_mad_name(_vmm_mad_name), vmm_mad_name(_vmm_mad_name),
@ -102,7 +101,7 @@ int Host::insert_replace(SqlDB *db, bool replace)
// Update the Host // Update the Host
sql_hostname = db->escape_str(hostname.c_str()); sql_hostname = db->escape_str(name.c_str());
if ( sql_hostname == 0 ) if ( sql_hostname == 0 )
{ {
@ -202,7 +201,7 @@ string& Host::to_xml(string& xml) const
oss << oss <<
"<HOST>" "<HOST>"
"<ID>" << oid << "</ID>" << "<ID>" << oid << "</ID>" <<
"<NAME>" << hostname << "</NAME>" << "<NAME>" << name << "</NAME>" <<
"<STATE>" << state << "</STATE>" << "<STATE>" << state << "</STATE>" <<
"<IM_MAD>" << im_mad_name << "</IM_MAD>" << "<IM_MAD>" << im_mad_name << "</IM_MAD>" <<
"<VM_MAD>" << vmm_mad_name << "</VM_MAD>" << "<VM_MAD>" << vmm_mad_name << "</VM_MAD>" <<
@ -233,7 +232,7 @@ int Host::from_xml(const string& xml)
// Get class base attributes // Get class base attributes
rc += xpath(oid, "/HOST/ID", -1); rc += xpath(oid, "/HOST/ID", -1);
rc += xpath(hostname, "/HOST/NAME", "not_found"); rc += xpath(name, "/HOST/NAME", "not_found");
rc += xpath(int_state, "/HOST/STATE", 0); rc += xpath(int_state, "/HOST/STATE", 0);
rc += xpath(im_mad_name, "/HOST/IM_MAD", "not_found"); rc += xpath(im_mad_name, "/HOST/IM_MAD", "not_found");

4
src/host/HostHook.cc
View File

@ -55,7 +55,7 @@ void HostAllocateHook::do_hook(void *arg)
{ {
hmd->execute(host->get_oid(), hmd->execute(host->get_oid(),
name, name,
host->get_hostname(), host->get_name(),
cmd, cmd,
parsed_args); parsed_args);
} }
@ -179,7 +179,7 @@ void HostStateHook::do_hook(void *arg)
{ {
hmd->execute(host->get_oid(), hmd->execute(host->get_oid(),
name, name,
host->get_hostname(), host->get_name(),
cmd, cmd,
parsed_args); parsed_args);
} }

2
src/host/HostPool.cc
View File

@ -45,7 +45,7 @@ int HostPool::init_cb(void *nil, int num, char **values, char **names)
HostPool::HostPool(SqlDB* db, HostPool::HostPool(SqlDB* db,
vector<const Attribute *> hook_mads, vector<const Attribute *> hook_mads,
const string& hook_location) const string& hook_location)
: PoolSQL(db,Host::table) : PoolSQL(db,Host::table,false)
{ {
// ------------------ Initialize Cluster Array ---------------------- // ------------------ Initialize Cluster Array ----------------------

2
src/host/test/HostPoolTest.cc
View File

@ -186,7 +186,7 @@ protected:
CPPUNIT_ASSERT( obj != 0 ); CPPUNIT_ASSERT( obj != 0 );
string xml_str = ""; string xml_str = "";
string name = host->get_hostname(); string name = host->get_name();
CPPUNIT_ASSERT( name == names[index] ); CPPUNIT_ASSERT( name == names[index] );

4
src/im/InformationManager.cc
View File

@ -201,7 +201,7 @@ void InformationManager::timer_action()
(thetime - host->get_last_monitored() >= monitor_period)) (thetime - host->get_last_monitored() >= monitor_period))
{ {
oss.str(""); oss.str("");
oss << "Monitoring host " << host->get_hostname() oss << "Monitoring host " << host->get_name()
<< " (" << it->first << ")"; << " (" << it->first << ")";
NebulaLog::log("InM",Log::INFO,oss); NebulaLog::log("InM",Log::INFO,oss);
@ -225,7 +225,7 @@ void InformationManager::timer_action()
update_remotes = true; update_remotes = true;
} }
imd->monitor(it->first,host->get_hostname(),update_remotes); imd->monitor(it->first,host->get_name(),update_remotes);
host->set_state(Host::MONITORING); host->set_state(Host::MONITORING);
} }

4
src/image/Image.cc
View File

@ -33,10 +33,8 @@
/* ************************************************************************ */ /* ************************************************************************ */
Image::Image(int _uid, string _user_name, ImageTemplate * _image_template): Image::Image(int _uid, string _user_name, ImageTemplate * _image_template):
PoolObjectSQL(-1,table), PoolObjectSQL(-1,"",_uid,table),
uid(_uid),
user_name(_user_name), user_name(_user_name),
name(""),
type(OS), type(OS),
regtime(time(0)), regtime(time(0)),
source(""), source(""),

56
src/image/ImagePool.cc
View File

@ -27,31 +27,16 @@ string ImagePool::_source_prefix;
string ImagePool::_default_type; string ImagePool::_default_type;
string ImagePool::_default_dev_prefix; string ImagePool::_default_dev_prefix;
int ImagePool::init_cb(void *nil, int num, char **values, char **names)
{
if ( num == 0 || values == 0 || values[0] == 0 )
{
return -1;
}
image_names.insert(make_pair(values[1],atoi(values[0])));
return 0;
}
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
ImagePool::ImagePool( SqlDB * db, ImagePool::ImagePool( SqlDB * db,
const string& __source_prefix, const string& __source_prefix,
const string& __default_type, const string& __default_type,
const string& __default_dev_prefix): const string& __default_dev_prefix):
PoolSQL(db,Image::table,true)
PoolSQL(db,Image::table)
{ {
ostringstream sql; ostringstream sql;
int rc;
// Init static defaults // Init static defaults
_source_prefix = __source_prefix; _source_prefix = __source_prefix;
@ -63,25 +48,9 @@ ImagePool::ImagePool( SqlDB * db,
_default_type != "CDROM" && _default_type != "CDROM" &&
_default_type != "DATABLOCK" ) _default_type != "DATABLOCK" )
{ {
NebulaLog::log("IMG", Log::ERROR, NebulaLog::log("IMG", Log::ERROR, "Bad default for image type, setting OS");
"Bad default for image type, setting OS");
_default_type = "OS"; _default_type = "OS";
} }
// Read from the DB the existing images, and build the ID:Name map
set_callback(static_cast<Callbackable::Callback>(&ImagePool::init_cb));
sql << "SELECT oid, name FROM " << Image::table;
rc = db->exec(sql, this);
unset_callback();
if ( rc != 0 )
{
NebulaLog::log("IMG", Log::ERROR,
"Could not load the existing images from the DB.");
}
} }
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
@ -109,14 +78,6 @@ int ImagePool::allocate (
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
*oid = PoolSQL::allocate(img, error_str); *oid = PoolSQL::allocate(img, error_str);
// ---------------------------------------------------------------------
// Add the image name to the map of image_names
// ---------------------------------------------------------------------
if ( *oid != -1 )
{
image_names.insert(make_pair(name, *oid));
}
return *oid; return *oid;
} }
@ -167,7 +128,8 @@ int ImagePool::dump(ostringstream& oss, const string& where)
int ImagePool::disk_attribute(VectorAttribute * disk, int ImagePool::disk_attribute(VectorAttribute * disk,
int disk_id, int disk_id,
int * index, int * index,
Image::ImageType * img_type) Image::ImageType * img_type,
int uid)
{ {
string source; string source;
Image * img = 0; Image * img = 0;
@ -202,7 +164,7 @@ int ImagePool::disk_attribute(VectorAttribute * disk,
} }
else else
{ {
img = get(source,true); img = get(source,uid,true);
if (img == 0) if (img == 0)
{ {
@ -253,7 +215,7 @@ int ImagePool::disk_attribute(VectorAttribute * disk,
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void ImagePool::authorize_disk(VectorAttribute * disk, AuthRequest * ar) void ImagePool::authorize_disk(VectorAttribute * disk,int uid, AuthRequest * ar)
{ {
string source; string source;
Image * img = 0; Image * img = 0;
@ -282,7 +244,7 @@ void ImagePool::authorize_disk(VectorAttribute * disk, AuthRequest * ar)
} }
else else
{ {
img = get(source,true); img = get(source,uid,true);
} }
if (img == 0) if (img == 0)
@ -291,7 +253,7 @@ void ImagePool::authorize_disk(VectorAttribute * disk, AuthRequest * ar)
} }
ar->add_auth(AuthRequest::IMAGE, ar->add_auth(AuthRequest::IMAGE,
img->get_iid(), img->get_oid(),
AuthRequest::USE, AuthRequest::USE,
img->get_uid(), img->get_uid(),
img->isPublic()); img->isPublic());

20
src/image/test/ImagePoolTest.cc
View File

@ -192,7 +192,7 @@ public:
ImagePool * imp; ImagePool * imp;
Image * img; Image * img;
// Allocate 2 users, so they are written to the DB. // Allocate 2 images, so they are written to the DB.
allocate(0); allocate(0);
allocate(2); allocate(2);
@ -200,13 +200,13 @@ public:
// allocated images. // allocated images.
imp = new ImagePool(db, "source_prefix", "OS", "hd"); imp = new ImagePool(db, "source_prefix", "OS", "hd");
img = imp->get(names[0], false); img = imp->get(names[0], uids[0], false);
CPPUNIT_ASSERT( img != 0 ); CPPUNIT_ASSERT( img != 0 );
img = imp->get(names[1], false); img = imp->get(names[1], uids[1], false);
CPPUNIT_ASSERT( img == 0 ); CPPUNIT_ASSERT( img == 0 );
img = imp->get(names[2], false); img = imp->get(names[2], uids[2], false);
CPPUNIT_ASSERT( img != 0 ); CPPUNIT_ASSERT( img != 0 );
@ -297,7 +297,7 @@ public:
check(0, obj); check(0, obj);
// Get using its name // Get using its name
obj = imp->get(names[1], true); obj = imp->get(names[1], uids[1], true);
CPPUNIT_ASSERT( obj != 0 ); CPPUNIT_ASSERT( obj != 0 );
obj->unlock(); obj->unlock();
@ -309,7 +309,7 @@ public:
pool->clean(); pool->clean();
// Get first object and check its integrity // Get first object and check its integrity
obj = imp->get(names[0], false); obj = imp->get(names[0], uids[0], false);
check(0, obj); check(0, obj);
// Get using its name // Get using its name
@ -326,14 +326,14 @@ public:
// The pool is empty // The pool is empty
// Non existing name // Non existing name
obj = imp->get("Wrong name", true); obj = imp->get("Wrong name", 0, true);
CPPUNIT_ASSERT( obj == 0 ); CPPUNIT_ASSERT( obj == 0 );
// Allocate an object // Allocate an object
allocate(0); allocate(0);
// Ask again for a non-existing name // Ask again for a non-existing name
obj = imp->get("Non existing name", true); obj = imp->get("Non existing name",uids[0], true);
CPPUNIT_ASSERT( obj == 0 ); CPPUNIT_ASSERT( obj == 0 );
} }
@ -632,7 +632,7 @@ public:
disk = new VectorAttribute("DISK"); disk = new VectorAttribute("DISK");
disk->replace("IMAGE", "Image 0"); disk->replace("IMAGE", "Image 0");
((ImagePool*)imp)->disk_attribute(disk, 0, &index, &img_type); ((ImagePool*)imp)->disk_attribute(disk, 0, &index, &img_type,0);
value = ""; value = "";
value = disk->vector_value("TARGET"); value = disk->vector_value("TARGET");
@ -649,7 +649,7 @@ public:
disk = new VectorAttribute("DISK"); disk = new VectorAttribute("DISK");
disk->replace("IMAGE_ID", "1"); disk->replace("IMAGE_ID", "1");
((ImagePool*)imp)->disk_attribute(disk, 0, &index, &img_type); ((ImagePool*)imp)->disk_attribute(disk, 0, &index, &img_type,0);
value = ""; value = "";
value = disk->vector_value("TARGET"); value = disk->vector_value("TARGET");

66
src/pool/PoolSQL.cc
View File

@ -38,11 +38,39 @@ const unsigned int PoolSQL::MAX_POOL_SIZE = 15000;
int PoolSQL::init_cb(void *nil, int num, char **values, char **names) int PoolSQL::init_cb(void *nil, int num, char **values, char **names)
{ {
lastOID = -1; int uid = 0;
int oid;
if ( values[0] != 0 ) if (num ==3) //with uid
{ {
lastOID = atoi(values[0]); if ((values[0] == 0) || (values[1] == 0) || (values[2] == 0))
{
return -1;
}
uid = atoi(values[2]);
}
else if (num == 2)
{
if ((values[0] == 0) || (values[1] == 0))
{
return -1;
}
uid = 0;
}
else
{
return -1;
}
oid = atoi(values[0]);
name_index.insert(make_pair(key(values[1],uid),oid));
if (lastOID < oid)
{
lastOID = oid;
} }
return 0; return 0;
@ -50,19 +78,33 @@ int PoolSQL::init_cb(void *nil, int num, char **values, char **names)
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
PoolSQL::PoolSQL(SqlDB * _db, const char * table): db(_db), lastOID(-1) PoolSQL::PoolSQL(SqlDB * _db, const char * table, bool with_uid):db(_db), lastOID(-1)
{ {
ostringstream oss; ostringstream oss;
int rc;
pthread_mutex_init(&mutex,0); pthread_mutex_init(&mutex,0);
set_callback(static_cast<Callbackable::Callback>(&PoolSQL::init_cb)); set_callback(static_cast<Callbackable::Callback>(&PoolSQL::init_cb));
oss << "SELECT MAX(oid) FROM " << table; if (with_uid == true)
{
oss << "SELECT oid, name, uid FROM " << table;
}
else
{
oss << "SELECT oid, name FROM " << table;
}
db->exec(oss,this); rc = db->exec(oss,this);
unset_callback(); unset_callback();
if ( rc == -1 )
{
throw runtime_error("Could not load the existing pool objects from the DB.");
}
}; };
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
@ -86,6 +128,7 @@ PoolSQL::~PoolSQL()
pthread_mutex_destroy(&mutex); pthread_mutex_destroy(&mutex);
} }
/* ************************************************************************** */ /* ************************************************************************** */
/* PoolSQL public interface */ /* PoolSQL public interface */
/* ************************************************************************** */ /* ************************************************************************** */
@ -120,6 +163,7 @@ int PoolSQL::allocate(
else else
{ {
rc = lastOID; rc = lastOID;
insert(objsql->get_name(),rc,objsql->get_uid());
} }
do_hooks(objsql, Hook::ALLOCATE); do_hooks(objsql, Hook::ALLOCATE);
@ -187,6 +231,7 @@ PoolObjectSQL * PoolSQL::get(
pool.insert(make_pair(objectsql->oid,objectsql)); pool.insert(make_pair(objectsql->oid,objectsql));
if ( olock == true ) if ( olock == true )
{ {
objectsql->lock(); objectsql->lock();
@ -238,7 +283,14 @@ void PoolSQL::replace()
{ {
PoolObjectSQL * tmp_ptr; PoolObjectSQL * tmp_ptr;
string name;
int uid;
tmp_ptr = index->second; tmp_ptr = index->second;
name = tmp_ptr->get_name();
uid = tmp_ptr->get_uid();
pool.erase(index); pool.erase(index);
delete tmp_ptr; delete tmp_ptr;
@ -272,6 +324,7 @@ void PoolSQL::clean()
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
int PoolSQL:: search_cb(void * _oids, int num, char **values, char **names) int PoolSQL:: search_cb(void * _oids, int num, char **values, char **names)
{ {
vector<int> * oids; vector<int> * oids;
@ -309,3 +362,4 @@ int PoolSQL::search(
return rc; return rc;
} }

4
src/rm/RequestManagerAllocate.cc
View File

@ -94,7 +94,7 @@ void RequestManager::VirtualMachineAllocate::execute(
continue; continue;
} }
VirtualMachineAllocate::ipool->authorize_disk(vector,&ar); VirtualMachineAllocate::ipool->authorize_disk(vector,uid,&ar);
} }
num = vm_template->get("NIC",vectors); num = vm_template->get("NIC",vectors);
@ -108,7 +108,7 @@ void RequestManager::VirtualMachineAllocate::execute(
continue; continue;
} }
VirtualMachineAllocate::vnpool->authorize_nic(vector,&ar); VirtualMachineAllocate::vnpool->authorize_nic(vector,uid,&ar);
} }
ar.add_auth(AuthRequest::VM, ar.add_auth(AuthRequest::VM,

2
src/rm/RequestManagerDeploy.cc
View File

@ -107,7 +107,7 @@ void RequestManager::VirtualMachineDeploy::execute(
goto error_host_get; goto error_host_get;
} }
hostname = host->get_hostname(); hostname = host->get_name();
vmm_mad = host->get_vmm_mad(); vmm_mad = host->get_vmm_mad();
tm_mad = host->get_tm_mad(); tm_mad = host->get_tm_mad();

2
src/rm/RequestManagerMigrate.cc
View File

@ -67,7 +67,7 @@ void RequestManager::VirtualMachineMigrate::execute(
goto error_host_get; goto error_host_get;
} }
hostname = host->get_hostname(); hostname = host->get_name();
vmm_mad = host->get_vmm_mad(); vmm_mad = host->get_vmm_mad();
tm_mad = host->get_tm_mad(); tm_mad = host->get_tm_mad();

4
src/template/template_parser.c
View File

@ -641,7 +641,7 @@ static int input (void );
/* This used to be an fputs(), but since the string might contain NUL's, /* This used to be an fputs(), but since the string might contain NUL's,
* we now use fwrite(). * we now use fwrite().
*/ */
#define ECHO fwrite( template_text, template_leng, 1, template_out ) #define ECHO do { if (fwrite( template_text, template_leng, 1, template_out )) {} } while (0)
#endif #endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
@ -652,7 +652,7 @@ static int input (void );
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
{ \ { \
int c = '*'; \ int c = '*'; \
int n; \ unsigned n; \
for ( n = 0; n < max_size && \ for ( n = 0; n < max_size && \
(c = getc( template_in )) != EOF && c != '\n'; ++n ) \ (c = getc( template_in )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \ buf[n] = (char) c; \

15
src/vm/VirtualMachine.cc
View File

@ -124,9 +124,7 @@ int VirtualMachine::select(SqlDB * db)
return rc; return rc;
} }
//Get the History Records //Get History Records. Current history is record is built in from_xml() (if any).
// First history record is built in from_xml() (if any).
// Check if there is a previous history to be loaded from the DB:
if( hasHistory() ) if( hasHistory() )
{ {
last_seq = history->seq; last_seq = history->seq;
@ -145,7 +143,6 @@ int VirtualMachine::select(SqlDB * db)
} }
//Create support directory for this VM //Create support directory for this VM
oss.str(""); oss.str("");
oss << nd.get_var_location() << oid; oss << nd.get_var_location() << oid;
@ -153,7 +150,6 @@ int VirtualMachine::select(SqlDB * db)
chmod(oss.str().c_str(), 0777); chmod(oss.str().c_str(), 0777);
//Create Log support for this VM //Create Log support for this VM
try try
{ {
_log = new FileLog(nd.get_vm_log_filename(oid),Log::DEBUG); _log = new FileLog(nd.get_vm_log_filename(oid),Log::DEBUG);
@ -168,11 +164,6 @@ int VirtualMachine::select(SqlDB * db)
return 0; return 0;
error_history:
ose << "Can not get history for VM id: " << oid;
log("ONE", Log::ERROR, ose);
return -1;
error_previous_history: error_previous_history:
ose << "Can not get previous history record (seq:" << history->seq ose << "Can not get previous history record (seq:" << history->seq
<< ") for VM id: " << oid; << ") for VM id: " << oid;
@ -698,7 +689,7 @@ int VirtualMachine::get_disk_images(string& error_str)
continue; continue;
} }
rc = ipool->disk_attribute(disk, i, &index, &img_type); rc = ipool->disk_attribute(disk, i, &index, &img_type, uid);
if (rc == 0 ) if (rc == 0 )
{ {
@ -841,7 +832,7 @@ int VirtualMachine::get_network_leases()
continue; continue;
} }
rc = vnpool->nic_attribute(nic, oid); rc = vnpool->nic_attribute(nic, uid, oid);
if (rc == -1) if (rc == -1)
{ {

4
src/vm/vm_var_parser.c
View File

@ -620,7 +620,7 @@ static int input (void );
/* This used to be an fputs(), but since the string might contain NUL's, /* This used to be an fputs(), but since the string might contain NUL's,
* we now use fwrite(). * we now use fwrite().
*/ */
#define ECHO fwrite( vm_var_text, vm_var_leng, 1, vm_var_out ) #define ECHO do { if (fwrite( vm_var_text, vm_var_leng, 1, vm_var_out )) {} } while (0)
#endif #endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
@ -631,7 +631,7 @@ static int input (void );
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
{ \ { \
int c = '*'; \ int c = '*'; \
int n; \ unsigned n; \
for ( n = 0; n < max_size && \ for ( n = 0; n < max_size && \
(c = getc( vm_var_in )) != EOF && c != '\n'; ++n ) \ (c = getc( vm_var_in )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \ buf[n] = (char) c; \

22
src/vm/vm_var_syntax.cc
View File

@ -1,9 +1,9 @@
/* A Bison parser, made by GNU Bison 2.4.2. */ /* A Bison parser, made by GNU Bison 2.4.3. */
/* Skeleton implementation for Bison's Yacc-like parsers in C /* Skeleton implementation for Bison's Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
Foundation, Inc. 2009, 2010 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -45,7 +45,7 @@
#define YYBISON 1 #define YYBISON 1
/* Bison version. */ /* Bison version. */
#define YYBISON_VERSION "2.4.2" #define YYBISON_VERSION "2.4.3"
/* Skeleton name. */ /* Skeleton name. */
#define YYSKELETON_NAME "yacc.c" #define YYSKELETON_NAME "yacc.c"
@ -180,7 +180,7 @@ void get_network_attribute(VirtualMachine * vm,
return; return;
} }
vn = vnpool->get(network,true); vn = vnpool->get(network, vm->get_uid(), true);
if ( vn == 0 ) if ( vn == 0 )
{ {
@ -1374,7 +1374,7 @@ YYLTYPE yylloc;
YYLTYPE *yylsp; YYLTYPE *yylsp;
/* The locations where the error started and ended. */ /* The locations where the error started and ended. */
YYLTYPE yyerror_range[2]; YYLTYPE yyerror_range[3];
YYSIZE_T yystacksize; YYSIZE_T yystacksize;
@ -1754,7 +1754,7 @@ yyerrlab:
#endif #endif
} }
yyerror_range[0] = yylloc; yyerror_range[1] = yylloc;
if (yyerrstatus == 3) if (yyerrstatus == 3)
{ {
@ -1791,7 +1791,7 @@ yyerrorlab:
if (/*CONSTCOND*/ 0) if (/*CONSTCOND*/ 0)
goto yyerrorlab; goto yyerrorlab;
yyerror_range[0] = yylsp[1-yylen]; yyerror_range[1] = yylsp[1-yylen];
/* Do not reclaim the symbols of the rule which action triggered /* Do not reclaim the symbols of the rule which action triggered
this YYERROR. */ this YYERROR. */
YYPOPSTACK (yylen); YYPOPSTACK (yylen);
@ -1825,7 +1825,7 @@ yyerrlab1:
if (yyssp == yyss) if (yyssp == yyss)
YYABORT; YYABORT;
yyerror_range[0] = *yylsp; yyerror_range[1] = *yylsp;
yydestruct ("Error: popping", yydestruct ("Error: popping",
yystos[yystate], yyvsp, yylsp, mc, vm, parsed, errmsg); yystos[yystate], yyvsp, yylsp, mc, vm, parsed, errmsg);
YYPOPSTACK (1); YYPOPSTACK (1);
@ -1835,10 +1835,10 @@ yyerrlab1:
*++yyvsp = yylval; *++yyvsp = yylval;
yyerror_range[1] = yylloc; yyerror_range[2] = yylloc;
/* Using YYLLOC is tempting, but would change the location of /* Using YYLLOC is tempting, but would change the location of
the lookahead. YYLOC is available though. */ the lookahead. YYLOC is available though. */
YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
*++yylsp = yyloc; *++yylsp = yyloc;
/* Shift the error token. */ /* Shift the error token. */

6
src/vm/vm_var_syntax.h
View File

@ -1,9 +1,9 @@
/* A Bison parser, made by GNU Bison 2.4.2. */ /* A Bison parser, made by GNU Bison 2.4.3. */
/* Skeleton interface for Bison's Yacc-like parsers in C /* Skeleton interface for Bison's Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
Foundation, Inc. 2009, 2010 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by

2
src/vm/vm_var_syntax.y
View File

@ -118,7 +118,7 @@ void get_network_attribute(VirtualMachine * vm,
return; return;
} }
vn = vnpool->get(network,true); vn = vnpool->get(network, vm->get_uid(), true);
if ( vn == 0 ) if ( vn == 0 )
{ {

17
src/vnm/VirtualNetwork.cc
View File

@ -29,11 +29,10 @@
/* Virtual Network :: Constructor/Destructor */ /* Virtual Network :: Constructor/Destructor */
/* ************************************************************************** */ /* ************************************************************************** */
VirtualNetwork::VirtualNetwork(string _user_name, VirtualNetwork::VirtualNetwork(int uid,
string _user_name,
VirtualNetworkTemplate *_vn_template): VirtualNetworkTemplate *_vn_template):
PoolObjectSQL(-1, table), PoolObjectSQL(-1,"",uid,table),
name(""),
uid(-1),
user_name(_user_name), user_name(_user_name),
bridge(""), bridge(""),
type(UNINITIALIZED), type(UNINITIALIZED),
@ -71,11 +70,11 @@ VirtualNetwork::~VirtualNetwork()
const char * VirtualNetwork::table = "network_pool"; const char * VirtualNetwork::table = "network_pool";
const char * VirtualNetwork::db_names = "oid, name, body"; const char * VirtualNetwork::db_names = "oid, name, body, uid";
const char * VirtualNetwork::db_bootstrap = "CREATE TABLE IF NOT EXISTS" const char * VirtualNetwork::db_bootstrap = "CREATE TABLE IF NOT EXISTS"
" network_pool " " network_pool (oid INTEGER PRIMARY KEY, name VARCHAR(256),"
"(oid INTEGER PRIMARY KEY, name VARCHAR(256), body TEXT, UNIQUE(name))"; " body TEXT, uid INTEGER, UNIQUE(name))";
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
@ -92,7 +91,6 @@ int VirtualNetwork::select(SqlDB * db)
unsigned int default_size = VirtualNetworkPool::default_size(); unsigned int default_size = VirtualNetworkPool::default_size();
unsigned int mac_prefix = VirtualNetworkPool::mac_prefix(); unsigned int mac_prefix = VirtualNetworkPool::mac_prefix();
// Rebuld the VirtualNetwork object // Rebuld the VirtualNetwork object
rc = PoolObjectSQL::select(db); rc = PoolObjectSQL::select(db);
@ -404,7 +402,8 @@ int VirtualNetwork::insert_replace(SqlDB *db, bool replace)
oss << " INTO " << table << " (" << db_names << ") VALUES (" oss << " INTO " << table << " (" << db_names << ") VALUES ("
<< oid << "," << oid << ","
<< "'" << sql_name << "'," << "'" << sql_name << "',"
<< "'" << sql_xml << "')"; << "'" << sql_xml << "',"
<< uid << ")";
rc = db->exec(oss); rc = db->exec(oss);

75
src/vnm/VirtualNetworkPool.cc
View File

@ -32,7 +32,7 @@ unsigned int VirtualNetworkPool::_default_size;
VirtualNetworkPool::VirtualNetworkPool(SqlDB * db, VirtualNetworkPool::VirtualNetworkPool(SqlDB * db,
const string& prefix, const string& prefix,
int __default_size): int __default_size):
PoolSQL(db,VirtualNetwork::table) PoolSQL(db,VirtualNetwork::table,true)
{ {
istringstream iss; istringstream iss;
size_t pos = 0; size_t pos = 0;
@ -78,9 +78,7 @@ int VirtualNetworkPool::allocate (
{ {
VirtualNetwork * vn; VirtualNetwork * vn;
vn = new VirtualNetwork(user_name, vn_template); vn = new VirtualNetwork(uid, user_name, vn_template);
vn->uid = uid;
*oid = PoolSQL::allocate(vn, error_str); *oid = PoolSQL::allocate(vn, error_str);
@ -90,63 +88,6 @@ int VirtualNetworkPool::allocate (
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
int VirtualNetworkPool::get_cb(void * _oid, int num, char **values,char **names)
{
int * oid;
oid = static_cast<int *>(_oid);
if ( oid == 0 || values == 0 || values[0] == 0 )
{
return -1;
}
*oid = atoi(values[0]);
return 0;
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
VirtualNetwork * VirtualNetworkPool::get(const string& name, bool lock)
{
ostringstream oss;
int oid = -1;
int rc;
char * sql_name = db->escape_str(name.c_str());
if ( sql_name == 0 )
{
return 0;
}
set_callback(
static_cast<Callbackable::Callback>(&VirtualNetworkPool::get_cb),
static_cast<void *>(&oid));
oss << "SELECT oid FROM " << VirtualNetwork::table << " WHERE name = '"
<< sql_name << "'";
rc = db->exec(oss, this);
unset_callback();
db->free_str(sql_name);
if (rc != 0 || oid == -1)
{
return 0;
}
return get(oid,lock);
}
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
int VirtualNetworkPool::dump_cb(void * _oss, int VirtualNetworkPool::dump_cb(void * _oss,
int num, int num,
char ** values, char ** values,
@ -191,7 +132,7 @@ int VirtualNetworkPool::dump(ostringstream& oss, const string& where)
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
int VirtualNetworkPool::nic_attribute(VectorAttribute * nic, int vid) int VirtualNetworkPool::nic_attribute(VectorAttribute * nic, int uid, int vid)
{ {
string network; string network;
VirtualNetwork * vnet = 0; VirtualNetwork * vnet = 0;
@ -220,7 +161,7 @@ int VirtualNetworkPool::nic_attribute(VectorAttribute * nic, int vid)
} }
else else
{ {
vnet = get(network,true); vnet = get(network, uid, true);
} }
if (vnet == 0) if (vnet == 0)
@ -238,7 +179,9 @@ int VirtualNetworkPool::nic_attribute(VectorAttribute * nic, int vid)
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void VirtualNetworkPool::authorize_nic(VectorAttribute * nic, AuthRequest * ar) void VirtualNetworkPool::authorize_nic(VectorAttribute * nic,
int uid,
AuthRequest * ar)
{ {
string network; string network;
VirtualNetwork * vnet = 0; VirtualNetwork * vnet = 0;
@ -267,7 +210,7 @@ void VirtualNetworkPool::authorize_nic(VectorAttribute * nic, AuthRequest * ar)
} }
else else
{ {
vnet = get(network,true); vnet = get(network, uid, true);
} }
if (vnet == 0) if (vnet == 0)
@ -276,7 +219,7 @@ void VirtualNetworkPool::authorize_nic(VectorAttribute * nic, AuthRequest * ar)
} }
ar->add_auth(AuthRequest::NET, ar->add_auth(AuthRequest::NET,
vnet->get_vnid(), vnet->get_oid(),
AuthRequest::USE, AuthRequest::USE,
vnet->get_uid(), vnet->get_uid(),
vnet->isPublic()); vnet->isPublic());

16
src/vnm/test/VirtualNetworkPoolTest.cc
View File

@ -27,8 +27,8 @@ using namespace std;
/* ************************************************************************* */ /* ************************************************************************* */
/* ************************************************************************* */ /* ************************************************************************* */
const int uids[] = {123, 261, 133}; const int uids[] = {123, 261, 133, 78};
const string user_names[] = {"A user","B user","C user"}; const string user_names[] = {"A user","B user","C user","D user"};
const string names[] = {"Net number one", "A virtual network","Net number two"}; const string names[] = {"Net number one", "A virtual network","Net number two"};
@ -267,7 +267,7 @@ public:
CPPUNIT_ASSERT( oid >= 0 ); CPPUNIT_ASSERT( oid >= 0 );
// Get using its name // Get using its name
vn = vnpool->get(names[1], true); vn = vnpool->get(names[1],uids[1], true);
CPPUNIT_ASSERT(vn != 0); CPPUNIT_ASSERT(vn != 0);
vn->unlock(); vn->unlock();
@ -277,7 +277,7 @@ public:
vnpool->clean(); vnpool->clean();
// Get using its name // Get using its name
vn = vnpool->get(names[1], false); vn = vnpool->get(names[1], uids[1], false);
check(1, vn); check(1, vn);
}; };
@ -290,14 +290,14 @@ public:
VirtualNetwork * vn; VirtualNetwork * vn;
// Empty Pool // Empty Pool
vn = vnpool->get("Wrong name", true); vn = vnpool->get("Wrong name", 0, true);
CPPUNIT_ASSERT( vn == 0 ); CPPUNIT_ASSERT( vn == 0 );
// Allocate an object // Allocate an object
allocate(0); allocate(0);
// Ask again for a non-existing name // Ask again for a non-existing name
vn = vnpool->get("Non existing name", true); vn = vnpool->get("Non existing name", uids[0], true);
CPPUNIT_ASSERT( vn == 0 ); CPPUNIT_ASSERT( vn == 0 );
} }
@ -1098,7 +1098,7 @@ public:
disk = new VectorAttribute("DISK"); disk = new VectorAttribute("DISK");
disk->replace("NETWORK", "Net 0"); disk->replace("NETWORK", "Net 0");
((VirtualNetworkPool*)vnp)->nic_attribute(disk, 0); ((VirtualNetworkPool*)vnp)->nic_attribute(disk, 0, 0);
value = ""; value = "";
@ -1128,7 +1128,7 @@ public:
disk = new VectorAttribute("DISK"); disk = new VectorAttribute("DISK");
disk->replace("NETWORK_ID", "1"); disk->replace("NETWORK_ID", "1");
((VirtualNetworkPool*)vnp)->nic_attribute(disk, 0); ((VirtualNetworkPool*)vnp)->nic_attribute(disk,0, 0);
value = ""; value = "";
value = disk->vector_value("NETWORK"); value = disk->vector_value("NETWORK");

20
src/xml/expr_arith.cc
View File

@ -1,9 +1,9 @@
/* A Bison parser, made by GNU Bison 2.4.2. */ /* A Bison parser, made by GNU Bison 2.4.3. */
/* Skeleton implementation for Bison's Yacc-like parsers in C /* Skeleton implementation for Bison's Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
Foundation, Inc. 2009, 2010 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
@ -45,7 +45,7 @@
#define YYBISON 1 #define YYBISON 1
/* Bison version. */ /* Bison version. */
#define YYBISON_VERSION "2.4.2" #define YYBISON_VERSION "2.4.3"
/* Skeleton name. */ /* Skeleton name. */
#define YYSKELETON_NAME "yacc.c" #define YYSKELETON_NAME "yacc.c"
@ -1232,7 +1232,7 @@ YYLTYPE yylloc;
YYLTYPE *yylsp; YYLTYPE *yylsp;
/* The locations where the error started and ended. */ /* The locations where the error started and ended. */
YYLTYPE yyerror_range[2]; YYLTYPE yyerror_range[3];
YYSIZE_T yystacksize; YYSIZE_T yystacksize;
@ -1643,7 +1643,7 @@ yyerrlab:
#endif #endif
} }
yyerror_range[0] = yylloc; yyerror_range[1] = yylloc;
if (yyerrstatus == 3) if (yyerrstatus == 3)
{ {
@ -1680,7 +1680,7 @@ yyerrorlab:
if (/*CONSTCOND*/ 0) if (/*CONSTCOND*/ 0)
goto yyerrorlab; goto yyerrorlab;
yyerror_range[0] = yylsp[1-yylen]; yyerror_range[1] = yylsp[1-yylen];
/* Do not reclaim the symbols of the rule which action triggered /* Do not reclaim the symbols of the rule which action triggered
this YYERROR. */ this YYERROR. */
YYPOPSTACK (yylen); YYPOPSTACK (yylen);
@ -1714,7 +1714,7 @@ yyerrlab1:
if (yyssp == yyss) if (yyssp == yyss)
YYABORT; YYABORT;
yyerror_range[0] = *yylsp; yyerror_range[1] = *yylsp;
yydestruct ("Error: popping", yydestruct ("Error: popping",
yystos[yystate], yyvsp, yylsp, mc, oxml, result, error_msg); yystos[yystate], yyvsp, yylsp, mc, oxml, result, error_msg);
YYPOPSTACK (1); YYPOPSTACK (1);
@ -1724,10 +1724,10 @@ yyerrlab1:
*++yyvsp = yylval; *++yyvsp = yylval;
yyerror_range[1] = yylloc; yyerror_range[2] = yylloc;
/* Using YYLLOC is tempting, but would change the location of /* Using YYLLOC is tempting, but would change the location of
the lookahead. YYLOC is available though. */ the lookahead. YYLOC is available though. */
YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
*++yylsp = yyloc; *++yylsp = yyloc;
/* Shift the error token. */ /* Shift the error token. */

6
src/xml/expr_arith.h
View File

@ -1,9 +1,9 @@
/* A Bison parser, made by GNU Bison 2.4.2. */ /* A Bison parser, made by GNU Bison 2.4.3. */
/* Skeleton interface for Bison's Yacc-like parsers in C /* Skeleton interface for Bison's Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
Foundation, Inc. 2009, 2010 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by

4
src/xml/expr_parser.c
View File

@ -611,7 +611,7 @@ static int input (void );
/* This used to be an fputs(), but since the string might contain NUL's, /* This used to be an fputs(), but since the string might contain NUL's,
* we now use fwrite(). * we now use fwrite().
*/ */
#define ECHO fwrite( expr_text, expr_leng, 1, expr_out ) #define ECHO do { if (fwrite( expr_text, expr_leng, 1, expr_out )) {} } while (0)
#endif #endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
@ -622,7 +622,7 @@ static int input (void );
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
{ \ { \
int c = '*'; \ int c = '*'; \
int n; \ unsigned n; \
for ( n = 0; n < max_size && \ for ( n = 0; n < max_size && \
(c = getc( expr_in )) != EOF && c != '\n'; ++n ) \ (c = getc( expr_in )) != EOF && c != '\n'; ++n ) \
buf[n] = (char) c; \ buf[n] = (char) c; \