resched-3.4.0.patch

Chris Johnston, 04/18/2012 03:04 PM

Download (18.7 KB)

View differences:

opennebula-3.4.0/include/DispatchManager.h 2012-04-18 13:28:31.671304264 +0000
202 202
        int vid);
203 203

  
204 204
    /**
205
     *  Moves a VM to RESCHED state
206
     *    @param vid VirtualMachine identification
207
     *    @return 0 on success, -1 if the VM does not exits or -2 if the VM is
208
     *    in a wrong a state
209
     */
210
    int resched(
211
        int vid);
212

  
213
    /**
205 214
     *  Moves a VM to PENDING state preserving any resource (i.e. leases) and id
206 215
     *    @param vid VirtualMachine identification
207 216
     *    @return 0 on success, -1 if the VM does not exits or -2 if the VM is
......
267 276

  
268 277
    void  failed_action(int vid);
269 278

  
279
    void  resched_action(int vid);
280

  
270 281
    void  resubmit_action(int vid);
271 282
};
272 283

  
opennebula-3.4.0/include/VirtualMachine.h 2012-04-18 13:28:31.671304264 +0000
55 55
        STOPPED   = 4,
56 56
        SUSPENDED = 5,
57 57
        DONE      = 6,
58
        FAILED    = 7
58
        FAILED    = 7,
59
        RESCHED   = 8
59 60
    };
60 61

  
61 62
    /**
opennebula-3.4.0/src/cli/one_helper/onevm_helper.rb 2012-04-18 13:29:57.211500431 +0000
85 85
            column :HOSTNAME, "Host where the VM is running", :size=>15 do |d|
86 86
                if d['HISTORY_RECORDS'] && d['HISTORY_RECORDS']['HISTORY']
87 87
                    state_str = VirtualMachine::VM_STATE[d['STATE'].to_i]
88
                    if %w{ACTIVE SUSPENDED}.include? state_str
88
                    if %w{ACTIVE SUSPENDED RESCHED}.include? state_str
89 89
                        d['HISTORY_RECORDS']['HISTORY']['HOSTNAME']
90 90
                    end
91 91
                end
opennebula-3.4.0/src/cli/onevm 2012-04-18 13:28:31.671304264 +0000
254 254
        end
255 255
    end
256 256

  
257
    resched_desc = <<-EOT.unindent
258
        Reschedules the VM.
259

  
260
        States: RUNNING
261
    EOT
262

  
263
    command :resched, resched_desc, [:range,:vmid_list] do
264
        helper.perform_actions(args[0],options,"rescheduling") do |vm|
265
            vm.resched
266
        end
267
    end
268

  
257 269
    resubmit_desc = <<-EOT.unindent
258 270
        Resubmits the VM to PENDING state. This is intented for VMs stuck in a
259 271
        transient state. To re-deploy a fresh copy of the same VM, create a
opennebula-3.4.0/src/dm/DispatchManagerActions.cc 2012-04-18 13:28:31.671304264 +0000
134 134
    oss << "Live-migrating VM " << vid;
135 135
    NebulaLog::log("DiM",Log::DEBUG,oss);
136 136

  
137
    if (vm->get_state()     == VirtualMachine::ACTIVE &&
137
    if ((vm->get_state()    == VirtualMachine::ACTIVE || vm->get_state() == VirtualMachine::RESCHED) &&
138 138
        vm->get_lcm_state() == VirtualMachine::RUNNING )
139 139
    {
140 140
        Nebula&             nd  = Nebula::instance();
......
628 628
            vm->log("DiM", Log::INFO, "New VM state is DONE.");
629 629
        break;
630 630

  
631
        case VirtualMachine::RESCHED:
631 632
        case VirtualMachine::ACTIVE:
632 633
            lcm->trigger(LifeCycleManager::DELETE,vid);
633 634
        break;
......
662 663

  
663 664
    switch (vm->get_state())
664 665
    {
666
        case VirtualMachine::RESCHED:
667
            NebulaLog::log("DiM",Log::ERROR,
668
                "Cannot resubmit a rescheduled VM. Let it reschedule first");
669
            rc = -2;
670
        break;
671

  
665 672
        case VirtualMachine::SUSPENDED:
666 673
            NebulaLog::log("DiM",Log::ERROR,
667 674
                "Cannot resubmit a suspended VM. Resume it first");
......
697 704

  
698 705
    return rc;
699 706
}
707

  
708
/* -------------------------------------------------------------------------- */
709
/* -------------------------------------------------------------------------- */
710

  
711
int DispatchManager::resched(
712
    int vid)
713
{
714
    VirtualMachine *    vm;
715
    ostringstream       oss;
716

  
717
    vm = vmpool->get(vid,true);
718

  
719
    if ( vm == 0 )
720
    {
721
        return -1;
722
    }
723

  
724
    oss << "Rescheduling VM " << vid;
725
    NebulaLog::log("DiM",Log::DEBUG,oss);
726

  
727
    if (vm->get_state()     == VirtualMachine::ACTIVE &&
728
        vm->get_lcm_state() == VirtualMachine::RUNNING )
729
    {
730
        vm->set_state(VirtualMachine::RESCHED);
731
        vmpool->update(vm);
732

  
733
        vm->log("DiM", Log::INFO, "New VM state is RESCHED.");
734
    }
735
    else
736
    {
737
        goto error;
738
    }
739

  
740
    vm->unlock();
741

  
742
    return 0;
743

  
744
error:
745
    oss.str("");
746
    oss << "Could not reschedule VM " << vid << ", wrong state.";
747
    NebulaLog::log("DiM",Log::ERROR,oss);
748

  
749
    vm->unlock();
750
    return -2;
751
}
opennebula-3.4.0/src/dm/DispatchManagerStates.cc 2012-04-18 13:28:31.671304264 +0000
112 112
    lcm_state = vm->get_lcm_state();
113 113
    dm_state  = vm->get_state();
114 114

  
115
    if ((dm_state == VirtualMachine::ACTIVE) &&
115
    if ((dm_state == VirtualMachine::ACTIVE || dm_state == VirtualMachine::RESCHED) &&
116 116
          (lcm_state == VirtualMachine::EPILOG ||
117 117
           lcm_state == VirtualMachine::CANCEL ||
118 118
           lcm_state == VirtualMachine::CLEANUP ))
opennebula-3.4.0/src/lcm/LifeCycleActions.cc 2012-04-18 13:28:31.671304264 +0000
241 241
        return;
242 242
    }
243 243

  
244
    if (vm->get_state() == VirtualMachine::ACTIVE &&
244
    if ((vm->get_state() == VirtualMachine::ACTIVE || vm->get_state() == VirtualMachine::RESCHED) &&
245 245
        vm->get_lcm_state() == VirtualMachine::RUNNING)
246 246
    {
247 247
        Nebula&                 nd = Nebula::instance();
......
252 252
        //                   MIGRATE STATE
253 253
        //----------------------------------------------------
254 254

  
255
        vm->set_state(VirtualMachine::ACTIVE);
256

  
255 257
        vm->set_state(VirtualMachine::MIGRATE);
256 258

  
257 259
        vmpool->update(vm);
opennebula-3.4.0/src/oca/ruby/OpenNebula/VirtualMachine.rb 2012-04-18 13:28:31.671304264 +0000
35 35
            :chmod    => "vm.chmod",
36 36
        }
37 37

  
38
        VM_STATE=%w{INIT PENDING HOLD ACTIVE STOPPED SUSPENDED DONE FAILED}
38
        VM_STATE=%w{INIT PENDING HOLD ACTIVE STOPPED SUSPENDED DONE FAILED RESCHED}
39 39

  
40 40
        LCM_STATE=%w{LCM_INIT PROLOG BOOT RUNNING MIGRATE SAVE_STOP SAVE_SUSPEND
41 41
            SAVE_MIGRATE PROLOG_MIGRATE PROLOG_RESUME EPILOG_STOP EPILOG
......
49 49
            "STOPPED"   => "stop",
50 50
            "SUSPENDED" => "susp",
51 51
            "DONE"      => "done",
52
            "FAILED"    => "fail"
52
            "FAILED"    => "fail",
53
            "RESCHED"   => "resc"
53 54
        }
54 55

  
55 56
        SHORT_LCM_STATES={
......
189 190
            action('restart')
190 191
        end
191 192

  
193
        # Reschedules a VM
194
        def resched
195
            action('resched')
196
        end
197

  
192 198
        # Resubmits a VM to PENDING state
193 199
        def resubmit
194 200
            action('resubmit')
opennebula-3.4.0/src/rm/RequestManagerPoolInfoFilter.cc 2012-04-18 13:28:31.671304264 +0000
62 62
    ostringstream state_filter;
63 63

  
64 64
    if (( state < VirtualMachinePoolInfo::ALL_VM ) ||
65
        ( state > VirtualMachine::FAILED ))
65
        ( state > VirtualMachine::RESCHED ))
66 66
    {
67 67
        failure_response(XML_RPC_API,
68 68
                         request_error("Incorrect filter_flag, state",""),
opennebula-3.4.0/src/rm/RequestManagerVirtualMachine.cc 2012-04-18 13:28:31.671304264 +0000
225 225
    {
226 226
        rc = dm->finalize(id);
227 227
    }
228
    else if (action == "resched")
229
    {
230
        rc = dm->resched(id);
231
    }
228 232
    else if (action == "resubmit")
229 233
    {
230 234
        rc = dm->resubmit(id);
......
363 367
        return;
364 368
    }
365 369

  
366
    if((vm->get_state()     != VirtualMachine::ACTIVE)  ||
370
    if((vm->get_state()     != VirtualMachine::ACTIVE && vm->get_state() != VirtualMachine::RESCHED)  ||
367 371
       (vm->get_lcm_state() != VirtualMachine::RUNNING) ||
368 372
       (vm->hasPreviousHistory() && vm->get_previous_reason() == History::NONE))
369 373
    {
opennebula-3.4.0/src/scheduler/include/Scheduler.h 2012-04-18 13:28:31.671304264 +0000
116 116

  
117 117
    virtual int schedule();
118 118

  
119
    virtual int set_up_pools();
119
    virtual int set_up_pools(int vmstate);
120 120

  
121 121
private:
122 122
    Scheduler(Scheduler const&){};
opennebula-3.4.0/src/scheduler/include/VirtualMachinePoolXML.h 2012-04-18 13:28:31.671304264 +0000
34 34

  
35 35
    ~VirtualMachinePoolXML(){};
36 36

  
37
    int set_up();
37
    int set_up(int vmstate);
38 38

  
39 39
    /**
40 40
     *  Gets an object from the pool
......
59 59
    virtual void add_object(xmlNodePtr node);
60 60

  
61 61
    virtual int load_info(xmlrpc_c::value &result);
62

  
63
    int state;
62 64
};
63 65

  
64 66
#endif /* VM_POOL_XML_H_ */
opennebula-3.4.0/src/scheduler/include/VirtualMachineXML.h 2012-04-18 14:09:18.422958733 +0000
56 56
        return gid;
57 57
    };
58 58

  
59
    int get_hid() const
60
    {
61
        return hid;
62
    };
63

  
59 64
    /**
60 65
     *  Adds a new share to the map of suitable shares to start this VM
61 66
     *    @param  hid of the selected host
......
151 156
    int     uid;
152 157
    int     gid;
153 158

  
159
    int     hid;
160

  
154 161
    int     memory;
155 162
    float   cpu;
156 163

  
opennebula-3.4.0/src/scheduler/SConstruct 2012-04-18 13:28:31.671304264 +0000
23 23
# Include dirs
24 24
env.Append(CPPPATH=[
25 25
    cwd + '/include/',
26
    cwd + '../../include/'
26 27
])
27 28

  
28 29
# Library dirs
opennebula-3.4.0/src/scheduler/src/pool/VirtualMachinePoolXML.cc 2012-04-18 13:28:31.671304264 +0000
15 15
/* -------------------------------------------------------------------------- */
16 16

  
17 17
#include "VirtualMachinePoolXML.h"
18
#include "VirtualMachine.h"
18 19
#include <stdexcept>
19 20

  
20
int VirtualMachinePoolXML::set_up()
21
int VirtualMachinePoolXML::set_up(int vmstate)
21 22
{
22 23
    ostringstream   oss;
23 24
    int             rc;
25
    state = vmstate;
24 26
    rc = PoolXML::set_up();
25 27
    if ( rc == 0 )
26 28
    {
27 29
        oss.str("");
28
        oss << "Pending virtual machines :";
30
        oss << "Pending virtual machines for state=" << state << ":";
29 31

  
30 32
        map<int,ObjectXML*>::iterator it;
31 33

  
......
72 74
                     -2,                            // VM from all users
73 75
                     -1,                            // start_id (none)
74 76
                     -1,                            // end_id (none)
75
                     1);                            // in pending state
77
                     state);                        // state
76 78
        return 0;
77 79
    }
78 80
    catch (exception const& e)
......
95 97
    ostringstream               oss;
96 98
    xmlrpc_c::value             deploy_result;
97 99

  
100

  
98 101
    oss.str("");
99 102
    oss << "Dispatching virtual machine " << vid
100 103
        << " to HID: " << hid;
......
103 106

  
104 107
    try
105 108
    {
106
        client->call( client->get_endpoint(),           // serverUrl
107
                      "one.vm.deploy",                  // methodName
108
                      "sii",                            // arguments format
109
                      &deploy_result,                   // resultP
110
                      client->get_oneauth().c_str(),    // argument 0
111
                      vid,                              // argument 1
112
                      hid                               // argument 2
113
                    );
109
        switch (state)
110
        {
111
            case VirtualMachine::PENDING:
112
                client->call( client->get_endpoint(),           // serverUrl
113
                              "one.vm.deploy",                  // methodName
114
                              "sii",                            // arguments format
115
                              &deploy_result,                   // resultP
116
                              client->get_oneauth().c_str(),    // argument 0
117
                              vid,                              // argument 1
118
                              hid);                             // argument 2
119
            break;
120

  
121
            case VirtualMachine::RESCHED: 
122
                client->call( client->get_endpoint(),           // serverUrl
123
                              "one.vm.migrate",                 // methodName
124
                              "siib",                           // arguments format
125
                              &deploy_result,                   // resultP
126
                              client->get_oneauth().c_str(),    // argument 0
127
                              vid,                              // argument 1
128
                              hid,                              // argument 2
129
                              true);                            // argument 3
130
            break;
131

  
132
            default:
133
                oss.str("");
134
                oss << "Error dispatching virtual machine: invalid state";
135
                NebulaLog::log("VM",Log::ERROR,oss);
136
                return -1;
137
        }
138

  
114 139
    }
115 140
    catch (exception const& e)
116 141
    {
opennebula-3.4.0/src/scheduler/src/pool/VirtualMachineXML.cc 2012-04-18 14:05:00.502202090 +0000
26 26
    uid = atoi(((*this)["/VM/UID"])[0].c_str());
27 27
    gid = atoi(((*this)["/VM/GID"])[0].c_str());
28 28

  
29
    result = ((*this)["/VM/HISTORY_RECORDS/HISTORY/HID"]);
30
    if (result.size() > 0)
31
    {
32
        hid = atoi(result[0].c_str());
33
    }
34
    else
35
    {
36
        hid = -1;
37
    }
38

  
29 39
    result = ((*this)["/VM/TEMPLATE/MEMORY"]);
30 40
    if (result.size() > 0)
31 41
    {
opennebula-3.4.0/src/scheduler/src/sched/Scheduler.cc 2012-04-18 14:11:29.982143676 +0000
34 34
#include "RankPolicy.h"
35 35
#include "NebulaLog.h"
36 36
#include "PoolObjectAuth.h"
37
#include "VirtualMachine.h"
37 38

  
38 39
using namespace std;
39 40

  
......
250 251
/* -------------------------------------------------------------------------- */
251 252
/* -------------------------------------------------------------------------- */
252 253

  
253
int Scheduler::set_up_pools()
254
int Scheduler::set_up_pools(int vmstate)
254 255
{
255 256
    int                             rc;
256 257
    ostringstream                   oss;
......
272 273
    //Cleans the cache and get the pending VMs
273 274
    //--------------------------------------------------------------------------
274 275

  
275
    rc = vmpool->set_up();
276
    rc = vmpool->set_up(vmstate);
276 277

  
277 278
    if ( rc != 0 )
278 279
    {
......
329 330
    const map<int, ObjectXML*> pending_vms = vmpool->get_objects();
330 331
    const map<int, ObjectXML*> hosts = hpool->get_objects();
331 332

  
332

  
333 333
    for (vm_it=pending_vms.begin(); vm_it != pending_vms.end(); vm_it++)
334 334
    {
335 335
        vm = static_cast<VirtualMachineXML*>(vm_it->second);
......
415 415
                NebulaLog::log("SCHED",Log::DEBUG,oss);
416 416
                continue;
417 417
            }
418

  
419
            // -----------------------------------------------------------------
420
            // Check host placement (rescheduling)
421
            // -----------------------------------------------------------------
422

  
423
            if (vm->get_hid() == host->get_hid())
424
            {
425
                ostringstream oss;
426

  
427
                oss << "Host " << host->get_hid() << 
428
                    " filtered out. VM running on host.";
429

  
430
                NebulaLog::log("SCHED",Log::DEBUG,oss);
431
                continue;
432
             }
433

  
418 434
            // -----------------------------------------------------------------
419 435
            // Check host capacity
420 436
            // -----------------------------------------------------------------
......
560 576

  
561 577
    if (name == ACTION_TIMER)
562 578
    {
563
        rc = set_up_pools();
579
        rc = set_up_pools(VirtualMachine::PENDING);
580

  
581
        if ( rc != 0 )
582
        {
583
            return;
584
        }
585

  
586
        rc = schedule();
587

  
588
        if ( rc != 0 )
589
        {
590
            return;
591
        }
592

  
593
        dispatch();
594

  
595
        rc = set_up_pools(VirtualMachine::RESCHED);
564 596

  
565 597
        if ( rc != 0 )
566 598
        {