// Validate a result string
bool validate_vmgahp_result_string(const char *result_string)
{
StringList result_list(result_string, " ");
if( result_list.isEmpty() ) {
return false;
}
// Format: <req_id> 0 <result1> ..
// Format: <req_id> 1 <result1> ..
if(result_list.number() < 3 ) {
return false;
}
char *arg = NULL;
result_list.rewind();
// first arg must be digit
arg = result_list.next();
if( !arg || !verify_digit_arg(arg)) {
vmprintf(D_ALWAYS, "First arg in result must be digit: %s\n", result_string);
return false;
}
// second arg must be either 0 or 1
arg = result_list.next();
if( !arg || ( strcmp(arg, "0") && strcmp(arg, "1") ) ) {
vmprintf(D_ALWAYS, "Second arg in result must be either 0 or 1: %s\n", result_string);
return false;
}
return true;
}
void
VirshType::Config()
{
char *config_value = NULL;
config_value = param("VM_NETWORKING_BRIDGE_INTERFACE");
if( config_value ) {
m_vm_bridge_interface = delete_quotation_marks(config_value).Value();
free(config_value);
} else if( vmgahp->m_gahp_config->m_vm_networking_types.contains("bridge") == true) {
vmprintf( D_ALWAYS, "ERROR: 'VM_NETWORKING_TYPE' contains "
"'bridge' but VM_NETWORKING_BRIDGE_INTERFACE "
"isn't defined, so 'bridge' "
"networking is disabled\n");
vmgahp->m_gahp_config->m_vm_networking_types.remove("bridge");
if( vmgahp->m_gahp_config->m_vm_networking_types.isEmpty() ) {
vmprintf( D_ALWAYS, "ERROR: 'VM_NETWORKING' is true "
"but 'VM_NETWORKING_TYPE' contains "
"no valid entries, so 'VM_NETWORKING' "
"is disabled\n");
vmgahp->m_gahp_config->m_vm_networking = false;
} else {
vmprintf( D_ALWAYS,
"Setting default networking type to 'nat'\n");
vmgahp->m_gahp_config->m_vm_default_networking_type = "nat";
}
}
}
int
VMGahp::waitForCommand(int /*pipe_end*/)
{
MyString *line = NULL;
while((line = m_request_buffer.GetNextLine()) != NULL) {
const char *command = line->Value();
Gahp_Args args;
VMRequest *new_req = NULL;
if( m_inClassAd ) {
if( strcasecmp(command, VMGAHP_COMMAND_CLASSAD_END) == 0 ) {
m_inClassAd = false;
// Everything is Ok. Now we got vmClassAd
returnOutputSuccess();
}else {
if( !m_jobAd->Insert(command) ) {
vmprintf(D_ALWAYS, "Failed to insert \"%s\" into classAd, "
"ignoring this attribute\n", command);
}
}
}else {
if(parse_vmgahp_command(command, args) &&
verifyCommand(args.argv, args.argc)) {
new_req = preExecuteCommand(command, &args);
if( new_req != NULL ) {
// Execute the new request
executeCommand(new_req);
if(new_req->m_has_result) {
movePendingReqToResultList(new_req);
if (m_async_mode) {
if (!m_new_results_signaled) {
write_to_daemoncore_pipe("R\n");
}
// So that we only do it once
m_new_results_signaled = true;
}
}
}
}else {
returnOutputError();
}
}
delete line;
line = NULL;
}
// check if GetNextLine() returned NULL because of an error or EOF
if(m_request_buffer.IsError() || m_request_buffer.IsEOF()) {
vmprintf(D_ALWAYS, "Request buffer closed, exiting\n");
cleanUp();
DC_Exit(0);
}
return true;
}
bool
VirshType::ResumeFromSoftSuspend(void)
{
vmprintf(D_FULLDEBUG, "Inside VirshType::ResumeFromSoftSuspend\n");
if( (m_configfile.Length() == 0)) {
return false;
}
if( m_is_soft_suspended ) {
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", m_vm_name.Value(), (err ? err->message : "No reason found"));
return false;
}
priv = set_root_priv();
int result = virDomainResume(dom);
virDomainFree(dom);
set_priv(priv);
if( result != 0 ) {
// unpause failed.
vmprintf(D_ALWAYS, "Unpausing VM failed in "
"VirshType::ResumeFromSoftSuspend\n");
return false;
}
m_is_soft_suspended = false;
}
return true;
}
bool
VirshType::killVMFast(const char* vmname, virConnectPtr libvirt_con)
{
vmprintf(D_FULLDEBUG, "Inside VirshType::killVMFast\n");
if( !vmname || (vmname[0] == '\0') ) {
return false;
}
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(libvirt_con, vmname);
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(libvirt_con);
if (err && err->code != VIR_ERR_NO_DOMAIN)
{
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", vmname, (err ? err->message : "No reason found"));
return false;
}
else
{
return true;
}
}
priv = set_root_priv();
bool ret = (virDomainDestroy(dom) == 0);
virDomainFree(dom);
set_priv(priv);
return ret;
}
void
VMGahp::executeCheckpoint(VMRequest *req)
{
// Expecting: VMGAHP_COMMAND_VM_CHECKPOINT <req_id> <vmid>
int vm_id = strtol(req->m_args.argv[2],(char **)NULL, 10);
MyString err_message;
VMType *vm = findVM(vm_id);
if(vm == NULL) {
req->m_has_result = true;
req->m_is_success = false;
req->m_result = VMGAHP_ERR_VM_NOT_FOUND;
vmprintf(D_FULLDEBUG, "VM(id=%d) is not found in executeCheckpoint\n",
vm_id);
return;
}else {
int result = vm->Checkpoint();
if(result == false) {
req->m_has_result = true;
req->m_is_success = false;
req->m_result = makeErrorMessage(vm->m_result_msg.Value());
vmprintf(D_FULLDEBUG, "executeCheckpoint fail!\n");
return;
} else {
req->m_has_result = true;
req->m_is_success = true;
req->m_result = "";
vmprintf(D_FULLDEBUG, "executeCheckpoint success!\n");
return;
}
}
}
bool
XenType::checkXenParams(VMGahpConfig* config)
{
char *config_value = NULL;
MyString fixedvalue;
vmprintf(D_FULLDEBUG, "In XenType::checkXenParams()\n");
if( !config ) {
return false;
}
// Read XEN_BOOTLOADER (required parameter)
config_value = param("XEN_BOOTLOADER");
if( !config_value ) {
vmprintf(D_ALWAYS, "\nERROR: You should define Xen bootloader\n");
return false;
}
fixedvalue = delete_quotation_marks(config_value);
free(config_value);
// Can read xen boot loader ?
if( check_vm_read_access_file(fixedvalue.Value(), true) == false ) {
vmprintf(D_ALWAYS, "Xen bootloader file '%s' cannot be read\n",
fixedvalue.Value());
return false;
}
return true;
}
bool KVMType::CreateVirshConfigFile(const char * filename)
{
MyString disk_string;
if(!filename) return false;
// The old way of doing things was to write the XML directly to a
// file; the new way is to store it in m_xml.
if (!VirshType::CreateVirshConfigFile(filename))
{
vmprintf(D_ALWAYS, "KVMType::CreateVirshConfigFile no XML found, generating defaults\n");
m_xml += "<domain type='kvm'>";
m_xml += "<name>";
m_xml += m_vm_name;
m_xml += "</name>";
m_xml += "<memory>";
m_xml += m_vm_mem * 1024;
m_xml += "</memory>";
m_xml += "<vcpu>";
m_xml += m_vcpus;
m_xml += "</vcpu>";
m_xml += "<os><type>hvm</type></os>";
m_xml += "<devices>";
m_xml += "<console type='pty'><source path='/dev/ptmx'/></console>";
if( m_vm_networking )
{
vmprintf(D_FULLDEBUG, "mac address is %s\n", m_vm_job_mac.Value());
if( m_vm_networking_type.find("nat") >= 0 ) {
m_xml += "<interface type='network'><source network='default'/></interface>";
}
else if( m_vm_networking_type.find("bridge") >= 0 )
{
m_xml += "<interface type='bridge'>";
if (!m_vm_bridge_interface.empty()) {
m_xml += "<source bridge='";
m_xml += m_vm_bridge_interface.c_str();
m_xml += "'/>";
}
if(!m_vm_job_mac.IsEmpty())
{
m_xml += "<mac address='";
m_xml += m_vm_job_mac;
m_xml += "'/>";
}
m_xml += "</interface>";
}
}
disk_string = makeVirshDiskString();
m_xml += disk_string;
m_xml += "</devices></domain>";
}
return true;
}
void
VMGahp::killAllProcess()
{
if( !m_jobAd ) {
// Virtual machine is absolutely not created.
return;
}
#if defined (HAVE_EXT_LIBVIRT) && !defined(VMWARE_ONLY)
if( strcasecmp(m_gahp_config->m_vm_type.Value(),
CONDOR_VM_UNIVERSE_XEN ) == 0 ) {
priv_state priv = set_root_priv();
if( m_jobAd && XenType::checkXenParams(m_gahp_config) ) {
MyString vmname;
if( VMType::createVMName(m_jobAd, vmname) ) {
XenType::killVMFast(vmname.Value());
vmprintf( D_FULLDEBUG, "killVMFast is called\n");
}
}
set_priv(priv);
} else if(strcasecmp(m_gahp_config->m_vm_type.Value(),
CONDOR_VM_UNIVERSE_KVM ) == 0 ) {
priv_state priv = set_root_priv();
if( m_jobAd && KVMType::checkXenParams(m_gahp_config) ) {
MyString vmname;
if( VMType::createVMName(m_jobAd, vmname) ) {
KVMType::killVMFast(vmname.Value());
vmprintf( D_FULLDEBUG, "killVMFast is called\n");
}
}
set_priv(priv);
} else
#endif
if( strcasecmp(m_gahp_config->m_vm_type.Value(),
CONDOR_VM_UNIVERSE_VMWARE ) == 0 ) {
priv_state priv = set_user_priv();
if( VMwareType::checkVMwareParams(m_gahp_config) ) {
VMwareType::killVMFast(m_gahp_config->m_prog_for_script.Value(),
m_gahp_config->m_vm_script.Value(), m_workingdir.Value());
vmprintf( D_FULLDEBUG, "killVMFast is called\n");
}
set_priv(priv);
}
// [PRAGMA] Kill Rocks VM Process
else if( strcasecmp(m_gahp_config->m_vm_type.Value(),
CONDOR_VM_UNIVERSE_VMWARE ) == 0 ) {
priv_state priv = set_user_priv();
if( RocksType::checkRocksParams(m_gahp_config) ) {
RocksType::killVMFast(m_gahp_config->m_prog_for_script.Value(),
m_gahp_config->m_vm_script.Value(), m_workingdir.Value());
vmprintf( D_FULLDEBUG, "killVMFast is called\n");
}
set_priv(priv);
}
}
bool
VMType::createConfigUsingScript(const char* configfile)
{
vmprintf(D_FULLDEBUG, "Inside VMType::createConfigUsingScript\n");
if( !configfile || m_scriptname.IsEmpty() ) {
return false;
}
// Set temporary environments for script program
StringList name_list;
const char *name;
ExprTree* expr = NULL;
m_classAd.ResetExpr();
while( m_classAd.NextExpr(name, expr) ) {
if( !strncasecmp( name, "JobVM", strlen("JobVM") ) ||
!strncasecmp( name, "VMPARAM", strlen("VMPARAM") )) {
name_list.append(name);
SetEnv(name, ExprTreeToString(expr));
}
}
ArgList systemcmd;
if( m_prog_for_script.IsEmpty() == false ) {
systemcmd.AppendArg(m_prog_for_script);
}
systemcmd.AppendArg(m_scriptname);
systemcmd.AppendArg("createconfig");
systemcmd.AppendArg(configfile);
int result = systemCommand(systemcmd, m_file_owner);
// UnSet temporary environments for script program
const char *tmp_name = NULL;
name_list.rewind();
while( (tmp_name = name_list.next()) != NULL ) {
UnsetEnv(tmp_name);
}
if( result != 0 ) {
vmprintf(D_ALWAYS, "Failed to create Configuration file('%s') using "
"script program('%s')\n", configfile,
m_scriptname.Value());
return false;
}
return true;
}
bool
write_local_settings_from_file(FILE* out_fp,
const char* param_name,
const char* start_mark,
const char* end_mark)
{
char* tmp = param(param_name);
if (tmp == NULL) {
return true;
}
MyString local_settings_file = tmp;
free(tmp);
if (start_mark != NULL) {
if (fprintf(out_fp, "%s\n", start_mark) < 0) {
vmprintf(D_ALWAYS,
"fprintf error writing start marker: %s\n",
strerror(errno));
return false;
}
}
FILE* in_fp = safe_fopen_wrapper_follow(local_settings_file.Value(), "r");
if (in_fp == NULL) {
vmprintf(D_ALWAYS,
"fopen error on %s: %s\n",
local_settings_file.Value(),
strerror(errno));
return false;
}
MyString line;
while (line.readLine(in_fp)) {
if (fputs(line.Value(), out_fp) == EOF) {
vmprintf(D_ALWAYS,
"fputs error copying local settings: %s\n",
strerror(errno));
fclose(in_fp);
return false;
}
}
fclose(in_fp);
if (end_mark != NULL) {
if (fprintf(out_fp, "%s\n", end_mark) == EOF) {
vmprintf(D_ALWAYS,
"fputs error writing end marker: %s\n",
strerror(errno));
return false;
}
}
return true;
}
bool
VirshType::createCkptFiles(void)
{
vmprintf(D_FULLDEBUG, "Inside VirshType::createCkptFiles\n");
// This function will suspend a running VM.
if( getVMStatus() == VM_STOPPED ) {
vmprintf(D_ALWAYS, "createCkptFiles is called for a stopped VM\n");
return false;
}
if( getVMStatus() == VM_RUNNING ) {
if( Suspend() == false ) {
return false;
}
}
if( getVMStatus() == VM_SUSPENDED ) {
// we create timestampfile
time_t current_time = time(NULL);
MyString timestampfile(m_suspendfile);
timestampfile += XEN_CKPT_TIMESTAMP_FILE_SUFFIX;
FILE *fp = safe_fopen_wrapper(timestampfile.Value(), "w");
if( !fp ) {
vmprintf(D_ALWAYS, "failed to safe_fopen_wrapper file(%s) for "
"checkpoint timestamp : safe_fopen_wrapper returns %s\n",
timestampfile.Value(), strerror(errno));
Resume();
return false;
}
if( fprintf(fp, "%d\n", (int)current_time) < 0 ) {
fclose(fp);
unlink(timestampfile.Value());
vmprintf(D_ALWAYS, "failed to fprintf for checkpoint timestamp "
"file(%s:%s)\n", timestampfile.Value(), strerror(errno));
Resume();
return false;
}
fclose(fp);
// checkpoint succeeds
m_is_checkpointed = true;
return true;
}
return false;
}
void
VMGahp::executeGetpid(VMRequest *req)
{
// Expecting: VMGAHP_COMMAND_VM_GETPID <req_id> <vmid>
int vm_id = strtol(req->m_args.argv[2],(char **)NULL, 10);
MyString err_message;
VMType *vm = findVM(vm_id);
if(vm == NULL) {
req->m_has_result = true;
req->m_is_success = false;
req->m_result = VMGAHP_ERR_VM_NOT_FOUND;
vmprintf(D_FULLDEBUG, "VM(id=%d) is not found in executeGetPid\n",
vm_id);
return;
}else {
req->m_has_result = true;
req->m_is_success = true;
// Result is set to the pid of actual process for VM
req->m_result = "";
req->m_result += vm->PidOfVM();
return;
}
}
/*
** Set the socket error message.
*/
void socket_set_errmsg(const char *zFormat, ...){
va_list ap;
socket_clear_errmsg();
va_start(ap, zFormat);
socketErrMsg = vmprintf(zFormat, ap);
va_end(ap);
}
void
VMGahp::executeCommand(VMRequest *req)
{
char *command = req->m_args.argv[0];
priv_state priv = set_user_priv();
if(strcasecmp(command, VMGAHP_COMMAND_VM_START) == 0 ) {
executeStart(req);
} else if(strcasecmp(command, VMGAHP_COMMAND_VM_STOP) == 0 ) {
executeStop(req);
} else if(strcasecmp(command, VMGAHP_COMMAND_VM_SUSPEND) == 0 ) {
executeSuspend(req);
} else if(strcasecmp(command, VMGAHP_COMMAND_VM_SOFT_SUSPEND) == 0 ) {
executeSoftSuspend(req);
} else if(strcasecmp(command, VMGAHP_COMMAND_VM_RESUME) == 0 ) {
executeResume(req);
} else if(strcasecmp(command, VMGAHP_COMMAND_VM_CHECKPOINT) == 0 ) {
executeCheckpoint(req);
} else if(strcasecmp(command, VMGAHP_COMMAND_VM_STATUS) == 0 ) {
executeStatus(req);
} else if(strcasecmp(command, VMGAHP_COMMAND_VM_GETPID) == 0 ) {
executeGetpid(req);
} else {
vmprintf(D_ALWAYS, "Unknown command(%s)\n", command);
}
set_priv(priv);
}
// check if a file was transferred.
// if so, fullname will have full path in working directory.
// Otherwise, fullname will be same to file_name
bool
VMType::isTransferedFile(const char* file_name, MyString& fullname)
{
if( !file_name || m_initial_working_files.isEmpty() ) {
return false;
}
// check if this file was transferred.
MyString tmp_fullname;
if( filelist_contains_file(file_name,
&m_initial_working_files, true) ) {
// this file was transferred.
// make full path with workingdir
tmp_fullname.formatstr("%s%c%s", m_workingpath.Value(),
DIR_DELIM_CHAR, condor_basename(file_name));
fullname = tmp_fullname;
return true;
}else {
// this file is not transferred
if( fullpath(file_name) == false ) {
vmprintf(D_ALWAYS, "Warning: The file(%s) doesn't have "
"full path even though it is not "
"transferred\n", file_name);
}
fullname = file_name;
return false;
}
return false;
}
bool verify_number_args(const int is, const int should_be)
{
if( is != should_be) {
vmprintf(D_ALWAYS, "Wrong # of args %d, should be %d\n", is, should_be);
return false;
}
return true;
}
// Check whether the given vmtype is in supported vmtype list
bool
verify_vm_type(const char *vmtype)
{
//[PRAGMA] print verify_vm_type process.
vmprintf(D_ALWAYS, "[PRAGMA] verify_vm_type\n"); //[PRAGMA]
int i=0;
while(support_vms_list[i] != NULL) {
//[PRAGMA] print supported vm type.
vmprintf(D_ALWAYS, "[PRAGMA] supported VM TYPE(%s)\n", support_vms_list[i]); //[PRAGMA] vmprintf all vm types
if(strcasecmp(vmtype, support_vms_list[i]) == 0 ) {
return true;
}
i++;
}
vmprintf(D_ALWAYS, "Not supported VM TYPE(%s)\n", vmtype);
return false;
}
bool
XenType::killVMFast(const char* vmname)
{
vmprintf(D_FULLDEBUG, "Inside XenType::killVMFast\n");
priv_state priv = set_root_priv();
virConnectPtr libvirt_connection = virConnectOpen("xen:///");
set_priv(priv);
return VirshType::killVMFast(vmname, libvirt_connection);
}
bool
VirshType::Checkpoint()
{
vmprintf(D_FULLDEBUG, "Inside VirshType::Checkpoint\n");
if( (m_configfile.Length() == 0)) {
m_result_msg = VMGAHP_ERR_INTERNAL;
return false;
}
if( getVMStatus() == VM_STOPPED ) {
vmprintf(D_ALWAYS, "Checkpoint is called for a stopped VM\n");
m_result_msg = VMGAHP_ERR_VM_INVALID_OPERATION;
return false;
}
if( !m_vm_checkpoint ) {
vmprintf(D_ALWAYS, "Checkpoint is not supported.\n");
m_result_msg = VMGAHP_ERR_VM_NO_SUPPORT_CHECKPOINT;
return false;
}
if( m_xen_hw_vt && !m_allow_hw_vt_suspend ) {
// This VM uses hardware virtualization.
// However, Virsh cannot suspend this type of VM yet.
// So we cannot checkpoint this VM.
vmprintf(D_ALWAYS, "Checkpoint of Hardware VT is not supported.\n");
m_result_msg = VMGAHP_ERR_VM_NO_SUPPORT_CHECKPOINT;
return false;
}
// If a VM is soft suspended, resume it first
ResumeFromSoftSuspend();
// This function cause a running VM to be suspended.
if( createCkptFiles() == false ) {
m_result_msg = VMGAHP_ERR_VM_CANNOT_CREATE_CKPT_FILES;
vmprintf(D_ALWAYS, "failed to create checkpoint files\n");
return false;
}
return true;
}
/*
** Generate <form method="post" action=ARG>. The ARG value is inserted
** by javascript.
*/
void form_begin(const char *zOtherArgs, const char *zAction, ...){
char *zLink;
va_list ap;
if( zOtherArgs==0 ) zOtherArgs = "";
va_start(ap, zAction);
zLink = vmprintf(zAction, ap);
va_end(ap);
if( g.perm.Hyperlink && !g.javascriptHyperlink ){
@ <form method="POST" action="%z(zLink)" %s(zOtherArgs)>
}else{
void
initialize_uids(void)
{
#if defined(WIN32)
#include "my_username.h"
char *name = NULL;
char *domain = NULL;
name = my_username();
domain = my_domainname();
caller_name = name;
job_user_name = name;
if ( !init_user_ids(name, domain ) ) {
// shouldn't happen - we always can get our own token
vmprintf(D_ALWAYS, "Could not initialize user_priv with our own token!\n");
}
vmprintf(D_ALWAYS, "Initialize Uids: caller=%s@%s, job user=%s@%s\n",
caller_name.Value(), domain, job_user_name.Value(), domain);
if( name ) {
free(name);
}
if( domain ) {
free(domain);
}
return;
#else
// init_user_ids was called in main_pre_dc_init()
vmprintf(D_ALWAYS, "Initial UID/GUID=%d/%d, EUID/EGUID=%d/%d, "
"Condor UID/GID=%d,%d\n", (int)getuid(), (int)getuid(),
(int)geteuid(), (int)getegid(),
(int)get_condor_uid(), (int)get_condor_gid());
vmprintf(D_ALWAYS, "Initialize Uids: caller=%s, job user=%s\n",
caller_name.Value(), job_user_name.Value());
return;
#endif
}
/*
* Just so that we can get out of the habit of using "goto".
*/
void virshIOError(const char * filename, FILE * fp)
{
vmprintf(D_ALWAYS, "failed to fprintf in CreateVirshConfigFile(%s:%s)\n",
filename, strerror(errno));
if( fp ) {
fclose(fp);
}
unlink(filename);
}
bool KVMType::checkXenParams(VMGahpConfig * config)
{
MyString fixedvalue;
if( !config ) {
return false;
}
// Do we need to check for both read and write access?
if(check_vm_read_access_file("/dev/kvm", true) == false) {
vmprintf(D_ALWAYS, "\nFile Permission Error: Cannot read /dev/kvm as root\n");
return false;
}
if(check_vm_write_access_file("/dev/kvm", true) == false) {
vmprintf(D_ALWAYS, "\nFile Permission Error: Cannot write /dev/kvm as root\n");
return false;
}
return true;
}
bool
VirshType::SoftSuspend()
{
vmprintf(D_FULLDEBUG, "Inside VirshType::SoftSuspend\n");
if( (m_configfile.Length() == 0)) {
m_result_msg = VMGAHP_ERR_INTERNAL;
return false;
}
if( m_is_soft_suspended ) {
return true;
}
if( getVMStatus() != VM_RUNNING ) {
m_result_msg = VMGAHP_ERR_VM_INVALID_OPERATION;
return false;
}
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", m_vm_name.Value(), (err ? err->message : "No reason found"));
return false;
}
int result = virDomainSuspend(dom);
virDomainFree(dom);
if( result == 0 ) {
// pause succeeds.
m_is_soft_suspended = true;
return true;
}
// Failed to suspend a VM softly.
// Instead of soft suspend, we use hard suspend.
vmprintf(D_ALWAYS, "SoftSuspend failed, so try hard Suspend instead!.\n");
return Suspend();
}
bool
VMGahp::verify_request_id(const char *s)
{
if( verify_digit_arg(s) == false) {
return false;
}
int req_id = (int)strtol(s, (char **)NULL, 10);
if( req_id <= 0 ) {
vmprintf(D_ALWAYS, "Invalid Request id(%s)\n", s);
return false;
}
// check duplicated req_id
if( findPendingRequest(req_id) != NULL ) {
vmprintf(D_ALWAYS, "Request id(%s) is conflict with "
"the existing one\n", s);
return false;
}
return true;
}
static char*
mprintf(const char *fmt, ...)
{
va_list ap;
char *s;
va_start(ap, fmt);
s = vmprintf(fmt, ap);
va_end(ap);
return s;
}
// Create a name representing a virtual machine
// Usually this name is used in vm config file
bool
VMType::createVMName(ClassAd *ad, MyString& vmname)
{
if( !ad ) {
return false;
}
if( create_name_for_VM(ad, vmname) == false ) {
vmprintf(D_ALWAYS, "Cannot make the name of VM\n");
return false;
}
return true;
}
// Check whether the given vmtype is in supported vmtype list
bool
verify_vm_type(const char *vmtype)
{
int i=0;
while(support_vms_list[i] != NULL) {
if(strcasecmp(vmtype, support_vms_list[i]) == 0 ) {
return true;
}
i++;
}
vmprintf(D_ALWAYS, "Not supported VM TYPE(%s)\n", vmtype);
return false;
}
bool
VirshType::Resume()
{
vmprintf(D_FULLDEBUG, "Inside VirshType::Resume\n");
if((m_configfile.Length() == 0)) {
m_result_msg = VMGAHP_ERR_INTERNAL;
return false;
}
// If a VM is soft suspended, resume it first.
ResumeFromSoftSuspend();
if( getVMStatus() == VM_RUNNING ) {
return true;
}
if( !m_restart_with_ckpt &&
( getVMStatus() != VM_SUSPENDED) ) {
m_result_msg = VMGAHP_ERR_VM_INVALID_OPERATION;
return false;
}
m_restart_with_ckpt = false;
m_is_checkpointed = false;
if( check_vm_read_access_file(m_suspendfile.Value(), true) == false ) {
m_result_msg = VMGAHP_ERR_VM_INVALID_SUSPEND_FILE;
return false;
}
priv_state priv = set_root_priv();
int result = virDomainRestore(m_libvirt_connection, m_suspendfile.Value());
set_priv(priv);
if( result != 0 ) {
// Read error output
// char *temp = cmd_out.print_to_delimed_string("/");
// m_result_msg = temp;
// free( temp );
return false;
}
setVMStatus(VM_RUNNING);
m_cpu_time = 0;
// Delete suspend file
unlink(m_suspendfile.Value());
m_suspendfile = "";
return true;
}