// 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_virtualMachineType_t * vm_type = adb_virtualMachineType_create(env);
adb_virtualMachineType_set_memory(vm_type, env, outInst->params.memorySize);
adb_virtualMachineType_set_cores(vm_type, env, outInst->params.numberOfCores);
adb_virtualMachineType_set_disk(vm_type, env, outInst->params.diskSize);
adb_instanceType_set_instanceType(instance, env, vm_type);
adb_netConfigType_t * netconf = adb_netConfigType_create(env);
adb_netConfigType_set_privateMacAddress(netconf, env, outInst->ncnet.privateMac);
adb_netConfigType_set_publicMacAddress(netconf, env, outInst->ncnet.publicMac);
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_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
}
AXIS2_EXTERN axutil_date_time_t *AXIS2_CALL
axutil_date_time_create(
const axutil_env_t *env)
{
return axutil_date_time_create_with_offset(env, 0);
}
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);
}
axis2_status_t test_date_time(axutil_env_t *env)
{
axutil_date_time_t *date_time = NULL;
axutil_date_time_t *ref = NULL;
axutil_date_time_t *date_time_offset = NULL;
axis2_char_t *time_str = "22:45:12";
axis2_char_t *date_str = "2000-12-12";
axis2_char_t *date_time_str = "2000-11-11T12:30:24";
axis2_status_t status = AXIS2_FAILURE;
axutil_date_time_comp_result_t compare_res = AXIS2_DATE_TIME_COMP_RES_FAILURE;
axis2_char_t *t_str = NULL, *d_str = NULL, *dt_str = NULL;
int year , month , date , hour , min , sec , msec;
date_time_offset = axutil_date_time_create_with_offset(env, 100);
if(!date_time_offset)
{
printf("axutil_date_time_t creation failed.\n");
return AXIS2_FAILURE;
}
date_time = axutil_date_time_create(env);
if(!date_time)
{
printf("axutil_date_time_t creation failed.\n");
return AXIS2_FAILURE;
}
status = axutil_date_time_deserialize_time(date_time, env, time_str);
if(status)
printf("axutil_date_time_t time string deserialization success.\n");
status = axutil_date_time_deserialize_date(date_time, env, date_str);
if(status)
printf("axutil_date_time_t date string deserialization success.\n");
status = axutil_date_time_deserialize_date_time(date_time, env, date_time_str);
if(status)
printf("axutil_date_time_t date time string deserialization success.\n");
ref = axutil_date_time_create(env);
if(!ref)
{
printf("axutil_date_time_t creation failed.\n");
return AXIS2_FAILURE;
}
compare_res = axutil_date_time_compare(date_time, env, ref);
if(compare_res == AXIS2_DATE_TIME_COMP_RES_FAILURE)
{
printf("axutil_date_time comparison failed.\n");
}
status = axutil_date_time_deserialize_date_time(ref, env, date_time_str);
if(status)
printf("axutil_date_time_t date time string deserialization success.\n");
compare_res = axutil_date_time_compare(date_time, env, ref);
if(compare_res == AXIS2_DATE_TIME_COMP_RES_EQUAL)
{
printf("axutil_date_time_t comparison success.");
}
status = axutil_date_time_set_date_time(date_time, env, 2008, 1, 8, 12, 18, 57, 799);
if(status)
{
printf("axutil_date_time_t set date time success.\n");
}
t_str = axutil_date_time_serialize_time(date_time, env);
if(!t_str)
{
printf("axutil_date_time_t time serialization failed.\n");
}
else
{
printf("axutil_date_time_t Time: %s\n", t_str);
}
d_str = axutil_date_time_serialize_date(date_time, env);
if(!d_str)
{
printf("axutil_date_time_t date serialization failed.\n");
}
else
{
printf("axutil_date_time_t Date: %s\n", d_str);
}
dt_str = axutil_date_time_serialize_date_time(date_time, env);
if(!dt_str)
{
printf("axutil_date_time_t date time serialization failed.\n");
}
else
{
printf("axutil_date_time_t Date Time: %s\n", dt_str);
}
year = axutil_date_time_get_year(date_time,env);
month=axutil_date_time_get_month(date_time,env);
date = axutil_date_time_get_day(date_time,env);
hour = axutil_date_time_get_hour(date_time,env);
min = axutil_date_time_get_minute(date_time,env);
sec = axutil_date_time_get_second(date_time,env);
msec = axutil_date_time_get_msec(date_time,env);
printf("axutil_date_time_t year: %d \n",year);
printf("axutil_date_time_t month: %d \n",month);
printf("axutil_date_time_t date: %d \n",date);
printf("axutil_date_time_t hour: %d \n",hour);
printf("axutil_date_time_t min: %d \n",min);
printf("axutil_date_time_t sec: %d \n",sec);
printf("axutil_date_time_t msec: %d \n",msec);
axutil_date_time_free(date_time,env);
axutil_date_time_free(ref, env);
axutil_date_time_free(date_time_offset, env);
return AXIS2_SUCCESS;
}
