Revision a2c5a4cb

View differences:

include/DocumentPool.h
27 27
{
28 28
public:
29 29

  
30
    DocumentPool(SqlDB * db) : PoolSQL(db, Document::table, true, false){};
30
    DocumentPool(SqlDB * db) : PoolSQL(db, Document::table){};
31 31

  
32 32
    ~DocumentPool(){};
33 33

  
include/MarketPlaceAppPool.h
24 24
class MarketPlaceAppPool : public PoolSQL
25 25
{
26 26
public:
27
    MarketPlaceAppPool(
28
            SqlDB * db,
29
            bool    is_federation_slave)
30
                :PoolSQL(db,MarketPlaceApp::table,!is_federation_slave,true){};
27
    MarketPlaceAppPool(SqlDB * db):PoolSQL(db, MarketPlaceApp::table){};
31 28

  
32 29
    ~MarketPlaceAppPool(){};
33 30

  
include/PoolSQL.h
45 45
     *   @param _db a pointer to the database
46 46
     *   @param _table the name of the table supporting the pool (to set the oid
47 47
     *   counter). If null the OID counter is not updated.
48
     *   @param cache True to enable the cache
49
     *   @param cache_by_name True if the objects can be retrieved by name
50 48
     */
51
    PoolSQL(SqlDB * _db, const char * _table, bool cache, bool cache_by_name);
49
    PoolSQL(SqlDB * _db, const char * _table);
52 50

  
53 51
    virtual ~PoolSQL();
54 52

  
......
353 351
     *  The pool is implemented with a Map of SQL object pointers, using the
354 352
     *  OID as key.
355 353
     */
356
    map<int,PoolObjectSQL *> pool;
357

  
358
    /**
359
     * Whether or not this pool uses the name_pool index
360
     */
361
    bool uses_name_pool;
362

  
363
    /**
364
     *  This is a name index for the pool map. The key is the name of the object
365
     *  , that may be combained with the owner id.
366
     */
367
    map<string,PoolObjectSQL *> name_pool;
354
    vector<PoolObjectSQL *> pool;
368 355

  
369 356
    /**
370 357
     *  Factory method, must return an ObjectSQL pointer to an allocated pool
include/VMGroupPool.h
25 25
class VMGroupPool : public PoolSQL
26 26
{
27 27
public:
28
    VMGroupPool(SqlDB * db):PoolSQL(db, VMGroup::table, true, true){};
28
    VMGroupPool(SqlDB * db):PoolSQL(db, VMGroup::table){};
29 29

  
30 30
    ~VMGroupPool(){};
31 31

  
include/VMTemplatePool.h
27 27
{
28 28
public:
29 29

  
30
    VMTemplatePool(SqlDB * db) : PoolSQL(db, VMTemplate::table, true, true){};
30
    VMTemplatePool(SqlDB * db) : PoolSQL(db, VMTemplate::table){};
31 31

  
32 32
    ~VMTemplatePool(){};
33 33

  
include/VirtualRouterPool.h
28 28
public:
29 29

  
30 30
    VirtualRouterPool(SqlDB * db, vector<const VectorAttribute *> hook_mads,
31
        const string& remotes_location) : PoolSQL(db, VirtualRouter::table, true, true)
31
        const string& remotes_location) : PoolSQL(db, VirtualRouter::table)
32 32
    {
33 33
        register_hooks(hook_mads, remotes_location);
34 34
    };
src/cluster/ClusterPool.cc
36 36
/* -------------------------------------------------------------------------- */
37 37

  
38 38
ClusterPool::ClusterPool(SqlDB * db, const VectorAttribute * _vnc_conf):
39
    PoolSQL(db, Cluster::table, true, true), vnc_conf(_vnc_conf)
39
    PoolSQL(db, Cluster::table), vnc_conf(_vnc_conf)
40 40
{
41 41
    ostringstream oss;
42 42
    string        error_str;
src/datastore/DatastorePool.cc
41 41
DatastorePool::DatastorePool(
42 42
        SqlDB * db,
43 43
        const vector<const SingleAttribute *>& _inherit_attrs) :
44
    PoolSQL(db, Datastore::table, true, true)
44
    PoolSQL(db, Datastore::table)
45 45

  
46 46
{
47 47
    ostringstream oss;
src/group/GroupPool.cc
39 39

  
40 40
GroupPool::GroupPool(SqlDB * db, vector<const VectorAttribute *> hook_mads,
41 41
    const string& remotes_location, bool is_federation_slave) :
42
        PoolSQL(db, Group::table, !is_federation_slave, true)
42
        PoolSQL(db, Group::table)
43 43
{
44 44
    ostringstream oss;
45 45
    string        error_str;
src/host/HostPool.cc
41 41
                   const string&             hook_location,
42 42
                   const string&             remotes_location,
43 43
                   time_t                    expire_time)
44
                        : PoolSQL(db, Host::table, true, true)
44
                        : PoolSQL(db, Host::table)
45 45
{
46 46

  
47 47
    _monitor_expiration = expire_time;
src/image/ImagePool.cc
42 42
        vector<const VectorAttribute *>& hook_mads,
43 43
        const string&                    remotes_location,
44 44
        const vector<const SingleAttribute *>& _inherit_attrs)
45
    :PoolSQL(db, Image::table, true, true)
45
    :PoolSQL(db, Image::table)
46 46
{
47 47
    // Init static defaults
48 48
    _default_type       = __default_type;
src/market/MarketPlacePool.cc
21 21

  
22 22
/* -------------------------------------------------------------------------- */
23 23

  
24
MarketPlacePool::MarketPlacePool(
25
        SqlDB * db,
26
        bool    is_federation_slave)
27
    :PoolSQL(db, MarketPlace::table, !is_federation_slave, true)
24
MarketPlacePool::MarketPlacePool(SqlDB * db, bool is_federation_slave)
25
    :PoolSQL(db, MarketPlace::table)
28 26
{
29 27
    //Federation slaves do not need to init the pool
30 28
    if (is_federation_slave)
src/nebula/Nebula.cc
663 663
        secgrouppool = new SecurityGroupPool(logdb);
664 664

  
665 665
        marketpool = new MarketPlacePool(db_ptr, is_federation_slave());
666
        apppool    = new MarketPlaceAppPool(db_ptr, is_federation_slave());
666
        apppool    = new MarketPlaceAppPool(db_ptr);
667 667

  
668 668
        vmgrouppool = new VMGroupPool(logdb);
669 669

  
src/pool/PoolSQL.cc
87 87
/* -------------------------------------------------------------------------- */
88 88
/* -------------------------------------------------------------------------- */
89 89

  
90
PoolSQL::PoolSQL(SqlDB * _db, const char * _table, bool _cache, bool by_name):
91
    db(_db), table(_table), uses_name_pool(by_name)
90
PoolSQL::PoolSQL(SqlDB * _db, const char * _table):
91
    db(_db), table(_table)
92 92
{
93 93
    pthread_mutex_init(&mutex,0);
94 94
};
......
98 98

  
99 99
PoolSQL::~PoolSQL()
100 100
{
101
    map<int,PoolObjectSQL *>::iterator  it;
101
    vector<PoolObjectSQL *>::iterator it;
102 102

  
103 103
    pthread_mutex_lock(&mutex);
104 104

  
105
    for ( it = pool.begin(); it != pool.end(); it++)
105
    for ( it = pool.begin(); it != pool.end(); ++it)
106 106
    {
107
        it->second->lock();
107
        (*it)->lock();
108 108

  
109
        delete it->second;
109
        delete *it;
110 110
    }
111 111

  
112 112
    pthread_mutex_unlock(&mutex);
......
192 192
        return 0;
193 193
    }
194 194

  
195
    pool.insert(make_pair(objectsql->oid, objectsql));
196

  
197
    if ( uses_name_pool )
198
    {
199
        string okey = key(objectsql->name, objectsql->uid);
200

  
201
        name_pool.insert(make_pair(okey, objectsql));
202
    }
195
    pool.push_back(objectsql);
203 196

  
204 197
    if ( olock == true )
205 198
    {
......
216 209

  
217 210
PoolObjectSQL * PoolSQL::get(const string& name, int ouid, bool olock)
218 211
{
219
    if ( uses_name_pool == false )
220
    {
221
        return 0;
222
    }
223

  
224 212
    lock();
225 213

  
226 214
    string name_key = key(name, ouid);
......
242 230
        return 0;
243 231
    }
244 232

  
245
    pool.insert(make_pair(objectsql->oid, objectsql));
246

  
247
    name_pool.insert(make_pair(name_key, objectsql));
233
    pool.push_back(objectsql);
248 234

  
249 235
    if ( olock == true )
250 236
    {
......
261 247

  
262 248
void PoolSQL::flush_cache(int oid)
263 249
{
264
    int  rc;
265
    PoolObjectSQL * tmp_ptr;
266

  
267
    map<int,PoolObjectSQL *>::iterator  it;
268

  
269
    for (it = pool.begin(); it != pool.end(); )
250
    for (vector<PoolObjectSQL *>::iterator it = pool.begin(); it != pool.end();)
270 251
    {
271 252
        // The object we are looking for in ::get(). Wait until it is unlocked()
272
        if (it->first == oid)
253
        if ((*it)->oid == oid)
273 254
        {
274
            it->second->lock();
255
            (*it)->lock();
275 256
        }
276 257
        else
277 258
        {
278 259
            // Any other locked object is just ignored
279
            rc = pthread_mutex_trylock(&(it->second->mutex));
260
            int rc = pthread_mutex_trylock(&((*it)->mutex));
280 261

  
281 262
            if ( rc == EBUSY ) // In use by other thread
282 263
            {
......
285 266
            }
286 267
        }
287 268

  
288
        tmp_ptr = it->second;
269
        delete *it;
289 270

  
290
        // map::erase does not invalidate iterator, except for the current one
291 271
        it = pool.erase(it);
292

  
293
        if ( uses_name_pool )
294
        {
295
            string okey = key(tmp_ptr->name, tmp_ptr->uid);
296

  
297
            name_pool.erase(okey);
298
        }
299

  
300
        delete tmp_ptr;
301 272
    }
302 273
}
303 274

  
......
306 277

  
307 278
void PoolSQL::flush_cache(const string& name_key)
308 279
{
309
    int  rc;
310
    PoolObjectSQL * tmp_ptr;
311

  
312
    map<string,PoolObjectSQL *>::iterator it;
313

  
314
    for (it = name_pool.begin(); it != name_pool.end(); )
280
    for (vector<PoolObjectSQL *>::iterator it = pool.begin(); it != pool.end();)
315 281
    {
282
        string okey = key((*it)->name, (*it)->uid);
283

  
316 284
        // The object we are looking for in ::get(). Wait until it is unlocked()
317
        if (name_key == it->first)
285
        if ( name_key == okey)
318 286
        {
319
            it->second->lock();
287
            (*it)->lock();
320 288
        }
321 289
        else
322 290
        {
323 291
            // Any other locked object is just ignored
324
            rc = pthread_mutex_trylock(&(it->second->mutex));
292
            int rc = pthread_mutex_trylock(&((*it)->mutex));
325 293

  
326 294
            if ( rc == EBUSY ) // In use by other thread
327 295
            {
......
330 298
            }
331 299
        }
332 300

  
333
        tmp_ptr = it->second;
334

  
335
        // map::erase does not invalidate iterator, except for the current one
336
        it = name_pool.erase(it);
337

  
338
        pool.erase(tmp_ptr->oid);
301
        delete *it;
339 302

  
340
        delete tmp_ptr;
303
        it = pool.erase(it);
341 304
    }
342 305
}
343 306

  
......
346 309

  
347 310
void PoolSQL::clean()
348 311
{
349
    map<int,PoolObjectSQL *>::iterator  it;
312
    vector<PoolObjectSQL *>::iterator it;
350 313

  
351 314
    lock();
352 315

  
353
    for ( it = pool.begin(); it != pool.end(); it++)
316
    for (it = pool.begin(); it != pool.end(); ++it)
354 317
    {
355
        it->second->lock();
318
        (*it)->lock();
356 319

  
357
        delete it->second;
320
        delete *it;
358 321
    }
359 322

  
360 323
    pool.clear();
361 324

  
362
    name_pool.clear();
363

  
364 325
    unlock();
365 326
}
366 327

  
src/secgroup/SecurityGroupPool.cc
21 21

  
22 22
/* -------------------------------------------------------------------------- */
23 23

  
24
SecurityGroupPool::SecurityGroupPool(SqlDB * db)
25
    :PoolSQL(db, SecurityGroup::table, true, true)
24
SecurityGroupPool::SecurityGroupPool(SqlDB * db):PoolSQL(db,SecurityGroup::table)
26 25
{
27 26
    //lastOID is set in PoolSQL::init_cb
28 27
    if (get_lastOID() == -1)
src/um/UserPool.cc
56 56
                   vector<const VectorAttribute *> hook_mads,
57 57
                   const string&             remotes_location,
58 58
                   bool                      is_federation_slave):
59
                       PoolSQL(db, User::table, !is_federation_slave, true)
59
                       PoolSQL(db, User::table)
60 60
{
61 61
    int           one_uid    = -1;
62 62
    int           server_uid = -1;
src/vdc/VdcPool.cc
25 25

  
26 26
/* -------------------------------------------------------------------------- */
27 27

  
28
VdcPool::VdcPool(SqlDB * db, bool is_federation_slave)
29
    :PoolSQL(db, Vdc::table, !is_federation_slave, true)
28
VdcPool::VdcPool(SqlDB * db, bool is_federation_slave): PoolSQL(db, Vdc::table)
30 29
{
31 30
    string error_str;
32 31

  
src/vm/VirtualMachinePool.cc
47 47
        float                       default_cpu_cost,
48 48
        float                       default_mem_cost,
49 49
        float                       default_disk_cost)
50
    : PoolSQL(db, VirtualMachine::table, true, false),
50
    : PoolSQL(db, VirtualMachine::table),
51 51
    _monitor_expiration(expire_time), _submit_on_hold(on_hold),
52 52
    _default_cpu_cost(default_cpu_cost), _default_mem_cost(default_mem_cost),
53 53
    _default_disk_cost(default_disk_cost)
src/vnm/VirtualNetworkPool.cc
48 48
    const vector<const SingleAttribute *>& _inherit_attrs,
49 49
    const VectorAttribute *             _vlan_conf,
50 50
    const VectorAttribute *             _vxlan_conf):
51
        PoolSQL(db, VirtualNetwork::table, true, true), vlan_conf(_vlan_conf),
51
        PoolSQL(db, VirtualNetwork::table), vlan_conf(_vlan_conf),
52 52
        vlan_id_bitmap(vlan_conf, VLAN_BITMAP_ID, vlan_table),
53 53
        vxlan_conf(_vxlan_conf)
54 54
{
src/zone/ZonePool.cc
28 28

  
29 29
/* -------------------------------------------------------------------------- */
30 30

  
31
ZonePool::ZonePool(SqlDB * db, bool is_federation_slave)
32
    :PoolSQL(db, Zone::table, !is_federation_slave, true)
31
ZonePool::ZonePool(SqlDB * db, bool is_federation_slave):PoolSQL(db,Zone::table)
33 32
{
34 33
    string error_str;
35 34

  

Also available in: Unified diff