2008-06-17 20:27:32 +04:00
/* -------------------------------------------------------------------------- */
2018-01-02 20:27:37 +03:00
/* Copyright 2002-2018, OpenNebula Project, OpenNebula Systems */
2008-06-17 20:27:32 +04:00
/* */
/* 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 VIRTUAL_MACHINE_MANAGER_DRIVER_H_
# define VIRTUAL_MACHINE_MANAGER_DRIVER_H_
# include <map>
# include <string>
# include <sstream>
# include "Mad.h"
2016-02-09 18:33:13 +03:00
# include "ActionSet.h"
2008-06-17 20:27:32 +04:00
# include "VirtualMachinePool.h"
2015-11-20 17:44:37 +03:00
# include "History.h"
2008-06-17 20:27:32 +04:00
using namespace std ;
/**
* VirtualMachineManagerDriver provides a base class to implement VM Manager
* Drivers . This class implements the protocol and recover functions
* from the Mad interface . Classes derived from the VirtualMachineManagerDriver
2013-01-21 03:15:46 +04:00
* must implement the deployment function to generate specific VM
2008-06-17 20:27:32 +04:00
* deployment information for the unerlying MAD .
*/
class VirtualMachineManagerDriver : public Mad
{
public :
VirtualMachineManagerDriver (
int userid ,
const map < string , string > & attrs ,
bool sudo ,
2008-07-05 19:46:29 +04:00
VirtualMachinePool * pool ) ;
2008-06-17 20:27:32 +04:00
2008-07-05 19:46:29 +04:00
virtual ~ VirtualMachineManagerDriver ( ) { } ;
2008-06-17 20:27:32 +04:00
/**
* Implements the VM Manager driver protocol .
* @ param message the string read from the driver
*/
2013-05-16 23:54:56 +04:00
void protocol ( const string & message ) const ;
2008-06-17 20:27:32 +04:00
/**
2013-01-21 03:15:46 +04:00
* TODO : What do we need here ? just poll the active VMs to recover
2008-06-17 20:27:32 +04:00
* connections ? Or an specific recover action from the MAD ?
*/
void recover ( ) ;
/**
* Generates a driver - specific deployment file :
* @ param vm pointer to a virtual machine
* @ param file_name to generate the deployment description
* @ return 0 on success
*/
virtual int deployment_description (
const VirtualMachine * vm ,
const string & file_name ) const = 0 ;
2013-01-21 03:15:46 +04:00
2013-02-13 14:07:23 +04:00
/**
* Updates the VM with the information gathered by the drivers
*
* @ param id VM id
* @ param monitor_str String returned by the poll driver call
*/
2017-09-05 14:17:08 +03:00
static void process_poll ( int id , const string & monitor_str ) ;
2013-02-11 20:50:08 +04:00
2008-07-05 19:46:29 +04:00
/**
2013-02-13 14:07:23 +04:00
* Updates the VM with the information gathered by the drivers
*
* @ param vm VM to update , must be locked
* @ param monitor_str String returned by the poll driver call
*/
2017-09-05 14:17:08 +03:00
static void process_poll ( VirtualMachine * vm , const string & monitor_str ) ;
2013-02-11 20:50:08 +04:00
2015-11-20 17:44:37 +03:00
/**
* Check if action is supported for imported VMs
* @ param action
* @ return True if it is supported
*/
bool is_imported_action_supported ( History : : VMAction action ) const
{
2016-02-09 18:33:13 +03:00
return imported_actions . is_set ( action ) ;
2015-11-20 17:44:37 +03:00
}
2016-05-18 20:48:43 +03:00
/**
* @ return true if system snapshots are preserved
*/
bool is_keep_snapshots ( ) const
{
return keep_snapshots ;
}
2013-01-21 03:15:46 +04:00
protected :
2008-07-05 19:46:29 +04:00
/**
2013-01-21 03:15:46 +04:00
* Gets a configuration attr from driver configuration file ( single
2008-07-05 19:46:29 +04:00
* version )
* @ param name of config attribute
* @ param value of the attribute
*/
2016-02-09 18:33:13 +03:00
template < typename T >
void get_default ( const string & name , T & value ) const
2008-07-05 19:46:29 +04:00
{
2016-02-09 18:33:13 +03:00
driver_conf . get ( name , value ) ;
2013-01-21 03:15:46 +04:00
}
2008-06-17 20:27:32 +04:00
2008-07-05 19:46:29 +04:00
/**
2013-01-21 03:15:46 +04:00
* Gets a configuration attr from driver configuration file ( vector
2008-07-05 19:46:29 +04:00
* version )
* @ param name of config vector attribute for the domain
* @ param vname of the attribute
* @ param value of the attribute
*/
2016-02-09 18:33:13 +03:00
template < typename T >
int get_default ( const char * name , const char * vname , T & value ) const
{
const VectorAttribute * vattr = driver_conf . get ( name ) ;
2013-01-21 03:15:46 +04:00
2016-02-12 18:25:06 +03:00
if ( vattr = = 0 )
2016-02-09 18:33:13 +03:00
{
return - 1 ;
}
return vattr - > vector_value ( vname , value ) ;
}
2013-02-26 17:56:41 +04:00
2013-01-21 03:15:46 +04:00
private :
2016-02-09 18:33:13 +03:00
friend class VirtualMachineManager ;
static const string imported_actions_default ;
static const string imported_actions_default_public ;
2015-07-01 22:15:40 +03:00
/**
* Configuration file for the driver
*/
Template driver_conf ;
2013-01-21 03:15:46 +04:00
2015-11-20 17:44:37 +03:00
/**
* List of available actions for imported VMs . Each bit is an action
* as defined in History . h , 1 = supported and 0 = not supported
*/
2016-02-09 18:33:13 +03:00
ActionSet < History : : VMAction > imported_actions ;
2015-11-20 17:44:37 +03:00
2016-05-18 20:48:43 +03:00
/**
* Set to true if the hypervisor can keep system snapshots across
* create / delete cycles and live migrations .
*/
bool keep_snapshots ;
2008-06-17 20:27:32 +04:00
/**
* Pointer to the Virtual Machine Pool , to access VMs
*/
VirtualMachinePool * vmpool ;
/**
2011-11-10 14:15:58 +04:00
* Sends a deploy request to the MAD : " DEPLOY ID XML_DRV_MSG "
2008-06-17 20:27:32 +04:00
* @ param oid the virtual machine id .
2011-11-10 14:15:58 +04:00
* @ param drv_msg xml data for the mad operation
2008-06-17 20:27:32 +04:00
*/
void deploy (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " DEPLOY " , oid , drv_msg ) ;
}
2008-06-17 20:27:32 +04:00
/**
2011-11-10 14:15:58 +04:00
* Sends a shutdown request to the MAD : " SHUTDOWN ID XML_DRV_MSG "
2008-06-17 20:27:32 +04:00
* @ param oid the virtual machine id .
2011-11-10 14:15:58 +04:00
* @ param drv_msg xml data for the mad operation
2008-06-17 20:27:32 +04:00
*/
void shutdown (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " SHUTDOWN " , oid , drv_msg ) ;
}
/**
* Sends a reset request to the MAD : " RESET ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void reset (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " RESET " , oid , drv_msg ) ;
}
2008-06-17 20:27:32 +04:00
2011-12-26 02:46:19 +04:00
/**
* Sends a reboot request to the MAD : " REBOOT ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void reboot (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " REBOOT " , oid , drv_msg ) ;
}
2011-12-26 02:46:19 +04:00
2008-06-17 20:27:32 +04:00
/**
2011-11-10 14:15:58 +04:00
* Sends a cancel request to the MAD : " CANCEL ID XML_DRV_MSG "
2008-06-17 20:27:32 +04:00
* @ param oid the virtual machine id .
2011-11-10 14:15:58 +04:00
* @ param drv_msg xml data for the mad operation
2008-06-17 20:27:32 +04:00
*/
void cancel (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " CANCEL " , oid , drv_msg ) ;
}
2008-06-17 20:27:32 +04:00
2013-01-21 03:15:46 +04:00
/**
* Sends a cleanup request to the MAD : " CLEANUP ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void cleanup (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " CLEANUP " , oid , drv_msg ) ;
}
2008-06-17 20:27:32 +04:00
/**
2011-11-10 14:15:58 +04:00
* Sends a checkpoint request to the MAD : " CHECKPOINT ID XML_DRV_MSG "
2008-06-17 20:27:32 +04:00
* @ param oid the virtual machine id .
2011-11-10 14:15:58 +04:00
* @ param drv_msg xml data for the mad operation
2008-06-17 20:27:32 +04:00
*/
void checkpoint (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " CHECKPOINT " , oid , drv_msg ) ;
}
2008-06-17 20:27:32 +04:00
/**
2011-11-10 14:15:58 +04:00
* Sends a save request to the MAD : " SAVE ID XML_DRV_MSG "
2008-06-17 20:27:32 +04:00
* @ param oid the virtual machine id .
2011-11-10 14:15:58 +04:00
* @ param drv_msg xml data for the mad operation
2008-06-17 20:27:32 +04:00
*/
void save (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " SAVE " , oid , drv_msg ) ;
}
2008-06-17 20:27:32 +04:00
/**
2011-11-10 14:15:58 +04:00
* Sends a save request to the MAD : " RESTORE ID XML_DRV_MSG "
2008-06-17 20:27:32 +04:00
* @ param oid the virtual machine id .
2011-11-10 14:15:58 +04:00
* @ param drv_msg xml data for the mad operation
2008-06-17 20:27:32 +04:00
*/
void restore (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " RESTORE " , oid , drv_msg ) ;
}
2008-06-17 20:27:32 +04:00
/**
2011-11-10 14:15:58 +04:00
* Sends a migrate request to the MAD : " MIGRATE ID XML_DRV_MSG "
2008-06-17 20:27:32 +04:00
* @ param oid the virtual machine id .
2011-11-10 14:15:58 +04:00
* @ param drv_msg xml data for the mad operation
2008-06-17 20:27:32 +04:00
*/
void migrate (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " MIGRATE " , oid , drv_msg ) ;
}
2008-06-17 20:27:32 +04:00
/**
2011-11-10 14:15:58 +04:00
* Sends a poll request to the MAD : " POLL ID XML_DRV_MSG "
2008-06-17 20:27:32 +04:00
* @ param oid the virtual machine id .
2011-11-10 14:15:58 +04:00
* @ param drv_msg xml data for the mad operation
2008-06-17 20:27:32 +04:00
*/
void poll (
const int oid ,
2012-05-09 00:33:59 +04:00
const string & drv_msg ) const
{
write_drv ( " POLL " , oid , drv_msg ) ;
}
2012-06-13 20:42:42 +04:00
/**
2012-12-12 21:31:27 +04:00
* Sends an attach request to the MAD : " ATTACHDISK ID XML_DRV_MSG "
2012-06-13 20:42:42 +04:00
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void attach (
const int oid ,
const string & drv_msg ) const
{
2012-06-15 20:14:08 +04:00
write_drv ( " ATTACHDISK " , oid , drv_msg ) ;
2012-06-13 20:42:42 +04:00
}
2012-06-14 19:45:41 +04:00
/**
2012-12-12 21:31:27 +04:00
* Sends a detach request to the MAD : " DETACHDISK ID XML_DRV_MSG "
2012-06-14 19:45:41 +04:00
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void detach (
const int oid ,
const string & drv_msg ) const
{
2012-06-15 20:14:08 +04:00
write_drv ( " DETACHDISK " , oid , drv_msg ) ;
2012-06-14 19:45:41 +04:00
}
2012-12-12 21:31:27 +04:00
/**
* Sends an attach NIC request to the MAD : " ATTACHNIC ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void attach_nic (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " ATTACHNIC " , oid , drv_msg ) ;
}
/**
* Sends a detach request to the MAD : " DETACHNIC ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void detach_nic (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " DETACHNIC " , oid , drv_msg ) ;
}
2013-02-19 18:21:33 +04:00
/**
* Sends a snapshot create request to the MAD :
* " SNAPSHOTCREATE ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void snapshot_create (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " SNAPSHOTCREATE " , oid , drv_msg ) ;
}
2013-02-20 19:04:09 +04:00
/**
* Sends a snapshot revert request to the MAD :
* " SNAPSHOTREVERT ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void snapshot_revert (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " SNAPSHOTREVERT " , oid , drv_msg ) ;
}
2012-05-09 00:33:59 +04:00
2013-02-21 18:01:48 +04:00
/**
* Sends a snapshot delete request to the MAD :
* " SNAPSHOTDELETE ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void snapshot_delete (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " SNAPSHOTDELETE " , oid , drv_msg ) ;
}
2015-07-01 14:37:58 +03:00
/**
* Sends a disk snapshot create request to the MAD :
* " DISKSNAPSHOTCREATE ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void disk_snapshot_create (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " DISKSNAPSHOTCREATE " , oid , drv_msg ) ;
}
2016-12-17 21:30:11 +03:00
/**
* Sends a disk resize request to the MAD :
* " RESIZE ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void disk_resize (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " RESIZEDISK " , oid , drv_msg ) ;
}
2016-03-02 01:31:31 +03:00
/**
* Sends a request to update the VM security groups :
* " UPDATESG ID XML_DRV_MSG "
* @ param oid the virtual machine id .
* @ param drv_msg xml data for the mad operation
*/
void updatesg (
const int oid ,
const string & drv_msg ) const
{
write_drv ( " UPDATESG " , oid , drv_msg ) ;
}
2013-03-06 18:59:58 +04:00
/**
*
*/
2012-05-09 00:33:59 +04:00
void write_drv ( const char * aname , const int oid , const string & msg ) const
{
ostringstream os ;
os < < aname < < " " < < oid < < " " < < msg < < endl ;
2013-03-06 18:59:58 +04:00
2012-05-09 00:33:59 +04:00
write ( os ) ;
}
2008-06-17 20:27:32 +04:00
} ;
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
# endif /*VIRTUAL_MACHINE_MANAGER_DRIVER_H_*/