adb_ncRunInstanceResponse_t* ncRunInstanceMarshal (adb_ncRunInstance_t* ncRunInstance, const axutil_env_t *env)
{
pthread_mutex_lock(&ncHandlerLock);
adb_ncRunInstanceType_t * input = adb_ncRunInstance_get_ncRunInstance(ncRunInstance, env);
adb_ncRunInstanceResponse_t * response = adb_ncRunInstanceResponse_create(env);
adb_ncRunInstanceResponseType_t * output = adb_ncRunInstanceResponseType_create(env);
// get standard fields from input
axis2_char_t * correlationId = adb_ncRunInstanceType_get_correlationId(input, env);
axis2_char_t * userId = adb_ncRunInstanceType_get_userId(input, env);
// get operation-specific fields from input
axis2_char_t * instanceId = adb_ncRunInstanceType_get_instanceId(input, env);
axis2_char_t * reservationId = adb_ncRunInstanceType_get_reservationId(input, env);
virtualMachine params;
copy_vm_type_from_adb (¶ms, adb_ncRunInstanceType_get_instanceType(input, env), env);
axis2_char_t * imageId = adb_ncRunInstanceType_get_imageId(input, env);
axis2_char_t * imageURL = adb_ncRunInstanceType_get_imageURL(input, env);
axis2_char_t * kernelId = adb_ncRunInstanceType_get_kernelId(input, env);
axis2_char_t * kernelURL = adb_ncRunInstanceType_get_kernelURL(input, env);
axis2_char_t * ramdiskId = adb_ncRunInstanceType_get_ramdiskId(input, env);
axis2_char_t * ramdiskURL = adb_ncRunInstanceType_get_ramdiskURL(input, env);
axis2_char_t * keyName = adb_ncRunInstanceType_get_keyName(input, env);
adb_netConfigType_t *net_type = adb_ncRunInstanceType_get_netParams(input, env);
netConfig netparams;
netparams.vlan = adb_netConfigType_get_vlan(net_type, env);
netparams.networkIndex = adb_netConfigType_get_networkIndex(net_type, env);
snprintf(netparams.privateMac, 24, "%s", adb_netConfigType_get_privateMacAddress(net_type, env));
snprintf(netparams.privateIp, 24, "%s", adb_netConfigType_get_privateIp(net_type, env));
snprintf(netparams.publicIp, 24, "%s", adb_netConfigType_get_publicIp(net_type, env));
axis2_char_t * userData = adb_ncRunInstanceType_get_userData(input, env);
axis2_char_t * launchIndex = adb_ncRunInstanceType_get_launchIndex(input, env);
int groupNamesSize = adb_ncRunInstanceType_sizeof_groupNames(input, env);
char ** groupNames = calloc (groupNamesSize, sizeof(char *));
if (groupNames==NULL) {
logprintfl (EUCAERROR, "ERROR: out of memory in ncRunInstancesMarshall()\n");
adb_ncRunInstanceResponseType_set_return(output, env, AXIS2_FALSE);
} else {
int i;
for (i=0; i<groupNamesSize; i++) {
groupNames[i] = adb_ncRunInstanceType_get_groupNames_at(input, env, i);
}
{ // log event
char other[256];
snprintf(other, 256, "begin,%s", reservationId);
eventlog("NC", userId, correlationId, "RunInstance", other);
}
{ // do it
ncMetadata meta = { correlationId, userId };
ncInstance * outInst;
int error = doRunInstance (&meta, instanceId, reservationId, ¶ms,
imageId, imageURL,
kernelId, kernelURL,
ramdiskId, ramdiskURL,
keyName,
&netparams,
userData, launchIndex, groupNames, groupNamesSize,
&outInst);
if (error) {
logprintfl (EUCAERROR, "ERROR: doRunInstance() failed error=%d\n", error);
adb_ncRunInstanceResponseType_set_return(output, env, AXIS2_FALSE);
} else {
///// set standard fields in output
adb_ncRunInstanceResponseType_set_return(output, env, AXIS2_TRUE);
adb_ncRunInstanceResponseType_set_correlationId(output, env, correlationId);
adb_ncRunInstanceResponseType_set_userId(output, env, userId);
///// set operation-specific fields in output
adb_instanceType_t * instance = adb_instanceType_create(env);
copy_instance_to_adb (instance, env, outInst); // copy all values outInst->instance
// TODO: should we free_instance(&outInst) here or not? currently you don't have to
adb_ncRunInstanceResponseType_set_instance(output, env, instance);
}
if (groupNamesSize)
free (groupNames);
}
}
// set response to output
adb_ncRunInstanceResponse_set_ncRunInstanceResponse(response, env, output);
pthread_mutex_unlock(&ncHandlerLock);
eventlog("NC", userId, correlationId, "RunInstance", "end");
return response;
}
adb_DescribeResourcesResponse_t *DescribeResourcesMarshal(adb_DescribeResources_t *describeResources, const axutil_env_t *env) {
// output vars
adb_DescribeResourcesResponse_t *ret=NULL;
adb_describeResourcesResponseType_t *drrt=NULL;
// input vars
adb_describeResourcesType_t *drt=NULL;
// working vars
int i, rc, *outTypesMax=NULL, *outTypesAvail=NULL;
int vmLen=0, outTypesLen=0;
ccResource *outNodes=NULL;
int outNodesLen=0;
axis2_bool_t status=AXIS2_TRUE;
char statusMessage[256];
virtualMachine *vms=NULL;
adb_virtualMachineType_t *vm=NULL;
ncMetadata ccMeta;
adb_serviceInfoType_t *sit=NULL;
int servicesLen=0, urisLen=0, j;
drt = adb_DescribeResources_get_DescribeResources(describeResources, env);
EUCA_MESSAGE_UNMARSHAL(describeResourcesType, drt, (&ccMeta));
vmLen = adb_describeResourcesType_sizeof_instanceTypes(drt, env);
vms = malloc(sizeof(virtualMachine) * vmLen);
for (i=0; i<vmLen; i++) {
char *name;
vm = adb_describeResourcesType_get_instanceTypes_at(drt, env, i);
copy_vm_type_from_adb (&(vms[i]), vm, env);
}
// do it
drrt = adb_describeResourcesResponseType_create(env);
rc=1;
if (!DONOTHING) {
rc = doDescribeResources(&ccMeta, &vms, vmLen, &outTypesMax, &outTypesAvail, &outTypesLen, &outNodes, &outNodesLen);
}
if (rc) {
logprintfl(ERROR, "ERROR: doDescribeResources() failed %d\n", rc);
status = AXIS2_FALSE;
snprintf(statusMessage, 255, "ERROR");
} else {
for (i=0; i<outNodesLen; i++) {
// adb_describeResourcesResponseType_add_serviceTags(drrt, env, outNodes[i].ncURL);
adb_ccNodeType_t *nt=NULL;
nt = adb_ccNodeType_create(env);
adb_ccNodeType_set_serviceTag(nt, env, outNodes[i].ncURL);
adb_ccNodeType_set_iqn(nt, env, outNodes[i].iqn);
adb_describeResourcesResponseType_add_nodes(drrt, env, nt);
}
if (outNodes) free(outNodes);
for (i=0; i<outTypesLen; i++) {
adb_ccResourceType_t *rt=NULL;
vm = copy_vm_type_to_adb (env, &(vms[i]));
rt = adb_ccResourceType_create(env);
adb_ccResourceType_set_instanceType(rt, env, vm);
adb_ccResourceType_set_maxInstances(rt, env, outTypesMax[i]);
adb_ccResourceType_set_availableInstances(rt, env, outTypesAvail[i]);
adb_describeResourcesResponseType_add_resources(drrt, env, rt);
}
if (outTypesMax) free(outTypesMax);
if (outTypesAvail) free(outTypesAvail);
}
if (vms) free(vms);
adb_describeResourcesResponseType_set_correlationId(drrt, env, ccMeta.correlationId);
adb_describeResourcesResponseType_set_userId(drrt, env, ccMeta.userId);
adb_describeResourcesResponseType_set_return(drrt, env, status);
if (status == AXIS2_FALSE) {
adb_describeResourcesResponseType_set_statusMessage(drrt, env, statusMessage);
}
ret = adb_DescribeResourcesResponse_create(env);
adb_DescribeResourcesResponse_set_DescribeResourcesResponse(ret, env, drrt);
return(ret);
}
static ncInstance * copy_instance_from_adb (adb_instanceType_t * instance, axutil_env_t * env)
{
int i;
adb_virtualMachineType_t * vm_type = adb_instanceType_get_instanceType(instance, env);
virtualMachine params;
copy_vm_type_from_adb (¶ms, vm_type, env);
netConfig ncnet;
bzero(&ncnet, sizeof(netConfig));
adb_netConfigType_t * netconf = adb_instanceType_get_netParams(instance, env);
if (netconf != NULL) {
ncnet.vlan = adb_netConfigType_get_vlan(netconf, env);
ncnet.networkIndex = adb_netConfigType_get_networkIndex(netconf, env);
strncpy(ncnet.privateMac, adb_netConfigType_get_privateMacAddress(netconf, env), 24);
strncpy(ncnet.privateIp, adb_netConfigType_get_privateIp(netconf, env), 24);
strncpy(ncnet.publicIp, adb_netConfigType_get_publicIp(netconf, env), 24);
}
int groupNamesSize = adb_instanceType_sizeof_groupNames (instance, env);
char * groupNames [EUCA_MAX_GROUPS];
for (i = 0; i<EUCA_MAX_GROUPS && i<groupNamesSize; i++) {
groupNames[i] = adb_instanceType_get_groupNames_at (instance, env, i);
}
ncInstance * outInst = allocate_instance(
(char *)adb_instanceType_get_instanceId(instance, env),
(char *)adb_instanceType_get_reservationId(instance, env),
¶ms,
(char *)adb_instanceType_get_imageId(instance, env),
NULL, // URL is NULL
(char *)adb_instanceType_get_kernelId(instance, env),
NULL, // URL is NULL
(char *)adb_instanceType_get_ramdiskId(instance, env),
NULL, // URL is NULL
(char *)adb_instanceType_get_stateName(instance, env),
0,
(char *)adb_instanceType_get_userId(instance, env),
&ncnet,
(char *)adb_instanceType_get_keyName(instance, env),
(char *)adb_instanceType_get_userData(instance, env),
(char *)adb_instanceType_get_launchIndex(instance, env),
groupNames, groupNamesSize
);
axutil_date_time_t * dt = adb_instanceType_get_launchTime(instance, env);
if (dt!=NULL) {
outInst->launchTime = datetime_to_unix (dt, env);
axutil_date_time_free(dt, env);
}
outInst->volumesSize = adb_instanceType_sizeof_volumes (instance, env);
if (outInst->volumesSize > 0) {
for (i=0; i<EUCA_MAX_VOLUMES && i<outInst->volumesSize; i++) {
adb_volumeType_t * volume = adb_instanceType_get_volumes_at (instance, env, i);
strncpy (outInst->volumes[i].volumeId, adb_volumeType_get_volumeId (volume, env), CHAR_BUFFER_SIZE);
strncpy (outInst->volumes[i].remoteDev, adb_volumeType_get_remoteDev (volume, env), CHAR_BUFFER_SIZE);
strncpy (outInst->volumes[i].localDev, adb_volumeType_get_localDev (volume, env), CHAR_BUFFER_SIZE);
strncpy (outInst->volumes[i].stateName, adb_volumeType_get_state (volume, env), CHAR_BUFFER_SIZE);
}
}
return outInst;
}
adb_RunInstancesResponse_t *RunInstancesMarshal(adb_RunInstances_t *runInstances, const axutil_env_t *env) {
// output vars
adb_RunInstancesResponse_t *ret=NULL;
adb_runInstancesResponseType_t *rirt=NULL;
// input vars
adb_runInstancesType_t *rit=NULL;
// working vars
adb_ccInstanceType_t *it=NULL;
adb_virtualMachineType_t *vm=NULL;
ccInstance *outInsts=NULL, *myInstance=NULL;
int minCount, maxCount, rc, outInstsLen, i, vlan, instIdsLen, netNamesLen, macAddrsLen, *networkIndexList=NULL, networkIndexListLen, uuidsLen, expiryTime;
axis2_bool_t status=AXIS2_TRUE;
char statusMessage[256];
char *emiId=NULL, *keyName=NULL, **instIds=NULL, *reservationId=NULL, **netNames=NULL, **macAddrs=NULL, *kernelId=NULL, *ramdiskId=NULL, *emiURL=NULL, *kernelURL=NULL, *ramdiskURL=NULL, *vmName=NULL, *userData=NULL, *launchIndex=NULL, *platform=NULL, *tmp=NULL, **uuids=NULL, *accountId=NULL, *ownerId=NULL;
ncMetadata ccMeta;
virtualMachine ccvm;
axutil_date_time_t *dt=NULL;
rit = adb_RunInstances_get_RunInstances(runInstances, env);
EUCA_MESSAGE_UNMARSHAL(runInstancesType, rit, (&ccMeta));
reservationId = adb_runInstancesType_get_reservationId(rit, env);
maxCount = adb_runInstancesType_get_maxCount(rit, env);
minCount = adb_runInstancesType_get_minCount(rit, env);
keyName = adb_runInstancesType_get_keyName(rit, env);
emiId = adb_runInstancesType_get_imageId(rit, env);
kernelId = adb_runInstancesType_get_kernelId(rit, env);
ramdiskId = adb_runInstancesType_get_ramdiskId(rit, env);
emiURL = adb_runInstancesType_get_imageURL(rit, env);
kernelURL = adb_runInstancesType_get_kernelURL(rit, env);
ramdiskURL = adb_runInstancesType_get_ramdiskURL(rit, env);
tmp = adb_runInstancesType_get_userData(rit, env);
if (!tmp) {
userData = strdup("");
} else {
userData = strdup(tmp);
}
launchIndex = adb_runInstancesType_get_launchIndex(rit, env);
platform = adb_runInstancesType_get_platform(rit, env);
dt = adb_runInstancesType_get_expiryTime(rit, env);
expiryTime = datetime_to_unix(dt, env);
vm = adb_runInstancesType_get_instanceType(rit, env);
copy_vm_type_from_adb (&ccvm, vm, env);
vmName = adb_virtualMachineType_get_name(vm, env);
snprintf(ccvm.name, 64, "%s", vmName);
vlan = adb_runInstancesType_get_vlan(rit, env);
instIdsLen = adb_runInstancesType_sizeof_instanceIds(rit, env);
instIds = malloc(sizeof(char *) * instIdsLen);
for (i=0; i<instIdsLen; i++) {
instIds[i] = adb_runInstancesType_get_instanceIds_at(rit, env, i);
}
netNamesLen = adb_runInstancesType_sizeof_netNames(rit, env);
netNames = malloc(sizeof(char *) * netNamesLen);
if (netNamesLen > 1) {
netNamesLen = 1;
}
for (i=0; i<netNamesLen; i++) {
netNames[i] = adb_runInstancesType_get_netNames_at(rit, env, i);
}
macAddrsLen = adb_runInstancesType_sizeof_macAddresses(rit, env);
macAddrs = malloc(sizeof(char *) * macAddrsLen);
for (i=0; i<macAddrsLen; i++) {
macAddrs[i] = adb_runInstancesType_get_macAddresses_at(rit, env, i);
}
uuidsLen = adb_runInstancesType_sizeof_uuids(rit, env);
uuids = malloc(sizeof(char *) * uuidsLen);
for (i=0; i<uuidsLen; i++) {
uuids[i] = adb_runInstancesType_get_uuids_at(rit, env, i);
}
networkIndexList = NULL;
networkIndexListLen = adb_runInstancesType_sizeof_networkIndexList(rit, env);
if (networkIndexListLen) {
networkIndexList = malloc(sizeof(int) * networkIndexListLen);
for (i=0; i<networkIndexListLen; i++) {
networkIndexList[i] = adb_runInstancesType_get_networkIndexList_at(rit, env, i);
}
}
accountId = adb_runInstancesType_get_accountId(rit, env);
if (!accountId) {
accountId = ccMeta.userId;
}
ownerId = adb_runInstancesType_get_ownerId(rit, env);
if (!ownerId) {
ownerId = accountId;
}
rirt = adb_runInstancesResponseType_create(env);
rc=1;
if (!DONOTHING) {
rc = doRunInstances(&ccMeta, emiId, kernelId, ramdiskId, emiURL, kernelURL,ramdiskURL, instIds, instIdsLen, netNames, netNamesLen, macAddrs, macAddrsLen, networkIndexList, networkIndexListLen, uuids, uuidsLen, minCount, maxCount, accountId, ownerId, reservationId, &ccvm, keyName, vlan, userData, launchIndex, platform, expiryTime, NULL, &outInsts, &outInstsLen);
}
if (rc) {
logprintf("ERROR: doRunInstances() failed %d\n", rc);
status=AXIS2_FALSE;
snprintf(statusMessage, 255, "ERROR");
} else {
for (i=0; i<outInstsLen; i++) {
myInstance = &(outInsts[i]);
it = adb_ccInstanceType_create(env);
myInstance->ccvm.virtualBootRecordLen = 0;
rc = ccInstanceUnmarshal(it, myInstance, env);
adb_runInstancesResponseType_add_instances(rirt, env, it);
}
if (outInsts) free(outInsts);
}
adb_runInstancesResponseType_set_correlationId(rirt, env, ccMeta.correlationId);
adb_runInstancesResponseType_set_userId(rirt, env, ccMeta.userId);
adb_runInstancesResponseType_set_return(rirt, env, status);
if (status == AXIS2_FALSE) {
adb_runInstancesResponseType_set_statusMessage(rirt, env, statusMessage);
}
ret = adb_RunInstancesResponse_create(env);
adb_RunInstancesResponse_set_RunInstancesResponse(ret, env, rirt);
free(networkIndexList);
free(macAddrs);
free(netNames);
free(instIds);
free(userData);
if(uuids != NULL)
free(uuids);
return(ret);
}
