void c_oneStart()
{
xmlrpc_env_init(&one_client.env);
xmlrpc_client_init2(&one_client.env, XMLRPC_CLIENT_NO_FLAGS,
"OpenNebula API Client", "1.2", NULL, 0);
one_client.error = 0;
one_client.url = "http://localhost:2633/RPC2";
one_client.session = "one-session";
};
int
main(int const argc,
const char ** const argv)
{
const char* const methodName = "sample.add";
xmlrpc_env env;
xmlrpc_env_init(&env);
//create a global client
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
// create a multi_server_info struct
multi_server_info_t multiServerInfo;
multiServerInfo.numberOfServer = 3; // 3 servers, 8080, 8081, 8082
multiServerInfo.serverUrlArray = malloc(sizeof(char *) *
multiServerInfo.numberOfServer);
multiServerInfo.serverUrlArray[0] = "http://localhost:8080/RPC2";
multiServerInfo.serverUrlArray[1] = "http://localhost:8081/RPC2";
multiServerInfo.serverUrlArray[2] = "http://localhost:8082/RPC2";
// how many times we need to run our multirpc_globalclient_asynch()
//int * requestsForMultiRpc = malloc(sizeof(int));
int requestsForMultiRpc = atoi(argv[1]);
// in one single multi rpc call, how many requests we need to send
// each server will get one request, so it is equal to number of server
//int * requestsRequired = malloc(sizeof(int));
int requestsRequired = multiServerInfo.numberOfServer;
int counter;
for (counter = 0; counter < (requestsForMultiRpc); ++counter)
{
// requestsRequired shows how many threads need to be created in
// the belowing function
multirpc_globalclient_asynch(&multiServerInfo, methodName,
handle_sample_add_response,
requestsRequired);
printf("Multi RPC has been done %d time. Waiting..\n", counter+1);
// xmlrpc_client_event_loop_finish_asynch();
}
// sleep(10);
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return 0;
}
void init_xmlrpc(const char* url)
{
if (url != NULL)
ubigraph_url = url;
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
die_if_fault_occurred(&env);
xmlrpc_initialized = 1;
}
int
main(int const argc,
const char ** const argv) {
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_int32 sum;
const char * const serverUrl = "http://localhost:8080/RPC2";
const char * const serverUrl2 = "http://localhost:8081/RPC2";
const char * const serverUrl3 = "http://localhost:8082/RPC2";
const char * const methodName = "sample.add";
if (argc-1 > 0) {
fprintf(stderr, "This program has no arguments\n");
exit(1);
}
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
dieIfFaultOccurred(&env);
printf("Making XMLRPC call to server url '%s' method '%s' "
"to request the sum "
"of 5 and 7...\n", serverUrl, methodName);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, methodName, "(sssii)", 1, 3, serverUrl, serverUrl2, serverUrl3,
(xmlrpc_int32) 5, (xmlrpc_int32) 7);
dieIfFaultOccurred(&env);
/* Get our sum and print it out. */
xmlrpc_read_int(&env, resultP, &sum);
dieIfFaultOccurred(&env);
printf("The sum is %d\n", sum);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
return 0;
}
void LogEvent_init(int port) {
#ifdef DEFINE_XMLRPC
char urlBuf[128]; // to store URL built from pattern
/* Construct the server URL from pattern and port, then store it. */
_xmlrpc_server_port = port;
sprintf(urlBuf, XMLRPC_SERVER_URL, _xmlrpc_server_port);
strcpy(_xmlrpc_server_url, urlBuf);
/* Initialize our error-handling environment. */
xmlrpc_env_init(&_xmlrpc_env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&_xmlrpc_env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
die_if_fault_occurred(&_xmlrpc_env);
#else
(void)port;
#endif /* DEFINE_XMLRPC */
}
/**
* @warning xmlrpc_client_init2 is not threadsafe
*/
void init_xmlrpc(const char* url)
{
xmlrpc_env env;
// Initialisation should only happen once or things will mess up.
if (xmlrpc_initialized)
return;
if (url != NULL)
ubigraph_url = url;
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, UBICLIENT_NAME,
UBICLIENT_VERSION, NULL, 0);
if (print_err_if_fault_occurred(&env))
return;
xmlrpc_initialized = 1;
}
void
xmlrpc_client_init(int const flags,
const char * const appname,
const char * const appversion) {
/*----------------------------------------------------------------------------
This function is not thread-safe.
-----------------------------------------------------------------------------*/
struct xmlrpc_clientparms clientparms;
/* As our interface does not allow for failure, we just fail silently ! */
xmlrpc_env env;
xmlrpc_env_init(&env);
clientparms.transport = NULL;
/* The following call is not thread-safe */
xmlrpc_client_init2(&env, flags,
appname, appversion,
&clientparms, XMLRPC_CPSIZE(transport));
xmlrpc_env_clean(&env);
}
static void
doCall(xmlrpc_env * const envP,
const char * const transport,
const xmlrpc_server_info * const serverInfoP,
xmlrpc_mem_block * const callXmlP,
xmlrpc_mem_block ** const respXmlPP) {
struct xmlrpc_clientparms clientparms;
clientparms.transport = transport;
clientparms.transportparmsP = NULL;
clientparms.transportparm_size = 0;
xmlrpc_client_init2(envP, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION,
&clientparms, XMLRPC_CPSIZE(transportparm_size));
if (!envP->fault_occurred) {
xmlrpc_client_transport_call(envP, NULL, serverInfoP,
callXmlP, respXmlPP);
xmlrpc_client_cleanup();
}
}
int
main(int const argc,
const char ** const argv) {
if(argc < 2 )
{
fprintf(stderr,"Usage : ./client <Semantics> <No of Servers>\n");
exit(EXIT_FAILURE);
}
const char const **serverUrl;
int i = 0, port = 8080 ;
xmlrpc_env env;
xmlrpc_value * resultP;
int nUrl = atoi(argv[2]);
struct timeval start,end,diff;
if(nUrl == 0)
{
fprintf(stderr,"Please enter non-zero number of servers\n");
exit(EXIT_FAILURE);
}
#if 0
serverUrl = (char **) malloc (nUrl * sizeof(char*));
for(i = 0 ; i < nUrl ; i++){
serverUrl[i] = (char *) malloc(50 * sizeof(char));
sprintf(serverUrl[i],"http://localhost:%d/RPC2",port++);
}
#endif
#if 1
serverUrl = malloc(sizeof(char*) * 5);
serverUrl[0] = "http://localhost:8080/RPC2";
serverUrl[1] = "http://localhost:8081/RPC2";
serverUrl[2] = "http://localhost:8082/RPC2";
serverUrl[3] = "http://localhost:8083/RPC2";
serverUrl[4] = "http://localhost:8084/RPC2";
#endif
const char * const methodName = "calculate_modexp";
//const char * const serverUrl = "http://localhost:8080/RPC2";
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
dieIfFaultOccurred(&env);
// printf("Making XMLRPC call to server url '%s' method '%s' " "to request the sum " "of 5 and 7...\n", serverUrl, methodName);
/* Make the remote procedure call */
// printf("Result is : %d\n",xmlrpc_validate_utf8("Hello World"));
xmlrpc_value *arr = xmlrpc_array_new(&env);
//resultP = xmlrpc_client_call(&env, serverUrl, methodName,"(A)", generate_request_array(&env , arr) );
gettimeofday(&start,NULL);
/*Call the server*/
resultP = xmlrpc_client_call_multi_sync(atoi(argv[1]),nUrl, &env, serverUrl, methodName,"(A)", generate_request_array(&env , arr));
gettimeofday(&end,NULL);
difference(&diff,end,start);
printf("Time Taken With %d Server = %ld:%ld\n",nUrl,diff.tv_usec/1000000,diff.tv_usec%1000000);
// printf("Check to see if killed\n");
dieIfFaultOccurred(&env);
/* Get our sum and print it out. */
//xmlrpc_read_int(&env, resultP, &primeResult);
// xmlrpc_env * const dummy;
// printf("Extracting Results\n");
const char* result = extract_result ( &env , resultP);
dieIfFaultOccurred(&env);
// printf("2^p/m = %s\n", result);
/*Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
return 0;
}
static void init() {
xmlrpc_env_init(&env);
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
check_fault(&env);
}
int
main(int const argc,
const char ** const argv) {
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_int32 number_of_links;
const char * const serverUrl = "http://localhost:4567/RPC2";
const char * const methodName = "get_number_of_links";
if (argc-1 > 0) {
fprintf(stderr, "This program has no arguments\n");
exit(1);
}
/* Initialize our error-handling environment. */
xmlrpc_env_init(&env);
/* Start up our XML-RPC client library. */
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
dieIfFaultOccurred(&env);
printf("Making XMLRPC call to server url '%s' method '%s'\n", serverUrl, "get_number_of_links");
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "get_number_of_links",
"(i)", (xmlrpc_int32) 1);
dieIfFaultOccurred(&env);
/* Get our sum and print it out. */
xmlrpc_read_int(&env, resultP, &number_of_links);
dieIfFaultOccurred(&env);
printf("Number of links defined: %d\n", number_of_links);
/* Dispose of our result value. */
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "get_links",
"(i)", (xmlrpc_int32) 1);
dieIfFaultOccurred(&env);
int array_size =xmlrpc_array_size(&env, resultP);
while(array_size>0) {
--array_size;
xmlrpc_value *value;
const char *link;
xmlrpc_array_read_item(&env, resultP, 0, &value);
xmlrpc_read_string(&env, value, &link);
printf("Link %u: %s\n", array_size, link);
xmlrpc_DECREF(value);
}
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "add_target", "(i)",
(xmlrpc_int32) 1);
xmlrpc_int64 targetID = 0;
xmlrpc_read_i8(&env, resultP, &targetID);
if(targetID) {
printf("New target added with ID: %"PRIx64"\n", targetID);
} else {
printf("Failed to add new target!\n");
goto done;
}
xmlrpc_DECREF(resultP);
/* Make the remote procedure call */
resultP = xmlrpc_client_call(&env, serverUrl, "remove_target", "(i)",
(xmlrpc_int64) targetID);
xmlrpc_int32 res;
xmlrpc_read_int(&env, resultP, &res);
printf("Target %"PRIx64" remove: %"PRIx32"\n", targetID, res);
done:
xmlrpc_DECREF(resultP);
/* Clean up our error-handling environment. */
xmlrpc_env_clean(&env);
/* Shutdown our XML-RPC client library. */
xmlrpc_client_cleanup();
return 0;
}
node_t * xmlrpc_client_callmethod(const char * serverUrl, const char * methodName, unsigned int argVersion){
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_client_init2(&env, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION, NULL, 0);
dieIfFailed("Client initialization", &env);
xmlrpc_value * ID, * PORT, * DATA, * DATAP, * IP;
ID = xmlrpc_int_new(&env, 23121);
IP = xmlrpc_string_new(&env, "127.0.0.1");
PORT = xmlrpc_int_new(&env, 8085);
DATA = xmlrpc_int_new(&env, 123);
DATAP = xmlrpc_struct_new(&env);
xmlrpc_struct_set_value(&env, DATAP, "ID", ID);
xmlrpc_struct_set_value(&env, DATAP, "IP", IP);
xmlrpc_struct_set_value(&env, DATAP, "PORT", PORT);
xmlrpc_struct_set_value(&env, DATAP, "DATA", DATA);
xmlrpc_DECREF(ID);
xmlrpc_DECREF(IP);
xmlrpc_DECREF(PORT);
xmlrpc_DECREF(DATA);
/* Make the call */
xmlrpc_value * resultArray = xmlrpc_client_call(&env, serverUrl, methodName, "(iS)", (xmlrpc_int32) argVersion, DATAP);
xmlrpc_value * OutID_t, *OutPORT_t, *OutDATA_t, *OutIP_t;
xmlrpc_int OutID, OutPORT, OutDATA;
char * OutIP;
unsigned int const resultCt = xmlrpc_array_size(&env, resultArray);
unsigned int i;
node_t * resultnode = (node_t *) malloc(3*sizeof(node_t));
for(i = 0; i < resultCt; ++i){
xmlrpc_value * resultP;
xmlrpc_array_read_item(&env, resultArray, i, &resultP);
xmlrpc_struct_find_value(&env, resultP, "ID", &OutID_t);
xmlrpc_struct_find_value(&env, resultP, "IP", &OutIP_t);
xmlrpc_struct_find_value(&env, resultP, "PORT", &OutPORT_t);
xmlrpc_struct_find_value(&env, resultP, "DATA", &OutDATA_t);
xmlrpc_read_int(&env, OutID_t, &OutID);
xmlrpc_read_string(&env, OutIP_t, &OutIP);
xmlrpc_read_int(&env, OutPORT_t, &OutPORT);
xmlrpc_read_int(&env, OutDATA_t, &OutDATA);
resultnode[i].ID = OutID;
strcpy(resultnode[i].IP, OutIP);
resultnode[i].PORT = OutPORT;
resultnode[i].DATA = OutDATA;
}
xmlrpc_env_clean(&env);
xmlrpc_client_cleanup();
return resultnode;
}
static void
testInitCleanup(void) {
xmlrpc_env env;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
xmlrpc_env_init(&env);
xmlrpc_client_init2(&env, 0, "testprog", "1.0", NULL, 0);
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
xmlrpc_client_init2(&env, 0, "testprog", "1.0", &clientParms1, 0);
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
clientParms1.transport = "curl";
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transport));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
clientParms1.transportparmsP = NULL;
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
clientParms1.transportparmsP = &curlTransportParms1;
/* Fails because we didn't include transportparm_size: */
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP));
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
clientParms1.transportparm_size = 0;
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
curlTransportParms1.network_interface = "eth0";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(network_interface);
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
curlTransportParms1.no_ssl_verifypeer = 1;
curlTransportParms1.no_ssl_verifyhost = 1;
clientParms1.transportparm_size = XMLRPC_CXPSIZE(no_ssl_verifyhost);
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
curlTransportParms1.user_agent = "testprog/1.0";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(user_agent);
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
xmlrpc_client_init(0, "testprog", "1.0");
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
xmlrpc_env_clean(&env);
}
