/* Fill in a PROC structure given a job ClassAd. This function replaces
GetProc from qmgr_lib_support.C, so we just get the job classad once
from the schedd and fill in the PROC structure directly. */
int
MakeProc(ClassAd *ad, PROC *p)
{
char buf[ATTRLIST_MAX_EXPRESSION];
float utime,stime;
ExprTree *e;
p->version_num = 3;
ad->LookupInteger(ATTR_CLUSTER_ID, p->id.cluster);
ad->LookupInteger(ATTR_PROC_ID, p->id.proc);
ad->LookupInteger(ATTR_JOB_UNIVERSE, p->universe);
ad->LookupInteger(ATTR_WANT_CHECKPOINT, p->checkpoint);
ad->LookupInteger(ATTR_WANT_REMOTE_SYSCALLS, p->remote_syscalls);
ad->LookupString(ATTR_OWNER, buf);
p->owner = strdup(buf);
ad->LookupInteger(ATTR_Q_DATE, p->q_date);
ad->LookupInteger(ATTR_COMPLETION_DATE, p->completion_date);
ad->LookupInteger(ATTR_JOB_STATUS, p->status);
ad->LookupInteger(ATTR_JOB_PRIO, p->prio);
ad->LookupInteger(ATTR_JOB_NOTIFICATION, p->notification);
ad->LookupInteger(ATTR_IMAGE_SIZE, p->image_size);
// There are two different syntaxes for the environment. Since
// the wire protocol only expects one, we pack either one into the
// same proc variable "env_v1or2" and make sure they are
// distinguishable. For backward compatibility, the schedd
// will have already ensured that we use V1 syntax if the
// remote side only understands that.
Env envobj;
MyString env_v1or2;
MyString env_error_msg;
if(!envobj.getDelimitedStringV1or2Raw(ad,&env_v1or2,&env_error_msg)) {
EXCEPT("Failed to parse environment string: %s\n",
env_error_msg.Value());
}
p->env_v1or2 = strdup(env_v1or2.Value());
p->n_cmds = 1;
p->cmd = (char **) malloc(p->n_cmds * sizeof(char *));
p->args_v1or2 = (char **) malloc(p->n_cmds * sizeof(char *));
p->in = (char **) malloc(p->n_cmds * sizeof(char *));
p->out = (char **) malloc(p->n_cmds * sizeof(char *));
p->err = (char **) malloc(p->n_cmds * sizeof(char *));
p->exit_status = (int *) malloc(p->n_cmds * sizeof(int));
// There are two different syntaxes for arguments. Since
// the wire protocol only expects one, we pack either one into the
// same proc variable "env_v1or2" and make sure they are
// distinguishable. For backward compatibility, the schedd
// will have already ensured that we use V1 syntax if the
// remote side only understands that.
ArgList args;
MyString args_v1or2;
MyString error_msg;
if(!args.GetArgsStringV1or2Raw(ad,&args_v1or2,&error_msg)) {
EXCEPT("Failed to get V1or2 arguments string: %s\n",error_msg.Value());
}
p->args_v1or2[0] = strdup(args_v1or2.Value());
ad->LookupString(ATTR_JOB_CMD, buf);
p->cmd[0] = strdup(buf);
ad->LookupString(ATTR_JOB_INPUT, buf);
p->in[0] = strdup(buf);
ad->LookupString(ATTR_JOB_OUTPUT, buf);
p->out[0] = strdup(buf);
ad->LookupString(ATTR_JOB_ERROR, buf);
p->err[0] = strdup(buf);
ad->LookupInteger(ATTR_JOB_EXIT_STATUS, p->exit_status[0]);
ad->LookupInteger(ATTR_MIN_HOSTS, p->min_needed);
ad->LookupInteger(ATTR_MAX_HOSTS, p->max_needed);
ad->LookupString(ATTR_JOB_ROOT_DIR, buf);
p->rootdir = strdup(buf);
ad->LookupString(ATTR_JOB_IWD, buf);
p->iwd = strdup(buf);
e = ad->LookupExpr(ATTR_REQUIREMENTS);
if (e) {
p->requirements = strdup(ExprTreeToString(e));
} else {
p->requirements = NULL;
}
e = ad->LookupExpr(ATTR_RANK);
if (e) {
p->preferences = strdup(ExprTreeToString(e));
} else {
p->preferences = NULL;
}
ad->LookupFloat(ATTR_JOB_LOCAL_USER_CPU, utime);
ad->LookupFloat(ATTR_JOB_LOCAL_SYS_CPU, stime);
float_to_rusage(utime, stime, &(p->local_usage));
p->remote_usage = (struct rusage *) malloc(p->n_cmds *
sizeof(struct rusage));
memset(p->remote_usage, 0, sizeof( struct rusage ));
ad->LookupFloat(ATTR_JOB_REMOTE_USER_CPU, utime);
ad->LookupFloat(ATTR_JOB_REMOTE_SYS_CPU, stime);
float_to_rusage(utime, stime, &(p->remote_usage[0]));
return 0;
}
bool
VMType::parseCommonParamFromClassAd(bool /* is_root false*/)
{
// Read common parameters for vm
m_result_msg = "";
// Read the amount of memory for VM
if( m_classAd.LookupInteger( ATTR_JOB_VM_MEMORY, m_vm_mem) != 1 ) {
vmprintf(D_ALWAYS, "%s cannot be found in job classAd\n",
ATTR_JOB_VM_MEMORY);
m_result_msg = VMGAHP_ERR_JOBCLASSAD_NO_VM_MEMORY_PARAM;
return false;
}else {
// Requested memory should not be larger than the maximum allowed memory
if( ( m_vm_mem <= 0 ) ||
(m_vm_mem > vmgahp->m_gahp_config->m_vm_max_memory) ) {
m_result_msg = VMGAHP_ERR_JOBCLASSAD_TOO_MUCH_MEMORY_REQUEST;
return false;
}
}
vmprintf(D_FULLDEBUG, "Memory: %d\n", m_vm_mem);
vmprintf(D_FULLDEBUG, "Looking up number of vcpus.\n");
// Read the number of vcpus
if( m_classAd.LookupInteger( ATTR_JOB_VM_VCPUS, m_vcpus) != 1) {
vmprintf(D_FULLDEBUG, "No VCPUS defined or VCPUS definition is bad.\n");
}
if(m_vcpus < 1) m_vcpus = 1;
vmprintf(D_FULLDEBUG, "Setting up %d CPUS\n", m_vcpus);
// Read parameter for networking
m_vm_networking = false;
m_classAd.LookupBool( ATTR_JOB_VM_NETWORKING, m_vm_networking);
if( m_vm_networking &&
(vmgahp->m_gahp_config->m_vm_networking == false ) ) {
vmprintf(D_ALWAYS, "A job requests networking but "
"the gahp server doesn't support networking\n");
m_result_msg = VMGAHP_ERR_JOBCLASSAD_MISMATCHED_NETWORKING;
return false;
}
if( m_vm_networking ) {
// Read parameter for networking types
if( m_classAd.LookupString( ATTR_JOB_VM_NETWORKING_TYPE,
m_vm_networking_type) == 1 ) {
// vm_networking_type is defined
// change string to lowercase
m_vm_networking_type.trim();
m_vm_networking_type.lower_case();
if( vmgahp->m_gahp_config->m_vm_networking_types.contains(m_vm_networking_type.Value()) == false ) {
vmprintf(D_ALWAYS, "Networking type(%s) is not supported by "
"this gahp server\n", m_vm_networking_type.Value());
m_result_msg = VMGAHP_ERR_JOBCLASSAD_MISMATCHED_NETWORKING_TYPE;
return false;
}
}else {
// vm_networking_type is undefined
if( vmgahp->m_gahp_config->m_vm_default_networking_type.IsEmpty() == false ) {
m_vm_networking_type = vmgahp->m_gahp_config->m_vm_default_networking_type;
}else {
m_vm_networking_type = "nat";
}
}
if(m_classAd.LookupString( ATTR_JOB_VM_MACADDR, m_vm_job_mac) != 1)
{
vmprintf(D_FULLDEBUG, "MAC address was not defined.\n");
}
}
// Read parameter for checkpoint
m_vm_checkpoint = false;
m_classAd.LookupBool(ATTR_JOB_VM_CHECKPOINT, m_vm_checkpoint);
if( VMType::createVMName(&m_classAd, m_vm_name) == false ) {
m_result_msg = VMGAHP_ERR_CRITICAL;
return false;
}
// Insert vm_name to classAd for future use
m_classAd.Assign("VMPARAM_VM_NAME", m_vm_name);
// Read the parameter of hardware VT
m_vm_hardware_vt = false;
m_classAd.LookupBool(ATTR_JOB_VM_HARDWARE_VT, m_vm_hardware_vt);
if( m_vm_hardware_vt &&
(vmgahp->m_gahp_config->m_vm_hardware_vt == false ) ) {
vmprintf(D_ALWAYS, "A job requests hardware virtualization but "
"the vmgahp server doesn't support hardware VT\n");
m_result_msg = VMGAHP_ERR_JOBCLASSAD_MISMATCHED_HARDWARE_VT;
return false;
}
// Read the parameter of vm_no_output_vm
// This parameter is an experiment parameter
// When this parameter is TRUE, Condor will not transfer
// all files for VM back to a job user.
// This parameter would be used if a job user uses explict method
// to get output files from VM.
// For example, if a job user uses a ftp program
// to send output files inside VM to his/her dedicated machine for ouput,
// the job user doesn't want to get modified VM disk files back.
// So the job user can use this parameter
m_vm_no_output_vm = false;
m_classAd.LookupBool(VMPARAM_NO_OUTPUT_VM, m_vm_no_output_vm);
m_classad_arg = "";
ArgList arglist;
MyString error_msg;
if(!arglist.GetArgsStringV1or2Raw(&m_classAd, &m_classad_arg, &error_msg)) {
m_classad_arg = "";
}
if( m_classad_arg.IsEmpty() == false ) {
// Create a file for arguments
FILE *argfile_fp = safe_fopen_wrapper_follow(VM_UNIV_ARGUMENT_FILE, "w");
if( !argfile_fp ) {
vmprintf(D_ALWAYS, "failed to safe_fopen_wrapper the file "
"for arguments: safe_fopen_wrapper_follow(%s) returns %s\n",
VM_UNIV_ARGUMENT_FILE, strerror(errno));
m_result_msg = VMGAHP_ERR_CANNOT_CREATE_ARG_FILE;
return false;
}
if( fprintf(argfile_fp, "%s", m_classad_arg.Value()) < 0) {
fclose(argfile_fp);
IGNORE_RETURN unlink(VM_UNIV_ARGUMENT_FILE);
vmprintf(D_ALWAYS, "failed to fprintf in CreateConfigFile(%s:%s)\n",
VM_UNIV_ARGUMENT_FILE, strerror(errno));
m_result_msg = VMGAHP_ERR_CANNOT_CREATE_ARG_FILE;
return false;
}
fclose(argfile_fp);
//??
m_arg_file.formatstr("%s%c%s", m_workingpath.Value(),
DIR_DELIM_CHAR, VM_UNIV_ARGUMENT_FILE);
}
return true;
}
