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); }