// helper function used by RunInstance and DescribeInstances
static void copy_instance_to_adb (adb_instanceType_t * instance, const axutil_env_t *env, ncInstance * outInst)
{
// NOTE: the order of set operations reflects the order in the WSDL
// passed into runInstances
adb_instanceType_set_reservationId(instance, env, outInst->reservationId);
adb_instanceType_set_instanceId(instance, env, outInst->instanceId);
adb_instanceType_set_imageId(instance, env, outInst->imageId);
adb_instanceType_set_kernelId(instance, env, outInst->kernelId);
adb_instanceType_set_ramdiskId(instance, env, outInst->ramdiskId);
adb_instanceType_set_userId(instance, env, outInst->userId);
adb_instanceType_set_keyName(instance, env, outInst->keyName);
adb_instanceType_set_instanceType(instance, env, copy_vm_type_to_adb (env, &(outInst->params)));
adb_netConfigType_t * netconf = adb_netConfigType_create(env);
adb_netConfigType_set_privateMacAddress(netconf, env, outInst->ncnet.privateMac);
adb_netConfigType_set_privateIp(netconf, env, outInst->ncnet.privateIp);
adb_netConfigType_set_publicIp(netconf, env, outInst->ncnet.publicIp);
adb_netConfigType_set_vlan(netconf, env, outInst->ncnet.vlan);
adb_netConfigType_set_networkIndex(netconf, env, outInst->ncnet.networkIndex);
adb_instanceType_set_netParams(instance, env, netconf);
// reported by NC
adb_instanceType_set_stateName(instance, env, outInst->stateName);
axutil_date_time_t * dt = axutil_date_time_create_with_offset(env, outInst->launchTime - time(NULL));
adb_instanceType_set_launchTime(instance, env, dt);
// passed into RunInstances for safekeeping by NC
adb_instanceType_set_userData(instance, env, outInst->userData);
adb_instanceType_set_launchIndex(instance, env, outInst->launchIndex);
int i;
for (i=0; i<outInst->groupNamesSize; i++) {
adb_instanceType_add_groupNames(instance, env, outInst->groupNames[i]);
}
// updated by NC upon Attach/DetachVolume
for (i=0; i<outInst->volumesSize; i++) {
adb_volumeType_t * volume = adb_volumeType_create(env);
adb_volumeType_set_volumeId(volume, env, outInst->volumes[i].volumeId);
adb_volumeType_set_remoteDev(volume, env, outInst->volumes[i].remoteDev);
adb_volumeType_set_localDev(volume, env, outInst->volumes[i].localDev);
adb_volumeType_set_state(volume, env, outInst->volumes[i].stateName);
adb_instanceType_add_volumes(instance, env, volume);
}
// NOTE: serviceTag seen in the WSDL is unused in NC, used by CC
}
int ncRunInstanceStub (ncStub *st, ncMetadata *meta, char *instanceId, char *reservationId, virtualMachine *params, char *imageId, char *imageURL, char *kernelId, char *kernelURL, char *ramdiskId, char *ramdiskURL, char *keyName, netConfig *netparams, char *userData, char *launchIndex, char **groupNames, int groupNamesSize, ncInstance **outInstPtr)
{
int i;
axutil_env_t * env = st->env;
axis2_stub_t * stub = st->stub;
adb_ncRunInstance_t * input = adb_ncRunInstance_create(env);
adb_ncRunInstanceType_t * request = adb_ncRunInstanceType_create(env);
// set standard input fields
adb_ncRunInstanceType_set_nodeName(request, env, st->node_name);
if (meta) {
adb_ncRunInstanceType_set_correlationId(request, env, CORRELATION_ID);
adb_ncRunInstanceType_set_userId(request, env, meta->userId);
}
// set op-specific input fields
adb_ncRunInstanceType_set_instanceId(request, env, instanceId);
adb_ncRunInstanceType_set_reservationId(request, env, reservationId);
adb_ncRunInstanceType_set_instanceType(request, env, copy_vm_type_to_adb(env, params));
adb_ncRunInstanceType_set_imageId(request, env, imageId);
adb_ncRunInstanceType_set_imageURL(request, env, imageURL);
adb_ncRunInstanceType_set_kernelId(request, env, kernelId);
adb_ncRunInstanceType_set_kernelURL(request, env, kernelURL);
adb_ncRunInstanceType_set_ramdiskId(request, env, ramdiskId);
adb_ncRunInstanceType_set_ramdiskURL(request, env, ramdiskURL);
adb_ncRunInstanceType_set_keyName(request, env, keyName);
adb_netConfigType_t *netConfig = adb_netConfigType_create(env);
adb_netConfigType_set_privateMacAddress(netConfig, env, netparams->privateMac);
adb_netConfigType_set_privateIp(netConfig, env, netparams->privateIp);
adb_netConfigType_set_publicIp(netConfig, env, netparams->publicIp);
adb_netConfigType_set_vlan(netConfig, env, netparams->vlan);
adb_netConfigType_set_networkIndex(netConfig, env, netparams->networkIndex);
adb_ncRunInstanceType_set_netParams(request, env, netConfig);
// adb_ncRunInstanceType_set_privateMacAddress(request, env, privMac);
// adb_ncRunInstanceType_set_privateIp(request, env, privIp);
// adb_ncRunInstanceType_set_vlan(request, env, vlan);
adb_ncRunInstanceType_set_userData(request, env, userData);
adb_ncRunInstanceType_set_launchIndex(request, env, launchIndex);
for (i=0; i<groupNamesSize; i++) {
adb_ncRunInstanceType_add_groupNames(request, env, groupNames[i]);
}
adb_ncRunInstance_set_ncRunInstance(input, env, request);
int status = 0;
{ // do it
adb_ncRunInstanceResponse_t * output = axis2_stub_op_EucalyptusNC_ncRunInstance(stub, env, input);
if (!output) {
logprintfl (EUCAERROR, "ERROR: RunInstance" NULL_ERROR_MSG);
status = -1;
} else {
adb_ncRunInstanceResponseType_t * response = adb_ncRunInstanceResponse_get_ncRunInstanceResponse(output, env);
if ( adb_ncRunInstanceResponseType_get_return(response, env) == AXIS2_FALSE ) {
logprintfl (EUCAERROR, "ERROR: RunInstance returned an error\n");
status = 1;
}
adb_instanceType_t * instance = adb_ncRunInstanceResponseType_get_instance(response, env);
* outInstPtr = copy_instance_from_adb (instance, env);
}
}
return status;
}
int ccInstanceUnmarshal(adb_ccInstanceType_t *dst, ccInstance *src, const axutil_env_t *env) {
axutil_date_time_t *dt=NULL;
adb_virtualMachineType_t *vm=NULL;
adb_netConfigType_t *netconf=NULL;
adb_volumeType_t *vol=NULL;
int i;
dt = axutil_date_time_create_with_offset(env, src->ts - time(NULL));
adb_ccInstanceType_set_instanceId(dst, env, src->instanceId);
adb_ccInstanceType_set_uuid(dst, env, src->uuid);
adb_ccInstanceType_set_reservationId(dst, env, src->reservationId);
adb_ccInstanceType_set_ownerId(dst, env, src->ownerId);
adb_ccInstanceType_set_accountId(dst, env, src->accountId);
adb_ccInstanceType_set_imageId(dst, env, src->amiId);
adb_ccInstanceType_set_kernelId(dst, env, src->kernelId);
adb_ccInstanceType_set_ramdiskId(dst, env, src->ramdiskId);
adb_ccInstanceType_set_keyName(dst, env, src->keyName);
adb_ccInstanceType_set_stateName(dst, env, src->state);
adb_ccInstanceType_set_launchTime(dst, env, dt);
adb_ccInstanceType_set_serviceTag(dst, env, src->serviceTag);
adb_ccInstanceType_set_userData(dst, env, src->userData);
adb_ccInstanceType_set_launchIndex(dst, env, src->launchIndex);
if (strlen(src->platform)) {
adb_ccInstanceType_set_platform(dst, env, src->platform);
}
if (strlen(src->bundleTaskStateName)) {
adb_ccInstanceType_set_bundleTaskStateName(dst, env, src->bundleTaskStateName);
}
adb_ccInstanceType_set_blkbytes(dst, env, src->blkbytes);
adb_ccInstanceType_set_netbytes(dst, env, src->netbytes);
for (i=0; i<64; i++) {
if (src->groupNames[i][0] != '\0') {
adb_ccInstanceType_add_groupNames(dst, env, src->groupNames[i]);
}
}
for (i=0; i<src->volumesSize; i++) {
vol = adb_volumeType_create(env);
adb_volumeType_set_volumeId(vol, env, src->volumes[i].volumeId);
adb_volumeType_set_remoteDev(vol, env, src->volumes[i].remoteDev);
adb_volumeType_set_localDev(vol, env, src->volumes[i].localDev);
adb_volumeType_set_state(vol, env, src->volumes[i].stateName);
adb_ccInstanceType_add_volumes(dst, env, vol);
}
netconf = adb_netConfigType_create(env);
adb_netConfigType_set_privateMacAddress(netconf, env, src->ccnet.privateMac);
adb_netConfigType_set_privateIp(netconf, env, src->ccnet.privateIp);
adb_netConfigType_set_publicIp(netconf, env, src->ccnet.publicIp);
adb_netConfigType_set_vlan(netconf, env, src->ccnet.vlan);
adb_netConfigType_set_networkIndex(netconf, env, src->ccnet.networkIndex);
adb_ccInstanceType_set_netParams(dst, env, netconf);
vm = copy_vm_type_to_adb (env, &(src->ccvm));
adb_virtualMachineType_set_name(vm, env, src->ccvm.name);
adb_ccInstanceType_set_instanceType(dst, env, vm);
return(0);
}
