static int
doAttachVolume ( struct nc_state_t *nc,
ncMetadata *meta,
char *instanceId,
char *volumeId,
char *remoteDev,
char *localDev)
{
int ret = OK, rc;
ncInstance * instance;
char localDevReal[32];
virConnectPtr *conn;
struct stat statbuf;
// fix up format of incoming local dev name, if we need to
ret = convert_dev_names (localDev, localDevReal, NULL);
if (ret)
return ret;
sem_p (inst_sem);
instance = find_instance(&global_instances, instanceId);
sem_v (inst_sem);
if ( instance == NULL )
return NOT_FOUND;
/* try attaching to the Xen domain */
conn = check_hypervisor_conn();
if (conn) {
sem_p(hyp_sem);
virDomainPtr dom = virDomainLookupByName(*conn, instanceId);
sem_v(hyp_sem);
if (dom) {
int err = 0;
char xml [1024];
int is_iscsi_target = 0;
char *local_iscsi_dev;
rc = 0;
if(check_iscsi(remoteDev)) {
is_iscsi_target = 1;
/*get credentials, decrypt them*/
//parse_target(remoteDev);
/*login to target*/
local_iscsi_dev = connect_iscsi_target(nc->connect_storage_cmd_path, remoteDev);
if (!local_iscsi_dev || !strstr(local_iscsi_dev, "/dev")) {
logprintfl(EUCAERROR, "AttachVolume(): failed to connect to iscsi target\n");
rc = 1;
} else {
snprintf (xml, 1024, "<disk type='block'><driver name='phy'/><source dev='%s'/><target dev='%s'/></disk>", local_iscsi_dev, localDevReal);
}
} else {
snprintf (xml, 1024, "<disk type='block'><driver name='phy'/><source dev='%s'/><target dev='%s'/></disk>", remoteDev, localDevReal);
rc = stat(remoteDev, &statbuf);
if (rc) {
logprintfl(EUCAERROR, "AttachVolume(): cannot locate local block device file '%s'\n", remoteDev);
rc = 1;
}
}
if (!rc) {
/* protect Xen calls, just in case */
sem_p (hyp_sem);
err = virDomainAttachDevice (dom, xml);
sem_v (hyp_sem);
if (err) {
logprintfl (EUCAERROR, "AttachVolume() failed (err=%d) XML=%s\n", err, xml);
// rc = doDetachVolume(nc, meta, instanceId, volumeId, remoteDev, localDev, 1);
ret = ERROR;
} else {
logprintfl (EUCAINFO, "attached %s to %s in domain %s\n", remoteDev, localDevReal, instanceId);
}
} else {
ret = ERROR;
}
sem_p(hyp_sem);
virDomainFree(dom);
sem_v(hyp_sem);
if(is_iscsi_target) {
if (local_iscsi_dev) free(local_iscsi_dev);
}
} else {
if (instance->state != BOOTING && instance->state != STAGING) {
logprintfl (EUCAWARN, "warning: domain %s not running on hypervisor, cannot attach device\n", instanceId);
}
ret = ERROR;
}
} else {
ret = ERROR;
}
if (ret==OK) {
ncVolume * volume;
sem_p (inst_sem);
volume = add_volume (instance, volumeId, remoteDev, localDevReal, localDevReal, "attached");
scSaveInstanceInfo(instance); /* to enable NC recovery */
sem_v (inst_sem);
if ( volume == NULL ) {
logprintfl (EUCAFATAL, "ERROR: Failed to save the volume record, aborting volume attachment\n");
return ERROR;
}
}
return ret;
}
static int
doDetachVolume ( struct nc_state_t *nc,
ncMetadata *meta,
char *instanceId,
char *volumeId,
char *remoteDev,
char *localDev,
int force)
{
int ret = OK;
ncInstance * instance;
char localDevReal[32];
virConnectPtr *conn;
// fix up format of incoming local dev name, if we need to
ret = convert_dev_names (localDev, localDevReal, NULL);
if (ret)
return ret;
sem_p (inst_sem);
instance = find_instance(&global_instances, instanceId);
sem_v (inst_sem);
if ( instance == NULL )
return NOT_FOUND;
/* try attaching to the Xen domain */
conn = check_hypervisor_conn();
if (conn) {
sem_p(hyp_sem);
virDomainPtr dom = virDomainLookupByName(*conn, instanceId);
sem_v(hyp_sem);
if (dom) {
int err = 0, fd, rc, pid, status;
char xml [1024], tmpfile[32], cmd[MAX_PATH];
FILE *FH;
int is_iscsi_target = 0;
char *local_iscsi_dev;
if(check_iscsi(remoteDev)) {
is_iscsi_target = 1;
/*get credentials, decrypt them*/
//parse_target(remoteDev);
/*logout from target*/
if((local_iscsi_dev = get_iscsi_target(nc->get_storage_cmd_path, remoteDev)) == NULL)
return ERROR;
snprintf (xml, 1024, "<disk type='block'><driver name='phy'/><source dev='%s'/><target dev='%s'/></disk>", local_iscsi_dev, localDevReal);
} else {
snprintf (xml, 1024, "<disk type='block'><driver name='phy'/><source dev='%s'/><target dev='%s'/></disk>", remoteDev, localDevReal);
}
/* protect Xen calls, just in case */
sem_p (hyp_sem);
pid = fork();
if (!pid) {
char cmd[MAX_PATH];
snprintf(tmpfile, 32, "/tmp/detachxml.XXXXXX");
fd = mkstemp(tmpfile);
if (fd > 0) {
write(fd, xml, strlen(xml));
close(fd);
snprintf(cmd, MAX_PATH, "%s %s `which virsh` %s %s %s", nc->detach_cmd_path, nc->rootwrap_cmd_path, instanceId, localDevReal, tmpfile);
rc = system(cmd);
rc = rc>>8;
unlink(tmpfile);
} else {
logprintfl(EUCAERROR, "could not write to tmpfile for detach XML: %s\n", tmpfile);
rc = 1;
}
exit(rc);
} else {
//!
//! Handles the instance migration request.
//!
//! @param[in] nc a pointer to the node controller (NC) state
//! @param[in] pMeta a pointer to the node controller (NC) metadata structure
//! @param[in] instances metadata for the instance to migrate to destination
//! @param[in] instancesLen number of instances in the instance list
//! @param[in] action IP of the destination Node Controller
//! @param[in] credentials credentials that enable the migration
//!
//! @return EUCA_OK on success or EUCA_*ERROR on failure
//!
//! @pre
//!
//! @post
static int doMigrateInstances(struct nc_state_t *nc, ncMetadata * pMeta, ncInstance ** instances, int instancesLen, char *action, char *credentials)
{
int ret = EUCA_OK;
int credentials_prepared = 0;
if (instancesLen <= 0) {
LOGERROR("called with invalid instancesLen (%d)\n", instancesLen);
pMeta->replyString = strdup("internal error (invalid instancesLen)");
return (EUCA_INVALID_ERROR);
}
LOGDEBUG("verifying %d instance[s] for migration...\n", instancesLen);
for (int inst_idx = 0; inst_idx < instancesLen; inst_idx++) {
LOGDEBUG("verifying instance # %d...\n", inst_idx);
if (instances[inst_idx]) {
ncInstance *instance_idx = instances[inst_idx];
LOGDEBUG("[%s] proposed migration action '%s' (%s > %s) [creds=%s]\n", SP(instance_idx->instanceId), SP(action), SP(instance_idx->migration_src),
SP(instance_idx->migration_dst), (instance_idx->migration_credentials == NULL) ? "UNSET" : "present");
} else {
pMeta->replyString = strdup("internal error (instance count mismatch)");
LOGERROR("Mismatch between migration instance count (%d) and length of instance list\n", instancesLen);
return (EUCA_ERROR);
}
}
// TO-DO: Optimize the location of this loop, placing it inside various conditionals below?
for (int inst_idx = 0; inst_idx < instancesLen; inst_idx++) {
ncInstance *instance_req = instances[inst_idx];
char *sourceNodeName = instance_req->migration_src;
char *destNodeName = instance_req->migration_dst;
LOGDEBUG("[%s] processing instance # %d (%s > %s)\n", instance_req->instanceId, inst_idx, instance_req->migration_src, instance_req->migration_dst);
// this is a call to the source of migration
if (!strcmp(pMeta->nodeName, sourceNodeName)) {
// locate the instance structure
ncInstance *instance;
sem_p(inst_sem);
{
instance = find_instance(&global_instances, instance_req->instanceId);
}
sem_v(inst_sem);
if (instance == NULL) {
LOGERROR("[%s] cannot find instance\n", instance_req->instanceId);
pMeta->replyString = strdup("failed to locate instance to migrate");
return (EUCA_NOT_FOUND_ERROR);
}
if (strcmp(action, "prepare") == 0) {
sem_p(inst_sem);
instance->migration_state = MIGRATION_PREPARING;
euca_strncpy(instance->migration_src, sourceNodeName, HOSTNAME_SIZE);
euca_strncpy(instance->migration_dst, destNodeName, HOSTNAME_SIZE);
euca_strncpy(instance->migration_credentials, credentials, CREDENTIAL_SIZE);
instance->migrationTime = time(NULL);
save_instance_struct(instance);
copy_instances();
sem_v(inst_sem);
// Establish migration-credential keys if this is the first instance preparation for this host.
LOGINFO("[%s] migration source preparing %s > %s [creds=%s]\n", SP(instance->instanceId), SP(instance->migration_src), SP(instance->migration_dst),
(instance->migration_credentials == NULL) ? "UNSET" : "present");
if (!credentials_prepared) {
if (generate_migration_keys(sourceNodeName, credentials, TRUE, instance) != EUCA_OK) {
pMeta->replyString = strdup("internal error (migration credentials generation failed)");
return (EUCA_SYSTEM_ERROR);
} else {
credentials_prepared++;
}
}
sem_p(inst_sem);
instance->migration_state = MIGRATION_READY;
save_instance_struct(instance);
copy_instances();
sem_v(inst_sem);
} else if (strcmp(action, "commit") == 0) {
sem_p(inst_sem);
if (instance->migration_state == MIGRATION_IN_PROGRESS) {
LOGWARN("[%s] duplicate request to migration source to initiate %s > %s (already migrating)\n", instance->instanceId,
instance->migration_src, instance->migration_dst);
sem_v(inst_sem);
return (EUCA_DUPLICATE_ERROR);
} else if (instance->migration_state != MIGRATION_READY) {
LOGERROR("[%s] request to commit migration %s > %s when source migration_state='%s' (not 'ready')\n", instance->instanceId,
SP(sourceNodeName), SP(destNodeName), migration_state_names[instance->migration_state]);
sem_v(inst_sem);
return (EUCA_UNSUPPORTED_ERROR);
}
instance->migration_state = MIGRATION_IN_PROGRESS;
outgoing_migrations_in_progress++;
LOGINFO("[%s] migration source initiating %s > %s [creds=%s] (1 of %d active outgoing migrations)\n", instance->instanceId, instance->migration_src,
instance->migration_dst, (instance->migration_credentials == NULL) ? "UNSET" : "present", outgoing_migrations_in_progress);
save_instance_struct(instance);
copy_instances();
sem_v(inst_sem);
// since migration may take a while, we do them in a thread
pthread_t tcb = { 0 };
if (pthread_create(&tcb, NULL, migrating_thread, (void *)instance)) {
LOGERROR("[%s] failed to spawn a migration thread\n", instance->instanceId);
return (EUCA_THREAD_ERROR);
}
set_corrid_pthread( get_corrid()!=NULL ? get_corrid()->correlation_id : NULL , tcb);
if (pthread_detach(tcb)) {
LOGERROR("[%s] failed to detach the migration thread\n", instance->instanceId);
return (EUCA_THREAD_ERROR);
}
} else if (strcmp(action, "rollback") == 0) {
if ((instance->migration_state == MIGRATION_READY) || (instance->migration_state == MIGRATION_PREPARING)) {
LOGINFO("[%s] rolling back migration (%s > %s) on source\n", instance->instanceId, instance->migration_src, instance->migration_dst);
sem_p(inst_sem);
migration_rollback(instance);
sem_v(inst_sem);
} else {
LOGINFO("[%s] ignoring request to roll back migration on source with instance in state %s(%s) -- duplicate rollback request?\n", instance->instanceId,
instance->stateName, migration_state_names[instance->migration_state]);
}
} else {
LOGERROR("[%s] action '%s' is not valid\n", instance->instanceId, action);
return (EUCA_INVALID_ERROR);
}
} else if (!strcmp(pMeta->nodeName, destNodeName)) { // this is a migrate request to destination
if (!strcmp(action, "commit")) {
LOGERROR("[%s] action '%s' for migration (%s > %s) is not valid on destination node\n", instance_req->instanceId, action, SP(sourceNodeName), SP(destNodeName));
return (EUCA_UNSUPPORTED_ERROR);
} else if (!strcmp(action, "rollback")) {
LOGINFO("[%s] rolling back migration (%s > %s) on destination\n", instance_req->instanceId, SP(sourceNodeName), SP(destNodeName));
sem_p(inst_sem);
{
ncInstance *instance = find_instance(&global_instances, instance_req->instanceId);
if (instance != NULL) {
LOGDEBUG("[%s] marked for cleanup\n", instance->instanceId);
change_state(instance, SHUTOFF);
instance->migration_state = MIGRATION_CLEANING;
save_instance_struct(instance);
}
}
sem_v(inst_sem);
return EUCA_OK;
} else if (strcmp(action, "prepare") != 0) {
LOGERROR("[%s] action '%s' is not valid or not implemented\n", instance_req->instanceId, action);
return (EUCA_INVALID_ERROR);
}
// Everything from here on is specific to "prepare" on a destination.
// allocate a new instance struct
ncInstance *instance = clone_instance(instance_req);
if (instance == NULL) {
LOGERROR("[%s] could not allocate instance struct\n", instance_req->instanceId);
goto failed_dest;
}
sem_p(inst_sem);
instance->migration_state = MIGRATION_PREPARING;
euca_strncpy(instance->migration_src, sourceNodeName, HOSTNAME_SIZE);
euca_strncpy(instance->migration_dst, destNodeName, HOSTNAME_SIZE);
euca_strncpy(instance->migration_credentials, credentials, CREDENTIAL_SIZE);
save_instance_struct(instance);
sem_v(inst_sem);
// Establish migration-credential keys.
LOGINFO("[%s] migration destination preparing %s > %s [creds=%s]\n", instance->instanceId, SP(instance->migration_src), SP(instance->migration_dst),
(instance->migration_credentials == NULL) ? "UNSET" : "present");
// First, call config-file modification script to authorize source node.
LOGDEBUG("[%s] authorizing migration source node %s\n", instance->instanceId, instance->migration_src);
if (authorize_migration_keys("-a", instance->migration_src, instance->migration_credentials, instance, TRUE) != EUCA_OK) {
goto failed_dest;
}
// Then, generate keys and restart libvirtd.
if (generate_migration_keys(instance->migration_dst, instance->migration_credentials, TRUE, instance) != EUCA_OK) {
goto failed_dest;
}
int error;
if (vbr_parse(&(instance->params), pMeta) != EUCA_OK) {
goto failed_dest;
}
// set up networking
char *brname = NULL;
if ((error = vnetStartNetwork(nc->vnetconfig, instance->ncnet.vlan, NULL, NULL, NULL, &brname)) != EUCA_OK) {
LOGERROR("[%s] start network failed for instance, terminating it\n", instance->instanceId);
EUCA_FREE(brname);
goto failed_dest;
}
euca_strncpy(instance->params.guestNicDeviceName, brname, sizeof(instance->params.guestNicDeviceName));
EUCA_FREE(brname);
// TODO: move stuff in startup_thread() into a function?
set_instance_params(instance);
if ((error = create_instance_backing(instance, TRUE)) // create files that back the disks
|| (error = gen_instance_xml(instance)) // create euca-specific instance XML file
|| (error = gen_libvirt_instance_xml(instance))) { // transform euca-specific XML into libvirt XML
LOGERROR("[%s] failed to prepare images for migrating instance (error=%d)\n", instance->instanceId, error);
goto failed_dest;
}
// attach any volumes
for (int v = 0; v < EUCA_MAX_VOLUMES; v++) {
ncVolume *volume = &instance->volumes[v];
if (strcmp(volume->stateName, VOL_STATE_ATTACHED) && strcmp(volume->stateName, VOL_STATE_ATTACHING))
continue; // skip the entry unless attached or attaching
LOGDEBUG("[%s] volumes [%d] = '%s'\n", instance->instanceId, v, volume->stateName);
// TODO: factor what the following out of here and doAttachVolume() in handlers_default.c
int have_remote_device = 0;
char *xml = NULL;
char *remoteDevStr = NULL;
char scUrl[512];
char localDevReal[32], localDevTag[256], remoteDevReal[132];
char *tagBuf = localDevTag;
ebs_volume_data *vol_data = NULL;
ret = convert_dev_names(volume->localDev, localDevReal, tagBuf);
if (ret)
goto unroll;
//Do the ebs connect.
LOGTRACE("[%s][%s] Connecting EBS volume to local host\n", instance->instanceId, volume->volumeId);
get_service_url("storage", nc, scUrl);
if (strlen(scUrl) == 0) {
LOGERROR("[%s][%s] Failed to lookup enabled Storage Controller. Cannot attach volume %s\n", instance->instanceId, volume->volumeId, scUrl);
have_remote_device = 0;
goto unroll;
} else {
LOGTRACE("[%s][%s] Using SC URL: %s\n", instance->instanceId, volume->volumeId, scUrl);
}
//Do the ebs connect.
LOGTRACE("[%s][%s] Connecting EBS volume to local host\n", instance->instanceId, volume->volumeId);
int rc = connect_ebs_volume(scUrl, volume->attachmentToken, nc->config_use_ws_sec, nc->config_sc_policy_file, nc->ip, nc->iqn, &remoteDevStr, &vol_data);
if (rc) {
LOGERROR("Error connecting ebs volume %s\n", volume->attachmentToken);
have_remote_device = 0;
ret = EUCA_ERROR;
goto unroll;
}
// update the volume struct with connection string obtained from SC
euca_strncpy(volume->connectionString, vol_data->connect_string, sizeof(volume->connectionString));
if (!remoteDevStr || !strstr(remoteDevStr, "/dev")) {
LOGERROR("[%s][%s] failed to connect to iscsi target\n", instance->instanceId, volume->volumeId);
remoteDevReal[0] = '\0';
} else {
LOGDEBUG("[%s][%s] attached iSCSI target of host device '%s'\n", instance->instanceId, volume->volumeId, remoteDevStr);
snprintf(remoteDevReal, sizeof(remoteDevReal), "%s", remoteDevStr);
have_remote_device = 1;
}
EUCA_FREE(remoteDevStr);
// something went wrong above, abort
if (!have_remote_device) {
goto unroll;
}
// make sure there is a block device
if (check_block(remoteDevReal)) {
LOGERROR("[%s][%s] cannot verify that host device '%s' is available for hypervisor attach\n", instance->instanceId, volume->volumeId, remoteDevReal);
goto unroll;
}
// generate XML for libvirt attachment request
if (gen_volume_xml(volume->volumeId, instance, localDevReal, remoteDevReal) // creates vol-XXX.xml
|| gen_libvirt_volume_xml(volume->volumeId, instance)) { // creates vol-XXX-libvirt.xml via XSLT transform
LOGERROR("[%s][%s] could not produce attach device xml\n", instance->instanceId, volume->volumeId);
goto unroll;
}
// invoke hooks
char path[EUCA_MAX_PATH];
char lpath[EUCA_MAX_PATH];
snprintf(path, sizeof(path), EUCALYPTUS_VOLUME_XML_PATH_FORMAT, instance->instancePath, volume->volumeId); // vol-XXX.xml
snprintf(lpath, sizeof(lpath), EUCALYPTUS_VOLUME_LIBVIRT_XML_PATH_FORMAT, instance->instancePath, volume->volumeId); // vol-XXX-libvirt.xml
if (call_hooks(NC_EVENT_PRE_ATTACH, lpath)) {
LOGERROR("[%s][%s] cancelled volume attachment via hooks\n", instance->instanceId, volume->volumeId);
goto unroll;
}
// read in libvirt XML, which may have been modified by the hook above
if ((xml = file2str(lpath)) == NULL) {
LOGERROR("[%s][%s] failed to read volume XML from %s\n", instance->instanceId, volume->volumeId, lpath);
goto unroll;
}
continue;
unroll:
ret = EUCA_ERROR;
// TODO: unroll all volume attachments
goto failed_dest;
}
sem_p(inst_sem);
instance->migration_state = MIGRATION_READY;
instance->bootTime = time(NULL); // otherwise nc_state.booting_cleanup_threshold will kick in
change_state(instance, BOOTING); // not STAGING, since in that mode we don't poll hypervisor for info
LOGINFO("[%s] migration destination ready %s > %s\n", instance->instanceId, instance->migration_src, instance->migration_dst);
save_instance_struct(instance);
error = add_instance(&global_instances, instance);
copy_instances();
sem_v(inst_sem);
if (error) {
if (error == EUCA_DUPLICATE_ERROR) {
LOGINFO("[%s] instance struct already exists (from previous migration?), deleting and re-adding...\n", instance->instanceId);
error = remove_instance(&global_instances, instance);
if (error) {
LOGERROR("[%s] could not replace (remove) instance struct, failing...\n", instance->instanceId);
goto failed_dest;
}
error = add_instance(&global_instances, instance);
if (error) {
LOGERROR("[%s] could not replace (add) instance struct, failing...\n", instance->instanceId);
goto failed_dest;
}
} else {
LOGERROR("[%s] could not add instance struct, failing...\n", instance->instanceId);
goto failed_dest;
}
}
continue;
failed_dest:
sem_p(inst_sem);
// Just making sure...
if (instance != NULL) {
LOGERROR("[%s] setting instance to Teardown(cleaning) after destination failure to prepare for migration\n", instance->instanceId);
// Set state to Teardown(cleaning) so source won't wait until timeout to roll back.
instance->migration_state = MIGRATION_CLEANING;
instance->terminationTime = time(NULL);
change_state(instance, TEARDOWN);
save_instance_struct(instance);
add_instance(&global_instances, instance); // OK if this fails--that should mean it's already been added.
copy_instances();
}
// If no remaining incoming or pending migrations, deauthorize all clients.
// TO-DO: Consolidate with similar sequence in handlers.c into a utility function?
if (!incoming_migrations_in_progress) {
int incoming_migrations_pending = 0;
LOGINFO("[%s] no remaining active incoming migrations -- checking to see if there are any pending migrations\n", instance->instanceId);
bunchOfInstances *head = NULL;
for (head = global_instances; head; head = head->next) {
if ((head->instance->migration_state == MIGRATION_PREPARING) || (head->instance->migration_state == MIGRATION_READY)) {
LOGINFO("[%s] is pending migration, state='%s', deferring deauthorization of migration keys\n", head->instance->instanceId,
migration_state_names[head->instance->migration_state]);
incoming_migrations_pending++;
}
}
// TO-DO: Add belt and suspenders?
if (!incoming_migrations_pending) {
LOGINFO("[%s] no remaining incoming or pending migrations -- deauthorizing all migration client keys\n", instance->instanceId);
authorize_migration_keys("-D -r", NULL, NULL, NULL, FALSE);
}
}
sem_v(inst_sem);
// Set to generic EUCA_ERROR unless already set to a more-specific error.
if (ret == EUCA_OK) {
ret = EUCA_ERROR;
}
} else {
LOGERROR("unexpected migration request (node %s is neither source nor destination)\n", pMeta->nodeName);
ret = EUCA_ERROR;
}
}
return ret;
}