Revision 728d0435

View differences:

include/DispatchManager.h
46 46
    {
47 47
        SUSPEND_SUCCESS,/**< Send by LCM when a VM is suspended*/
48 48
        STOP_SUCCESS,   /**< Send by LCM when a VM is stopped*/
49
        SHUTDOWN_SAVE_SUCCESS,  /**< Send by LCM when a VM is shut down and saved*/
49
        UNDEPLOY_SUCCESS,  /**< Send by LCM when a VM is undeployed and saved*/
50 50
        POWEROFF_SUCCESS, /**< Send by LCM when a VM is powered off */
51 51
        DONE,           /**< Send by LCM when a VM is shut down*/
52 52
        FAILED,         /**< Send by LCM when one of the execution steps fails*/
......
138 138
     *    @return 0 on success, -1 if the VM does not exits or -2 if the VM is
139 139
     *    in a wrong a state
140 140
     */
141
    int shutdown_save(
141
    int undeploy (
142 142
        int vid,
143 143
        bool hard);
144 144

  
......
408 408

  
409 409
    void  stop_success_action(int vid);
410 410

  
411
    void  shutdown_save_success_action(int vid);
411
    void  undeploy_success_action(int vid);
412 412

  
413 413
    void  poweroff_success_action(int vid);
414 414

  
include/LifeCycleManager.h
84 84
        MIGRATE,          /**< Sent by the DM to migrate a VM to other host   */
85 85
        LIVE_MIGRATE,     /**< Sent by the DM to live-migrate a VM            */
86 86
        SHUTDOWN,         /**< Sent by the DM to shutdown a running VM        */
87
        SHUTDOWN_SAVE,      /**< Sent by the DM to shutdown a running VM      */
88
        SHUTDOWN_SAVE_HARD, /**< Sent by the DM to shutdown a running VM      */
87
        UNDEPLOY,         /**< Sent by the DM to undeploy a running VM        */
88
        UNDEPLOY_HARD,    /**< Sent by the DM to force undeploy a running VM  */
89 89
        POWEROFF,         /**< Sent by the DM to power off a running VM       */
90 90
        RESTART,          /**< Sent by the DM to restart a deployed VM        */
91 91
        DELETE,           /**< Sent by the DM to delete a VM                  */
......
249 249

  
250 250
    void shutdown_action(int vid);
251 251

  
252
    void shutdown_save_action(int vid, bool hard);
252
    void undeploy_action(int vid, bool hard);
253 253

  
254 254
    void poweroff_action(int vid);
255 255

  
include/VirtualMachine.h
59 59
        DONE      = 6,
60 60
        FAILED    = 7,
61 61
        POWEROFF  = 8,
62
        SHUTDOWN_SAVED = 9
62
        UNDEPLOYED = 9
63 63
    };
64 64

  
65 65
    /**
......
96 96
        HOTPLUG_SAVEAS           = 26,
97 97
        HOTPLUG_SAVEAS_POWEROFF  = 27,
98 98
        HOTPLUG_SAVEAS_SUSPENDED = 28,
99
        SHUTDOWN_SAVE           = 29,
100
        EPILOG_SHUTDOWN_SAVE    = 30,
101
        PROLOG_SHUTDOWN_SAVE    = 31
99
        UNDEPLOYING         = 29,
100
        EPILOG_UNDEPLOY     = 30,
101
        PROLOG_UNDEPLOY     = 31
102 102
    };
103 103

  
104 104
    // -------------------------------------------------------------------------
src/cli/onevm
319 319
        end
320 320
    end
321 321

  
322
    shutdown_save_desc = <<-EOT.unindent
322
    undeploy_desc = <<-EOT.unindent
323 323
        Shuts down the given VM. The VM is saved in the system Datastore.
324 324

  
325 325
        With --hard it unplugs the VM.
......
327 327
        States: RUNNING
328 328
    EOT
329 329

  
330
    command :"shutdown-save", shutdown_save_desc, [:range,:vmid_list],
330
    command :undeploy, undeploy_desc, [:range,:vmid_list],
331 331
        :options => [OneVMHelper::SCHEDULE, OneVMHelper::HARD] do
332 332

  
333
        command_name='shutdown-save'
333
        command_name='undeploy'
334 334
        command_name<<'-hard' if options[:hard]
335 335

  
336 336
        if (!options[:schedule].nil?)
337 337
            helper.schedule_actions(args[0], options, command_name)
338 338
        else
339 339
            helper.perform_actions(args[0],options,"shutting down") do |vm|
340
                vm.shutdown_save(options[:hard]==true)
340
                vm.undeploy(options[:hard]==true)
341 341
            end
342 342
        end
343 343
    end
src/dm/DispatchManager.cc
77 77
        aname = "STOP_SUCCESS";
78 78
        break;
79 79

  
80
    case SHUTDOWN_SAVE_SUCCESS:
81
        aname = "SHUTDOWN_SAVE_SUCCESS";
80
    case UNDEPLOY_SUCCESS:
81
        aname = "UNDEPLOY_SUCCESS";
82 82
        break;
83 83

  
84 84
    case POWEROFF_SUCCESS:
......
134 134
    {
135 135
        stop_success_action(vid);
136 136
    }
137
    else if (action == "SHUTDOWN_SAVE_SUCCESS")
137
    else if (action == "UNDEPLOY_SUCCESS")
138 138
    {
139
        shutdown_save_success_action(vid);
139
        undeploy_success_action(vid);
140 140
    }
141 141
    else if (action == "POWEROFF_SUCCESS")
142 142
    {
src/dm/DispatchManagerActions.cc
209 209
/* -------------------------------------------------------------------------- */
210 210
/* -------------------------------------------------------------------------- */
211 211

  
212
int DispatchManager::shutdown_save(
212
int DispatchManager::undeploy(
213 213
    int vid,
214 214
    bool hard)
215 215
{
......
234 234

  
235 235
        if (hard)
236 236
        {
237
            lcm->trigger(LifeCycleManager::SHUTDOWN_SAVE_HARD,vid);
237
            lcm->trigger(LifeCycleManager::UNDEPLOY_HARD,vid);
238 238
        }
239 239
        else
240 240
        {
241
            lcm->trigger(LifeCycleManager::SHUTDOWN_SAVE,vid);
241
            lcm->trigger(LifeCycleManager::UNDEPLOY,vid);
242 242
        }
243 243
    }
244 244
    else
......
551 551
    NebulaLog::log("DiM",Log::DEBUG,oss);
552 552

  
553 553
    if (vm->get_state() == VirtualMachine::STOPPED ||
554
        vm->get_state() == VirtualMachine::SHUTDOWN_SAVED )
554
        vm->get_state() == VirtualMachine::UNDEPLOYED )
555 555
    {
556 556
        vm->set_state(VirtualMachine::PENDING);
557 557

  
......
858 858
        break;
859 859

  
860 860
        case VirtualMachine::STOPPED:
861
        case VirtualMachine::SHUTDOWN_SAVED:
861
        case VirtualMachine::UNDEPLOYED:
862 862
            tm->trigger(TransferManager::EPILOG_DELETE_STOP,vid);
863 863
            finalize_cleanup(vm);
864 864
        break;
......
933 933

  
934 934
        case VirtualMachine::HOLD: // Move the VM to PENDING in any of these
935 935
        case VirtualMachine::STOPPED:
936
        case VirtualMachine::SHUTDOWN_SAVED:
936
        case VirtualMachine::UNDEPLOYED:
937 937
            vm->set_state(VirtualMachine::LCM_INIT);
938 938
            vm->set_state(VirtualMachine::PENDING);
939 939

  
src/dm/DispatchManagerStates.cc
98 98
/* -------------------------------------------------------------------------- */
99 99
/* -------------------------------------------------------------------------- */
100 100

  
101
void  DispatchManager::shutdown_save_success_action(int vid)
101
void  DispatchManager::undeploy_success_action(int vid)
102 102
{
103 103
    VirtualMachine *    vm;
104 104

  
......
110 110
    }
111 111

  
112 112
    if ((vm->get_state() == VirtualMachine::ACTIVE) &&
113
        (vm->get_lcm_state() == VirtualMachine::EPILOG_SHUTDOWN_SAVE ||
114
         vm->get_lcm_state() == VirtualMachine::PROLOG_SHUTDOWN_SAVE))
113
        (vm->get_lcm_state() == VirtualMachine::EPILOG_UNDEPLOY ||
114
         vm->get_lcm_state() == VirtualMachine::PROLOG_UNDEPLOY))
115 115
    {
116
        vm->set_state(VirtualMachine::SHUTDOWN_SAVED);
116
        vm->set_state(VirtualMachine::UNDEPLOYED);
117 117

  
118 118
        vm->set_state(VirtualMachine::LCM_INIT);
119 119

  
120 120
        vmpool->update(vm);
121 121

  
122
        vm->log("DiM", Log::INFO, "New VM state is SHUTDOWN_SAVED");
122
        vm->log("DiM", Log::INFO, "New VM state is UNDEPLOYED");
123 123
    }
124 124
    else
125 125
    {
126 126
        ostringstream oss;
127 127

  
128
        oss << "shutdown_save_success action received but VM " << vid
128
        oss << "undeploy_success action received but VM " << vid
129 129
            << " not in ACTIVE state";
130 130
        NebulaLog::log("DiM",Log::ERROR,oss);
131 131
    }
src/lcm/LifeCycleActions.cc
55 55
            }
56 56
            else if (vm->get_previous_reason() == History::NONE)
57 57
            {
58
                vm_state  = VirtualMachine::PROLOG_SHUTDOWN_SAVE;
58
                vm_state  = VirtualMachine::PROLOG_UNDEPLOY;
59 59
                tm_action = TransferManager::PROLOG_RESUME;
60 60
            }
61 61
        }
......
342 342
/* -------------------------------------------------------------------------- */
343 343
/* -------------------------------------------------------------------------- */
344 344

  
345
void  LifeCycleManager::shutdown_save_action(int vid, bool hard)
345
void  LifeCycleManager::undeploy_action(int vid, bool hard)
346 346
{
347 347
    VirtualMachine *    vm;
348 348

  
......
360 360
        VirtualMachineManager * vmm = nd.get_vmm();
361 361

  
362 362
        //----------------------------------------------------
363
        //             SHUTDOWN_SAVE STATE
363
        //             UNDEPLOYING STATE
364 364
        //----------------------------------------------------
365 365

  
366
        vm->set_state(VirtualMachine::SHUTDOWN_SAVE);
366
        vm->set_state(VirtualMachine::UNDEPLOYING);
367 367

  
368 368
        vm->set_resched(false);
369 369

  
370 370
        vmpool->update(vm);
371 371

  
372
        vm->log("LCM",Log::INFO,"New VM state is SHUTDOWN_SAVE");
372
        vm->log("LCM",Log::INFO,"New VM state is UNDEPLOYING");
373 373

  
374 374
        //----------------------------------------------------
375 375

  
......
384 384
    }
385 385
    else
386 386
    {
387
        vm->log("LCM", Log::ERROR, "shutdown_save_action, VM in a wrong state.");
387
        vm->log("LCM", Log::ERROR, "undeploy_action, VM in a wrong state.");
388 388
    }
389 389

  
390 390
    vm->unlock();
......
809 809
    {
810 810
        case VirtualMachine::PROLOG:
811 811
        case VirtualMachine::PROLOG_RESUME:
812
        case VirtualMachine::PROLOG_SHUTDOWN_SAVE:
812
        case VirtualMachine::PROLOG_UNDEPLOY:
813 813
            vm->set_prolog_etime(the_time);
814 814
            vmpool->update_history(vm);
815 815

  
src/lcm/LifeCycleManager.cc
232 232
        aname = "SHUTDOWN";
233 233
        break;
234 234

  
235
    case SHUTDOWN_SAVE:
236
        aname = "SHUTDOWN_SAVE";
235
    case UNDEPLOY:
236
        aname = "UNDEPLOY";
237 237
        break;
238 238

  
239
    case SHUTDOWN_SAVE_HARD:
240
        aname = "SHUTDOWN_SAVE_HARD";
239
    case UNDEPLOY_HARD:
240
        aname = "UNDEPLOY_HARD";
241 241
        break;
242 242

  
243 243
    case RESTART:
......
449 449
    {
450 450
        shutdown_action(vid);
451 451
    }
452
    else if (action == "SHUTDOWN_SAVE")
452
    else if (action == "UNDEPLOY")
453 453
    {
454
        shutdown_save_action(vid, false);
454
        undeploy_action(vid, false);
455 455
    }
456
    else if (action == "SHUTDOWN_SAVE_HARD")
456
    else if (action == "UNDEPLOY_HARD")
457 457
    {
458
        shutdown_save_action(vid, true);
458
        undeploy_action(vid, true);
459 459
    }
460 460
    else if (action == "RESTART")
461 461
    {
src/lcm/LifeCycleStates.cc
514 514

  
515 515
        dm->trigger(DispatchManager::POWEROFF_SUCCESS,vid);
516 516
    }
517
    else if (vm->get_lcm_state() == VirtualMachine::SHUTDOWN_SAVE)
517
    else if (vm->get_lcm_state() == VirtualMachine::UNDEPLOYING)
518 518
    {
519 519
        //----------------------------------------------------
520
        //            EPILOG_SHUTDOWN_SAVE STATE
520
        //            EPILOG_UNDEPLOY STATE
521 521
        //----------------------------------------------------
522 522

  
523
        vm->set_state(VirtualMachine::EPILOG_SHUTDOWN_SAVE);
523
        vm->set_state(VirtualMachine::EPILOG_UNDEPLOY);
524 524

  
525 525
        vm->delete_snapshots();
526 526

  
......
534 534

  
535 535
        vmpool->update_history(vm);
536 536

  
537
        vm->log("LCM", Log::INFO, "New VM state is EPILOG_SHUTDOWN_SAVE");
537
        vm->log("LCM", Log::INFO, "New VM state is EPILOG_UNDEPLOY");
538 538

  
539 539
        //----------------------------------------------------
540 540

  
......
567 567

  
568 568
    if ( vm->get_lcm_state() == VirtualMachine::SHUTDOWN ||
569 569
         vm->get_lcm_state() == VirtualMachine::SHUTDOWN_POWEROFF ||
570
         vm->get_lcm_state() == VirtualMachine::SHUTDOWN_SAVE )
570
         vm->get_lcm_state() == VirtualMachine::UNDEPLOYING )
571 571
    {
572 572
        //----------------------------------------------------
573 573
        //    RUNNING STATE FROM SHUTDOWN
......
616 616
    lcm_state = vm->get_lcm_state();
617 617

  
618 618
    if (lcm_state == VirtualMachine::PROLOG ||
619
        lcm_state == VirtualMachine::PROLOG_SHUTDOWN_SAVE )
619
        lcm_state == VirtualMachine::PROLOG_UNDEPLOY )
620 620
    {
621 621
        action = VirtualMachineManager::DEPLOY;
622 622
    }
......
724 724

  
725 725
        dm->trigger(DispatchManager::STOP_SUCCESS,vid);
726 726
    }
727
    else if ( state == VirtualMachine::PROLOG_SHUTDOWN_SAVE )
727
    else if ( state == VirtualMachine::PROLOG_UNDEPLOY )
728 728
    {
729 729
        //----------------------------------------------------
730
        //    SHUTDOWN_SAVE STATE FROM PROLOG_RESUME
730
        //    UNDEPLOY STATE FROM PROLOG_UNDEPLOY
731 731
        //----------------------------------------------------
732 732

  
733 733
        Nebula&             nd = Nebula::instance();
......
755 755

  
756 756
        //----------------------------------------------------
757 757

  
758
        dm->trigger(DispatchManager::SHUTDOWN_SAVE_SUCCESS,vid);
758
        dm->trigger(DispatchManager::UNDEPLOY_SUCCESS,vid);
759 759
    }
760 760
    else
761 761
    {
......
795 795
    {
796 796
        action = DispatchManager::STOP_SUCCESS;
797 797
    }
798
    else if ( state == VirtualMachine::EPILOG_SHUTDOWN_SAVE )
798
    else if ( state == VirtualMachine::EPILOG_UNDEPLOY )
799 799
    {
800
        action = DispatchManager::SHUTDOWN_SAVE_SUCCESS;
800
        action = DispatchManager::UNDEPLOY_SUCCESS;
801 801
    }
802 802
    else if ( state == VirtualMachine::EPILOG )
803 803
    {
......
899 899
        dm->trigger(DispatchManager::RESUBMIT, vid);
900 900
    }
901 901
    else if ( vm->get_lcm_state() == VirtualMachine::EPILOG_STOP ||
902
              vm->get_lcm_state() == VirtualMachine::EPILOG_SHUTDOWN_SAVE ||
902
              vm->get_lcm_state() == VirtualMachine::EPILOG_UNDEPLOY ||
903 903
              vm->get_lcm_state() == VirtualMachine::EPILOG )
904 904
    {
905 905
        vm->set_epilog_etime(the_time);
......
959 959

  
960 960
        tm->trigger(TransferManager::EPILOG,vid);
961 961
    }
962
    else if (vm->get_lcm_state() == VirtualMachine::SHUTDOWN_SAVE)
962
    else if (vm->get_lcm_state() == VirtualMachine::UNDEPLOYING)
963 963
    {
964 964
        //----------------------------------------------------
965
        //            EPILOG_SHUTDOWN_SAVE STATE
965
        //            EPILOG_UNDEPLOY STATE
966 966
        //----------------------------------------------------
967 967

  
968
        vm->set_state(VirtualMachine::EPILOG_SHUTDOWN_SAVE);
968
        vm->set_state(VirtualMachine::EPILOG_UNDEPLOY);
969 969

  
970 970
        vm->delete_snapshots();
971 971

  
......
979 979

  
980 980
        vmpool->update_history(vm);
981 981

  
982
        vm->log("LCM", Log::INFO, "New VM state is EPILOG_SHUTDOWN_SAVE");
982
        vm->log("LCM", Log::INFO, "New VM state is EPILOG_UNDEPLOY");
983 983

  
984 984
        //----------------------------------------------------
985 985

  
......
1011 1011
    }
1012 1012

  
1013 1013
    if ( vm->get_lcm_state() == VirtualMachine::CANCEL ||
1014
         vm->get_lcm_state() == VirtualMachine::SHUTDOWN_SAVE )
1014
         vm->get_lcm_state() == VirtualMachine::UNDEPLOYING )
1015 1015
    {
1016 1016
        //----------------------------------------------------
1017 1017
        //    RUNNING STATE FROM CANCEL
src/oca/ruby/opennebula/virtual_machine.rb
47 47
        }
48 48

  
49 49
        VM_STATE=%w{INIT PENDING HOLD ACTIVE STOPPED SUSPENDED DONE FAILED
50
            POWEROFF SHUTDOWN_SAVED}
50
            POWEROFF UNDEPLOYED}
51 51

  
52 52
        LCM_STATE=%w{LCM_INIT PROLOG BOOT RUNNING MIGRATE SAVE_STOP SAVE_SUSPEND
53 53
            SAVE_MIGRATE PROLOG_MIGRATE PROLOG_RESUME EPILOG_STOP EPILOG
54 54
            SHUTDOWN CANCEL FAILURE CLEANUP_RESUBMIT UNKNOWN HOTPLUG SHUTDOWN_POWEROFF
55 55
            BOOT_UNKNOWN BOOT_POWEROFF BOOT_SUSPENDED BOOT_STOPPED CLEANUP_DELETE
56 56
            HOTPLUG_SNAPSHOT HOTPLUG_NIC HOTPLUG_SAVEAS HOTPLUG_SAVEAS_POWEROFF
57
            HOTPLUG_SAVEAS_SUSPENDED SHUTDOWN_SAVE EPILOG_SHUTDOWN_SAVE
58
            PROLOG_SHUTDOWN_SAVE}
57
            HOTPLUG_SAVEAS_SUSPENDED UNDEPLOYING EPILOG_UNDEPLOY PROLOG_UNDEPLOY}
59 58

  
60 59
        SHORT_VM_STATES={
61 60
            "INIT"      => "init",
......
67 66
            "DONE"      => "done",
68 67
            "FAILED"    => "fail",
69 68
            "POWEROFF"  => "poff",
70
            "SHUTDOWN_SAVED"  => "shut"
69
            "UNDEPLOYING"  => "unde"
71 70
        }
72 71

  
73 72
        SHORT_LCM_STATES={
......
99 98
            "HOTPLUG_SAVEAS"           => "hotp",
100 99
            "HOTPLUG_SAVEAS_POWEROFF"  => "hotp",
101 100
            "HOTPLUG_SAVEAS_SUSPENDED" => "hotp",
102
            "SHUTDOWN_SAVE"            => "shut",
103
            "EPILOG_SHUTDOWN_SAVE"     => "epil",
104
            "PROLOG_SHUTDOWN_SAVE"     => "prol"
101
            "UNDEPLOYING"       => "unde",
102
            "EPILOG_UNDEPLOY"   => "epil",
103
            "PROLOG_UNDEPLOY"   => "prol"
105 104
        }
106 105

  
107 106
        MIGRATE_REASON=%w{NONE ERROR STOP_RESUME USER CANCEL}
......
215 214
            action(hard ? 'shutdown-hard' : 'shutdown')
216 215
        end
217 216

  
218
        # Shutdowns an already deployed VM
219
        def shutdown_save(hard=false)
220
            action(hard ? 'shutdown-save-hard' : 'shutdown-save')
217
        # Shuts down an already deployed VM, saving its state in the system DS
218
        def undeploy(hard=false)
219
            action(hard ? 'undeploy-hard' : 'undeploy')
221 220
        end
222 221

  
223

  
224 222
        # Powers off a running VM
225 223
        def poweroff
226 224
            action('poweroff')
src/rm/RequestManagerVirtualMachine.cc
381 381
    {
382 382
        rc = dm->poweroff(id);
383 383
    }
384
    else if (action == "shutdown-save")
384
    else if (action == "undeploy")
385 385
    {
386
        rc = dm->shutdown_save(id, false);
386
        rc = dm->undeploy(id, false);
387 387
    }
388
    else if (action == "shutdown-save-hard")
388
    else if (action == "undeploy-hard")
389 389
    {
390
        rc = dm->shutdown_save(id, true);
390
        rc = dm->undeploy(id, true);
391 391
    }
392 392

  
393 393
    switch (rc)
......
1254 1254
        case VirtualMachine::PENDING:
1255 1255
        case VirtualMachine::HOLD:
1256 1256
        case VirtualMachine::FAILED:
1257
        case VirtualMachine::SHUTDOWN_SAVED:
1257
        case VirtualMachine::UNDEPLOYED:
1258 1258
        break;
1259 1259

  
1260 1260
        case VirtualMachine::STOPPED:
......
1432 1432
        case VirtualMachine::HOLD:
1433 1433
        case VirtualMachine::FAILED:
1434 1434
        case VirtualMachine::POWEROFF:
1435
        case VirtualMachine::SHUTDOWN_SAVED:
1435
        case VirtualMachine::UNDEPLOYED:
1436 1436
            ret = vm->resize(ncpu, nmemory, nvcpu, error_str);
1437 1437

  
1438 1438
            if (ret != 0)
src/scheduler/src/pool/VirtualMachineXML.cc
296 296

  
297 297
    if (   action_st != "shutdown"
298 298
        && action_st != "shutdown-hard"
299
        && action_st != "shutdown-save"
300
        && action_st != "shutdown-save-hard"
299
        && action_st != "undeploy"
300
        && action_st != "undeploy-hard"
301 301
        && action_st != "hold"
302 302
        && action_st != "release"
303 303
        && action_st != "stop"
src/tm/TransferManagerDriver.cc
122 122
                case VirtualMachine::PROLOG:
123 123
                case VirtualMachine::PROLOG_MIGRATE:
124 124
                case VirtualMachine::PROLOG_RESUME:
125
                case VirtualMachine::PROLOG_SHUTDOWN_SAVE:
125
                case VirtualMachine::PROLOG_UNDEPLOY:
126 126
                    lcm_action = LifeCycleManager::PROLOG_SUCCESS;
127 127
                    break;
128 128

  
129 129
                case VirtualMachine::EPILOG:
130 130
                case VirtualMachine::EPILOG_STOP:
131
                case VirtualMachine::EPILOG_SHUTDOWN_SAVE:
131
                case VirtualMachine::EPILOG_UNDEPLOY:
132 132
                case VirtualMachine::CLEANUP_RESUBMIT:
133 133
                    lcm_action = LifeCycleManager::EPILOG_SUCCESS;
134 134
                    break;
......
167 167
                case VirtualMachine::PROLOG:
168 168
                case VirtualMachine::PROLOG_MIGRATE:
169 169
                case VirtualMachine::PROLOG_RESUME:
170
                case VirtualMachine::PROLOG_SHUTDOWN_SAVE:
170
                case VirtualMachine::PROLOG_UNDEPLOY:
171 171
                    lcm_action = LifeCycleManager::PROLOG_FAILURE;
172 172
                    break;
173 173

  
174 174
                case VirtualMachine::EPILOG:
175 175
                case VirtualMachine::EPILOG_STOP:
176
                case VirtualMachine::EPILOG_SHUTDOWN_SAVE:
176
                case VirtualMachine::EPILOG_UNDEPLOY:
177 177
                case VirtualMachine::CLEANUP_RESUBMIT:
178 178
                    lcm_action = LifeCycleManager::EPILOG_FAILURE;
179 179
                    break;
src/vmm/VirtualMachineManager.cc
903 903

  
904 904
error_common:
905 905
    if ( vm->get_lcm_state() == VirtualMachine::CANCEL ||
906
         vm->get_lcm_state() == VirtualMachine::SHUTDOWN_SAVE ) //not in DELETE
906
         vm->get_lcm_state() == VirtualMachine::UNDEPLOYING ) //not in DELETE
907 907
    {
908 908
        Nebula              &ne = Nebula::instance();
909 909
        LifeCycleManager *  lcm = ne.get_lcm();

Also available in: Unified diff