mirror of
https://github.com/OpenNebula/one.git
synced 2025-01-07 17:17:41 +03:00
784a4fc960
track the ports in use in the cluster and avoid port collision. VNC ports are assigned when the VM is deployed and released when the VM is stopped, undeployed or done. Includes the following: - 9da66150dc0e3dc2731518d8a215f9598696a999 - 4c35a9fcccf70cbe87d2947403ea815967e7b605 - ccfccb6d2fc40aa1c07eb994f37b8da4fb479082 - b1b64e61a39f4452c7ba00e581de42888e0e84a5 - d474ee4db9ed520bcae743d510be35b25ea988ed - dacb61b1402da2ec309b6e79bdd285d0d11de84f
342 lines
12 KiB
C++
342 lines
12 KiB
C++
/* -------------------------------------------------------------------------- */
|
|
/* Copyright 2002-2015, OpenNebula Project, OpenNebula Systems */
|
|
/* */
|
|
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
|
|
/* not use this file except in compliance with the License. You may obtain */
|
|
/* a copy of the License at */
|
|
/* */
|
|
/* http://www.apache.org/licenses/LICENSE-2.0 */
|
|
/* */
|
|
/* Unless required by applicable law or agreed to in writing, software */
|
|
/* distributed under the License is distributed on an "AS IS" BASIS, */
|
|
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
|
|
/* See the License for the specific language governing permissions and */
|
|
/* limitations under the License. */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
#ifndef LIFE_CYCLE_MANAGER_H_
|
|
#define LIFE_CYCLE_MANAGER_H_
|
|
|
|
#include "ActionManager.h"
|
|
#include "VirtualMachinePool.h"
|
|
#include "HostPool.h"
|
|
#include "ImagePool.h"
|
|
#include "SecurityGroupPool.h"
|
|
#include "ClusterPool.h"
|
|
|
|
using namespace std;
|
|
|
|
extern "C" void * lcm_action_loop(void *arg);
|
|
|
|
//Forward definitions
|
|
class TransferManager;
|
|
class DispatchManager;
|
|
class VirtualMachineManager;
|
|
class ImageManager;
|
|
|
|
/**
|
|
* The Virtual Machine Life-cycle Manager module. This class is responsible for
|
|
* managing the life-cycle of a Virtual Machine.
|
|
*/
|
|
class LifeCycleManager : public ActionListener
|
|
{
|
|
public:
|
|
|
|
LifeCycleManager():
|
|
vmpool(0), hpool(0), ipool(0), sgpool(0), clpool(0), tm(0), vmm(0),
|
|
dm(0), imagem(0)
|
|
{
|
|
am.addListener(this);
|
|
};
|
|
|
|
~LifeCycleManager(){};
|
|
|
|
enum Actions
|
|
{
|
|
SAVE_SUCCESS, /**< Sent by the VMM when a save action succeeds */
|
|
SAVE_FAILURE, /**< Sent by the VMM when a save action fails */
|
|
DEPLOY_SUCCESS, /**< Sent by the VMM when a deploy/restore/migrate action succeeds */
|
|
DEPLOY_FAILURE, /**< Sent by the VMM when a deploy/restore/migrate action fails */
|
|
SHUTDOWN_SUCCESS, /**< Sent by the VMM when a shutdown action succeeds*/
|
|
SHUTDOWN_FAILURE, /**< Sent by the VMM when a shutdown action fails */
|
|
CANCEL_SUCCESS, /**< Sent by the VMM when a cancel action succeeds */
|
|
CANCEL_FAILURE, /**< Sent by the VMM when a cancel action fails */
|
|
MONITOR_SUSPEND, /**< Sent by the VMM when a VM is paused while active */
|
|
MONITOR_DONE, /**< Sent by the VMM when a Host cannot be monitored*/
|
|
MONITOR_POWEROFF, /**< Sent by the VMM when a VM is not found */
|
|
MONITOR_POWERON, /**< Sent by the VMM when a VM is found again */
|
|
PROLOG_SUCCESS, /**< Sent by the TM when the prolog phase succeeds */
|
|
PROLOG_FAILURE, /**< Sent by the TM when the prolog phase fails */
|
|
EPILOG_SUCCESS, /**< Sent by the TM when the epilog phase succeeds */
|
|
EPILOG_FAILURE, /**< Sent by the TM when the epilog phase fails */
|
|
ATTACH_SUCCESS, /**< Sent by the VMM when an attach action succeeds */
|
|
ATTACH_FAILURE, /**< Sent by the VMM when an attach action fails */
|
|
DETACH_SUCCESS, /**< Sent by the VMM when a detach action succeeds */
|
|
DETACH_FAILURE, /**< Sent by the VMM when a detach action fails */
|
|
ATTACH_NIC_SUCCESS,/**< Sent by the VMM when an attach nic action succeeds */
|
|
ATTACH_NIC_FAILURE,/**< Sent by the VMM when an attach nic action fails */
|
|
DETACH_NIC_SUCCESS,/**< Sent by the VMM when a detach nic action succeeds */
|
|
DETACH_NIC_FAILURE,/**< Sent by the VMM when a detach nic action fails */
|
|
CLEANUP_SUCCESS, /**< Sent by the VMM when a cleanup action succeeds */
|
|
CLEANUP_FAILURE, /**< Sent by the VMM when a cleanup action fails */
|
|
SAVEAS_SUCCESS, /**< Sent by the VMM when saveas succeeds */
|
|
SAVEAS_FAILURE, /**< Sent by the VMM when saveas fails */
|
|
SNAPSHOT_CREATE_SUCCESS, /**< Sent by the VMM on snap. create success */
|
|
SNAPSHOT_CREATE_FAILURE, /**< Sent by the VMM on snap. create failure */
|
|
SNAPSHOT_REVERT_SUCCESS, /**< Sent by the VMM on snap. revert success */
|
|
SNAPSHOT_REVERT_FAILURE, /**< Sent by the VMM on snap. revert failure */
|
|
SNAPSHOT_DELETE_SUCCESS, /**< Sent by the VMM on snap. revert success */
|
|
SNAPSHOT_DELETE_FAILURE, /**< Sent by the VMM on snap. revert failure */
|
|
DISK_SNAPSHOT_SUCCESS, /**<Sent by TM when a snap. succeeds */
|
|
DISK_SNAPSHOT_FAILURE, /**<Sent by TM when a snap. fails */
|
|
DEPLOY, /**< Sent by the DM to deploy a VM on a host */
|
|
SUSPEND, /**< Sent by the DM to suspend an running VM */
|
|
RESTORE, /**< Sent by the DM to restore a suspended VM */
|
|
STOP, /**< Sent by the DM to stop an running VM */
|
|
CANCEL, /**< Sent by the DM to cancel an running VM */
|
|
MIGRATE, /**< Sent by the DM to migrate a VM to other host */
|
|
LIVE_MIGRATE, /**< Sent by the DM to live-migrate a VM */
|
|
SHUTDOWN, /**< Sent by the DM to shutdown a running VM */
|
|
UNDEPLOY, /**< Sent by the DM to undeploy a running VM */
|
|
UNDEPLOY_HARD, /**< Sent by the DM to force undeploy a running VM */
|
|
POWEROFF, /**< Sent by the DM to power off a running VM */
|
|
POWEROFF_HARD, /**< Sent by the DM to power off hard a running VM */
|
|
RESTART, /**< Sent by the DM to restart a deployed VM */
|
|
DELETE, /**< Sent by the DM to delete a VM */
|
|
CLEAN, /**< Sent by the DM to cleanup a VM for resubmission*/
|
|
FINALIZE,
|
|
UPDATESG /**< Sent by RM/VMM to trigger the secgroup update */
|
|
};
|
|
|
|
/**
|
|
* Triggers specific actions to the Life-cycle Manager. This function
|
|
* wraps the ActionManager trigger function.
|
|
* @param action the LCM action
|
|
* @param vid VM unique id. This is the argument of the passed to the
|
|
* invoked action.
|
|
*/
|
|
void trigger(
|
|
Actions action,
|
|
int vid);
|
|
|
|
/**
|
|
* This functions starts a new thread for the Life-cycle Manager. This
|
|
* thread will wait in an action loop till it receives ACTION_FINALIZE.
|
|
* @return 0 on success.
|
|
*/
|
|
int start();
|
|
|
|
/**
|
|
* Initializes internal pointers to other managers. Must be called when
|
|
* all the other managers exist in Nebula::instance
|
|
*/
|
|
void init_managers();
|
|
|
|
/**
|
|
* Gets the thread identification.
|
|
* @return pthread_t for the manager thread (that in the action loop).
|
|
*/
|
|
pthread_t get_thread_id() const
|
|
{
|
|
return lcm_thread;
|
|
};
|
|
|
|
/**
|
|
* Recovers a VM by self-triggering the associated lost transition.
|
|
* @param vm to be recovered
|
|
* @param success trigger successful transition if true, fail otherwise
|
|
*/
|
|
void recover(VirtualMachine * vm, bool success);
|
|
|
|
/**
|
|
* Retries the last VM operation that lead to a failure. The underlying
|
|
* driver actions may be invoked and should be "re-entrant".
|
|
*/
|
|
void retry(VirtualMachine * vm);
|
|
|
|
private:
|
|
/**
|
|
* Thread id for the Virtual Machine Manager
|
|
*/
|
|
pthread_t lcm_thread;
|
|
|
|
/**
|
|
* Pointer to the Virtual Machine Pool, to access VMs
|
|
*/
|
|
VirtualMachinePool * vmpool;
|
|
|
|
/**
|
|
* Pointer to the Host Pool, to access hosts
|
|
*/
|
|
HostPool * hpool;
|
|
|
|
/**
|
|
* Pointer to the Image Pool, to access images
|
|
*/
|
|
ImagePool * ipool;
|
|
|
|
/**
|
|
* Pointer to the SecurityGroup Pool
|
|
*/
|
|
SecurityGroupPool * sgpool;
|
|
|
|
/**
|
|
* Pointer to the Cluster Pool
|
|
*/
|
|
ClusterPool * clpool;
|
|
|
|
/**
|
|
* Pointer to TransferManager
|
|
*/
|
|
TransferManager * tm;
|
|
|
|
/**
|
|
* Pointer to VirtualMachineManager
|
|
*/
|
|
VirtualMachineManager * vmm;
|
|
|
|
/**
|
|
* Pointer to DispatchManager
|
|
*/
|
|
DispatchManager * dm;
|
|
|
|
/**
|
|
* Action engine for the Manager
|
|
*/
|
|
ActionManager am;
|
|
|
|
/**
|
|
* Pointer to ImageManager
|
|
*/
|
|
ImageManager * imagem;
|
|
|
|
|
|
/**
|
|
* Function to execute the Manager action loop method within a new pthread
|
|
* (requires C linkage)
|
|
*/
|
|
friend void * lcm_action_loop(void *arg);
|
|
|
|
/**
|
|
* The action function executed when an action is triggered.
|
|
* @param action the name of the action
|
|
* @param arg arguments for the action function
|
|
*/
|
|
void do_action(
|
|
const string & action,
|
|
void * arg);
|
|
|
|
/**
|
|
* Cleans up a VM, canceling any pending or ongoing action and closing
|
|
* the history registers
|
|
*
|
|
* @param vm with the lock acquired
|
|
* @param dispose true if the vm will end in DONE, false to resubmit to PENDING
|
|
* @param image_id If the VM is in the middle of a save as operation, an
|
|
* image may need to be set to error state.
|
|
*/
|
|
void clean_up_vm (VirtualMachine *vm, bool dispose, int& image_id);
|
|
|
|
void save_success_action(int vid);
|
|
|
|
void save_failure_action(int vid);
|
|
|
|
void deploy_success_action(int vid);
|
|
|
|
void deploy_failure_action(int vid);
|
|
|
|
void shutdown_success_action(int vid);
|
|
|
|
void shutdown_failure_action(int vid);
|
|
|
|
void monitor_suspend_action(int vid);
|
|
|
|
void monitor_done_action(int vid);
|
|
|
|
void monitor_poweroff_action(int vid);
|
|
|
|
void monitor_poweron_action(int vid);
|
|
|
|
void prolog_success_action(int vid);
|
|
|
|
void prolog_failure_action(int vid);
|
|
|
|
void epilog_success_action(int vid);
|
|
|
|
void epilog_failure_action(int vid);
|
|
|
|
void attach_success_action(int vid);
|
|
|
|
void attach_failure_action(int vid);
|
|
|
|
void detach_success_action(int vid);
|
|
|
|
void detach_failure_action(int vid);
|
|
|
|
void saveas_success_action(int vid);
|
|
|
|
void saveas_failure_action(int vid);
|
|
|
|
void attach_nic_success_action(int vid);
|
|
|
|
void attach_nic_failure_action(int vid);
|
|
|
|
void detach_nic_success_action(int vid);
|
|
|
|
void detach_nic_failure_action(int vid);
|
|
|
|
void cleanup_callback_action(int vid);
|
|
|
|
void snapshot_create_success(int vid);
|
|
|
|
void snapshot_create_failure(int vid);
|
|
|
|
void snapshot_revert_success(int vid);
|
|
|
|
void snapshot_revert_failure(int vid);
|
|
|
|
void snapshot_delete_success(int vid);
|
|
|
|
void snapshot_delete_failure(int vid);
|
|
|
|
void disk_snapshot_success(int vid);
|
|
|
|
void disk_snapshot_failure(int vid);
|
|
|
|
void deploy_action(int vid);
|
|
|
|
void suspend_action(int vid);
|
|
|
|
void restore_action(int vid);
|
|
|
|
void stop_action(int vid);
|
|
|
|
void checkpoint_action(int vid);
|
|
|
|
void migrate_action(int vid);
|
|
|
|
void live_migrate_action(int vid);
|
|
|
|
void shutdown_action(int vid, bool hard);
|
|
|
|
void undeploy_action(int vid, bool hard);
|
|
|
|
void poweroff_action(int vid);
|
|
|
|
void poweroff_hard_action(int vid);
|
|
|
|
void poweroff_action(int vid, bool hard);
|
|
|
|
void updatesg_action(int sgid);
|
|
|
|
void restart_action(int vid);
|
|
|
|
void delete_action(int vid);
|
|
|
|
void clean_action(int vid);
|
|
|
|
void timer_action();
|
|
};
|
|
|
|
#endif /*LIFE_CYCLE_MANAGER_H_*/
|