Revision ca2a1a42

View differences:

include/Host.h
402 402
     */
403 403
    const set<int>& get_prev_rediscovered_vms() const
404 404
    {
405
        return prev_rediscovered_vms;
405
        return *prev_rediscovered_vms;
406 406
    }
407 407

  
408 408
    /**
......
412 412
     */
413 413
    void set_prev_rediscovered_vms(const set<int>& rediscovered_vms)
414 414
    {
415
        prev_rediscovered_vms = rediscovered_vms;
415
        *prev_rediscovered_vms = rediscovered_vms;
416 416
    }
417 417

  
418 418
private:
......
453 453
    /**
454 454
     *  The Share represents the logical capacity associated with the host
455 455
     */
456
    HostShare       host_share;
456
    HostShare host_share;
457 457

  
458 458
    /**
459 459
     * Tmp set of lost VM IDs. Used to give lost VMs one grace cycle, in case
460 460
     * they reappear.
461 461
     */
462
    set<int>        tmp_lost_vms;
462
    set<int> * tmp_lost_vms;
463 463

  
464 464
    /**
465 465
     * Tmp set of zombie VM IDs. Used to give zombie VMs one grace cycle, in
466 466
     * case they are cleaned.
467 467
     */
468
    set<int>        tmp_zombie_vms;
468
    set<int> * tmp_zombie_vms;
469 469

  
470 470
    /**
471 471
     * Set that stores the VMs reported as found from the poweroff state. This
472 472
     * is managed from outside the host to avoid deadlocks, as the current
473 473
     * VM state is needed
474 474
     */
475
    set<int>        prev_rediscovered_vms;
475
    set<int> * prev_rediscovered_vms;
476 476

  
477 477
    // -------------------------------------------------------------------------
478 478
    //  VM Collection
include/HostPool.h
39 39
        const string& hook_location, const string& remotes_location,
40 40
        time_t expire_time);
41 41

  
42
    ~HostPool(){};
42
    ~HostPool();
43 43

  
44 44
    /**
45 45
     *  Function to allocate a new Host object
......
66 66
        int     oid,
67 67
        bool    lock)
68 68
    {
69
        return static_cast<Host *>(PoolSQL::get(oid,lock));
69
        Host * h = static_cast<Host *>(PoolSQL::get(oid,lock));
70

  
71
        if ( h != 0 )
72
        {
73
            HostVM * hv = get_host_vm(oid);
74

  
75
            h->tmp_lost_vms   = &(hv->tmp_lost_vms);
76
            h->tmp_zombie_vms = &(hv->tmp_zombie_vms);
77

  
78
            h->prev_rediscovered_vms = &(hv->prev_rediscovered_vms);
79
        }
80

  
81
        return h;
70 82
    };
71 83

  
72 84
    /**
......
79 91
    Host * get(string name, bool lock)
80 92
    {
81 93
        // The owner is set to -1, because it is not used in the key() method
82
        return static_cast<Host *>(PoolSQL::get(name,-1,lock));
94
        Host * h = static_cast<Host *>(PoolSQL::get(name,-1,lock));
95

  
96
        if ( h != 0 )
97
        {
98
            HostVM * hv = get_host_vm(h->oid);
99

  
100
            h->tmp_lost_vms   = &(hv->tmp_lost_vms);
101
            h->tmp_zombie_vms = &(hv->tmp_zombie_vms);
102

  
103
            h->prev_rediscovered_vms = &(hv->prev_rediscovered_vms);
104
        }
105

  
106
        return h;
83 107
    };
84 108

  
85 109
    /**
......
180 204
            return -1;
181 205
        }
182 206

  
183
        return PoolSQL::drop(objsql, error_msg);
207
        int rc = PoolSQL::drop(objsql, error_msg);
208

  
209
        if ( rc == 0 )
210
        {
211
            delete_host_vm(host->oid);
212
        }
213

  
214
        return rc;
184 215
    };
185 216

  
186 217
    /**
......
265 296
    int clean_expired_monitoring();
266 297

  
267 298
private:
299
    /**
300
     * Stores several Host counters to give VMs one monitor grace cycle before
301
     * moving them to another state
302
     */
303
    struct HostVM
304
    {
305
        /**
306
         * Tmp set of lost VM IDs. 
307
         */
308
        set<int> tmp_lost_vms;
309

  
310
        /**
311
         * Tmp set of zombie VM IDs. 
312
         */
313
        set<int> tmp_zombie_vms;
314

  
315
        /**
316
         * VMs reported as found from the poweroff state.
317
         */
318
        set<int> prev_rediscovered_vms;
319
    };
320

  
321
    map<int, HostVM *> host_vms;
322

  
323
    HostVM * get_host_vm(int oid);
324

  
325
    void delete_host_vm(int oid);
268 326

  
269 327
    /**
270 328
     *  Factory method to produce Host objects
src/host/Host.cc
253 253
    set<int>::iterator        set_it;
254 254
    map<int,string>::iterator map_it;
255 255

  
256
    set<int> prev_tmp_lost   = tmp_lost_vms;
257
    set<int> prev_tmp_zombie = tmp_zombie_vms;
256
    set<int> prev_tmp_lost   = *tmp_lost_vms;
257
    set<int> prev_tmp_zombie = *tmp_zombie_vms;
258 258

  
259 259
    int num_zombies = 0;
260 260
    int num_wilds   = 0;
......
298 298

  
299 299
    obj_template->remove("VM", vm_att);
300 300

  
301
    tmp_lost_vms = vm_collection.clone();
301
    *tmp_lost_vms = vm_collection.clone();
302 302

  
303
    tmp_zombie_vms.clear();
303
    tmp_zombie_vms->clear();
304 304

  
305 305
    for (it = vm_att.begin(); it != vm_att.end(); it++)
306 306
    {
......
328 328

  
329 329
            it_vm = found.find(vmid);
330 330

  
331
            if ( tmp_lost_vms.erase(vmid) == 1 ) //Good, known
331
            if ( tmp_lost_vms->erase(vmid) == 1 ) //Good, known
332 332
            {
333 333
                found.insert(make_pair(vmid, vatt->vector_value("POLL")));
334 334
            }
......
338 338
            }
339 339
            else //Bad, known but should not be here
340 340
            {
341
                tmp_zombie_vms.insert(vmid);
341
                tmp_zombie_vms->insert(vmid);
342 342

  
343 343
                // Reported as zombie at least 2 times?
344 344
                if (prev_tmp_zombie.count(vmid) == 1)
......
389 389
    {
390 390
        if ( one_util::regex_match("STATE=. ",map_it->second.c_str()) != 0 )
391 391
        {
392
            tmp_lost_vms.insert(map_it->first);
392
            tmp_lost_vms->insert(map_it->first);
393 393
            found.erase(map_it++);
394 394
        }
395 395
        else
......
398 398
        }
399 399
    }
400 400

  
401
    for(set_it = tmp_lost_vms.begin(); set_it != tmp_lost_vms.end(); set_it++)
401
    for(set_it = tmp_lost_vms->begin(); set_it != tmp_lost_vms->end(); set_it++)
402 402
    {
403 403
        // Reported as lost at least 2 times?
404 404
        if (prev_tmp_lost.count(*set_it) == 1)
src/host/HostPool.cc
145 145
/* -------------------------------------------------------------------------- */
146 146
/* -------------------------------------------------------------------------- */
147 147

  
148
HostPool::~HostPool()
149
{
150
    map<int, HostVM *>::iterator it;
151

  
152
    for (it=host_vms.begin(); it != host_vms.end() ; ++it)
153
    {
154
        delete it->second;
155
    } 
156
};
157

  
158
/* -------------------------------------------------------------------------- */
159
/* -------------------------------------------------------------------------- */
160

  
148 161
int HostPool::allocate (
149 162
    int * oid,
150 163
    const string& hostname,
......
322 335

  
323 336
    return rc;
324 337
}
338

  
339
/* -------------------------------------------------------------------------- */
340
/* -------------------------------------------------------------------------- */
341

  
342
HostPool::HostVM * HostPool::get_host_vm(int oid)
343
{
344
    HostVM * hvm;
345

  
346
    map<int, HostVM *>::iterator it = host_vms.find(oid);
347

  
348
    if ( it == host_vms.end() )
349
    {
350
        hvm = new HostVM;
351

  
352
        host_vms.insert(make_pair(oid, new HostVM));
353
    }
354
    else
355
    {
356
        hvm = it->second;
357
    }
358

  
359
    return hvm;
360
}
361

  
362
void HostPool::delete_host_vm(int oid)
363
{
364
    HostVM * hvm;
365

  
366
    map<int, HostVM *>::iterator it = host_vms.find(oid);
367

  
368
    if ( it != host_vms.end() )
369
    {
370
        delete it->second;
371

  
372
        host_vms.erase(it);
373
    }
374
}
375

  
src/vmm/LibVirtDriverKVM.cc
870 870
        script = nic[i]->vector_value("SCRIPT");
871 871
        model  = nic[i]->vector_value("MODEL");
872 872
        ip     = nic[i]->vector_value("IP");
873
        vrouter_ip = nic[i]->vector_value("VROUTER_IP");
874 873
        filter = nic[i]->vector_value("FILTER");
875 874

  
875
        vrouter_ip = nic[i]->vector_value("VROUTER_IP");
876

  
876 877
        i_avg_bw  = nic[i]->vector_value("INBOUND_AVG_BW");
877 878
        i_peak_bw = nic[i]->vector_value("INBOUND_PEAK_BW");
878 879
        i_peak_kb = nic[i]->vector_value("INBOUND_PEAK_KB");
......
959 960
                         << one_util::escape_xml_attr(*the_filter) << ">\n"
960 961
                     << "\t\t\t\t<parameter name='IP' value="
961 962
                         << one_util::escape_xml_attr(ip) << "/>\n";
963

  
962 964
                if ( !vrouter_ip.empty() )
963 965
                {
964 966
                    file << "\t\t\t\t<parameter name='IP' value="
965 967
                            << one_util::escape_xml_attr(vrouter_ip) << "/>\n";
966 968
                }
969

  
967 970
                file << "\t\t\t</filterref>\n";
968 971
            }
969 972
        }

Also available in: Unified diff