void launch(int port, struct ExperimentServer handlers){
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
weblab_handlers.is_up_and_running = handlers.is_up_and_running;
weblab_handlers.start_experiment = handlers.start_experiment;
weblab_handlers.send_command = handlers.send_command;
weblab_handlers.send_file = handlers.send_file;
weblab_handlers.dispose = handlers.dispose;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.test_me", &weblab_xmlrpc_test_me, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.is_up_and_running", &weblab_xmlrpc_is_up_and_running, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.start_experiment", &weblab_xmlrpc_start_experiment, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.send_command", &weblab_xmlrpc_send_command_to_device, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.send_file", &weblab_xmlrpc_send_file_to_device, NULL);
xmlrpc_registry_add_method( &env, registryP, NULL, "Util.dispose", &weblab_xmlrpc_dispose, NULL);
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = port;
serverparm.log_file_name = "xmlrpc_log";
printf("Running XML-RPC server on port %i...\n", port);
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(log_file_name));
}
int
main(int const argc,
const char ** const argv) {
struct xmlrpc_method_info3 const methodInfo = {
/* .methodName = */ "sample.add",
/* .methodFunction = */ &sample_add,
};
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
if (argc-1 != 1) {
fprintf(stderr, "You must specify 1 argument: The TCP port "
"number on which the server will accept connections "
"for RPCs (8080 is a common choice). "
"You specified %d arguments.\n", argc-1);
exit(1);
}
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
if (env.fault_occurred) {
printf("xmlrpc_registry_new() failed. %s\n", env.fault_string);
exit(1);
}
xmlrpc_registry_add_method3(&env, registryP, &methodInfo);
if (env.fault_occurred) {
printf("xmlrpc_registry_add_method3() failed. %s\n",
env.fault_string);
exit(1);
}
serverparm.config_file_name = NULL; /* Select the modern normal API */
serverparm.registryP = registryP;
serverparm.port_number = atoi(argv[1]);
serverparm.log_file_name = "/tmp/xmlrpc_log";
printf("Running XML-RPC server...\n");
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(log_file_name));
if (env.fault_occurred) {
printf("xmlrpc_server_abyss() failed. %s\n", env.fault_string);
exit(1);
}
/* xmlrpc_server_abyss() never returns unless it fails */
return 0;
}
static void run_rpc_server(xmlrpc_env *env, unsigned int port)
{
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
memset(&serverparm, 0, sizeof(serverparm));
registryP = xmlrpc_registry_new(env);
xmlrpc_registry_add_method(env, registryP, NULL, "add_flow_destination", &add_flow_destination, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "add_flow_source", &add_flow_source, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "start_flows", &start_flows, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_reports", &method_get_reports, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "stop_flow", &method_stop_flow, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_version", &method_get_version, NULL);
xmlrpc_registry_add_method(env, registryP, NULL, "get_status", &method_get_status, NULL);
/* In the modern form of the Abyss API, we supply parameters in memory
like a normal API. We select the modern form by setting
config_file_name to NULL:
*/
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.socket_bound = 1;
serverparm.log_file_name = NULL; /*"/tmp/xmlrpc_log";*/
/* Increase HTTP keep-alive duration. Using defaults the amount of
* sockets in TIME_WAIT state would become too high.
*/
serverparm.keepalive_timeout = 60;
serverparm.keepalive_max_conn = 1000;
/* Disable introspection */
serverparm.dont_advertise = 1;
logging_log(LOG_NOTICE, "Running XML-RPC server on port %u", port);
printf("Running XML-RPC server...\n");
serverparm.socket_handle = bind_rpc_server(rpc_bind_addr, port);
xmlrpc_server_abyss(env, &serverparm, XMLRPC_APSIZE(socket_handle));
if (env->fault_occurred) {
logging_log(LOG_ALERT, "XML-RPC Fault: %s (%d)\n",
env->fault_string, env->fault_code);
}
/* xmlrpc_server_abyss() never returns */
}
int
main(int const argc,
const char ** const argv) {
struct xmlrpc_method_info3 const methodInfo = {
/* .methodName = */ "calculate_modexp",
/* .methodFunction = */ &calculate_modexp,
};
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
if (argc-1 != 1) {
fprintf(stderr, "You must specify 1 argument: The TCP port "
"number on which the server will accept connections "
"for RPCs (8080 is a common choice). "
"You specified %d arguments.\n", argc-1);
exit(1);
}
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method3(&env, registryP, &methodInfo);
/* In the modern form of the Abyss API, we supply parameters in memory
like a normal API. We select the modern form by setting
config_file_name to NULL:
*/
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = atoi(argv[1]);
serverparm.log_file_name = "/tmp/xmlrpc_log";
printf("Running XML-RPC server...\n");
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(log_file_name));
/* xmlrpc_server_abyss() never returns */
return 0;
}
//--------------------------------------------------------------------------------------
DWORD WINAPI ServerThread(LPVOID lpParam)
{
struct xmlrpc_method_info3 const methodInfo =
{
/* .methodName = */ "vertex_callback",
/* .methodFunction = */ &vertex_callback,
};
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry *registryP;
xmlrpc_env env;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
xmlrpc_registry_add_method3(&env, registryP, &methodInfo);
/* In the modern form of the Abyss API, we supply parameters in memory
like a normal API. We select the modern form by setting
config_file_name to NULL:
*/
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = XMLRPC_SERVER_PORT;
serverparm.log_file_name = "./" LOG_NAME;
DbgMsg(
__FILE__, __LINE__,
__FUNCTION__"(): Running XML-RPC server at port %d...\n",
serverparm.port_number
);
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(log_file_name));
/* xmlrpc_server_abyss() never returns */
return 0;
}
int main(int argc, char **argv)
{
xmlrpc_server_abyss_parms serverparm;
xmlrpc_registry * registryP;
xmlrpc_env env;
int ii;
int c;
int dmn = 0;
char *config_file = NULL;
while ( ( c = getopt_long( argc, argv, short_opts, long_opts, NULL ) ) != -1 )
{
switch( c ) {
case 'd':
dmn = 1;
break;
case 'c':
config_file = strdup( optarg );
break;
case '?':
default:
fprintf(stderr, "unknown option\n");
fprintf(stderr, "%s", usage_txt);
exit(1);
}
}
if ( dmn && (0 != daemon( 0, 0 ) )) {
SYSLOG_FAULT("Failed to daemonize");
return 1;
}
if ( zw_api_init( "/dev/ttyUSB0", &hzr_ctx.zw_ctx ) ) {
SYSLOG_FAULT("zWave API Init failed");
return 1;
}
sleep(3);
zw_list_nodes();
if ( config_file )
xmlconfig_load( config_file );
xmlrpc_env_init(&env);
dieOnFault("init", &env);
registryP = xmlrpc_registry_new(&env);
dieOnFault("init_registry", &env);
for ( ii = 0; ii < ( sizeof( methodInfo ) / sizeof( struct xmlrpc_method_info3 ) ); ii++ )
{
xmlrpc_registry_add_method3(&env, registryP, &methodInfo[ii]);
dieOnFault("add_method", &env);
}
serverparm.config_file_name = NULL;
serverparm.registryP = registryP;
serverparm.port_number = 8080;
serverparm.log_file_name = "/tmp/xmlrpc_log";
printf("Starting XML-RPC server...\n");
xmlrpc_server_abyss(&env, &serverparm, XMLRPC_APSIZE(registryP));
if ( config_file ) free( config_file );
return 0;
}
/**
* Thread process created to run a listener for the methods being called.
*/
static void *
xr_rpcListener (Server *svr)
{
xmlrpc_server_abyss_parms serverparm;
/* Initialize the environment and install the default dispatcher method.
*/
xmlrpc_env_init (&svr->env); /* initialize XML-RPC interface */
if (SRVR_DEBUG)
fprintf (stderr, "GLOBAL_ABYSS_SERVER rpcListener ....\n");
svr->registry = xmlrpc_registry_new (&svr->env);
xmlrpc_registry_set_default_method (&svr->env,
(svr->serverparm.registryP = svr->registry),
(xmlrpc_default_method) &xr_defaultMethod, svr);
serverparm.config_file_name = NULL;
serverparm.registryP = svr->serverparm.registryP;
serverparm.port_number = svr->serverparm.port_number;
serverparm.log_file_name = svr->serverparm.log_file_name;
serverparm.keepalive_timeout = 0;
serverparm.keepalive_max_conn = 0;
/*
serverparm.keepalive_timeout = 30;
serverparm.keepalive_max_conn = 128;
*/
/* Never returns .....
*/
#ifndef OLD_METHOD
xmlrpc_server_abyss (&svr->env, &serverparm, XMLRPC_APSIZE(log_file_name));
#else
{
xmlrpc_server_abyss_t *serverP;
xmlrpc_server_abyss_sig *oldHandlersP;
xmlrpc_server_abyss_create (&svr->env, &serverparm,
XMLRPC_APSIZE(log_file_name), &serverP);
xmlrpc_server_abyss_setup_sig (&svr->env, serverP, &oldHandlersP);
printf ("Starting XML-RPC server...\n");
xmlrpc_server_abyss_run_server (&svr->env, &serverP);
xmlrpc_server_abyss_restore_sig (oldHandlersP);
free (oldHandlersP);
xmlrpc_server_abyss_destroy (serverP);
xmlrpc_server_abyss_global_term ();
}
#endif
/* Should never get here.
*/
if (svr->env.fault_occurred) {
fprintf (stderr, "xmlrpc_server_abyss terminates.....\n");
exit (1);
} else
return ((void *) OK);
}
