int main(int argc, char ** argv)
{
int c;
int option_index = 0;
int ret=0;
global_context_t * global_context;
global_context = (global_context_t*)malloc(sizeof(global_context_t));
init_global_context(global_context);
global_context->config.entry_program_name = CORE_PROGRAM_SUBINDEL;
optind = 1;
opterr = 1;
optopt = 63;
while ((c = getopt_long (argc, argv, "pi:g:o:I:d:?v", long_options, &option_index)) != -1)
{
switch(c)
{
case 'i':
strncpy(global_context->config.first_read_file, optarg, MAX_FILE_NAME_LENGTH-1);
break;
case 'p':
global_context -> input_reads.is_paired_end_reads=1;
break;
case 'g':
strncpy(global_context->config.index_prefix, optarg, MAX_FILE_NAME_LENGTH-1);
break;
case 'o':
strncpy(global_context->config.output_prefix, optarg, MAX_FILE_NAME_LENGTH-1);
break;
case 'd':
global_context->config.expected_pair_distance = atoi(optarg);
break;
case 'v':
core_version_number("subindel");
return 0;
break;
case 'I':
global_context->config.max_indel_length = atoi(optarg);
if(global_context->config.max_indel_length>=16)
{
global_context->config.reassembly_subread_length = 16;
global_context->config.reassembly_window_multiplex = 3;
global_context->config.reassembly_start_read_number = 3;
global_context->config.reassembly_tolerable_voting = 0;
global_context->config.reassembly_window_alleles = 3;
global_context->config.reassembly_key_length = 28;
}
break;
default:
case 'h':
print_usage_subindel();
return -1;
break;
}
}
if(argc<3)
{
print_usage_subindel();
return -1;
}
ret = print_configuration_forindel(global_context);
warning_file_type(global_context->config.first_read_file,global_context->config.is_BAM_input?FILE_TYPE_BAM:FILE_TYPE_SAM);
ret = ret || load_global_context_forindel(global_context);
ret = ret || load_indexes_forindel(global_context);
ret = ret || transfer_SAM_to_assembly(global_context);
ret = ret || init_indel_tables(global_context);
ret = ret || finalise_long_insertions_by_hashtable(global_context);
ret = ret || write_indel_final_results(global_context);
ret = ret || destroy_indel_module(global_context);
ret = ret || print_summary(global_context);
free(global_context);
return ret;
}
int main( int argc, const char* argv[])
{
std::auto_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2));
if (!errorBuffer.get())
{
std::cerr << _TXT("failed to create error buffer") << std::endl;
return -1;
}
g_errorBuffer = errorBuffer.get();
bool doExit = false;
int argi = 1;
std::string logfile;
std::vector<std::string> moduledirs;
std::vector<std::string> modules;
std::vector<std::string> resourcedirs;
std::vector<std::string> tracecfglist;
std::string storageconfig;
bool doCreateIfNotExist = false;
unsigned int nofThreads = 0;
unsigned int port = 7181; //... default port
try
{
// Parsing arguments:
for (; argi < argc; ++argi)
{
if (0==std::strcmp( argv[argi], "-h") || 0==std::strcmp( argv[argi], "--help"))
{
printUsage();
doExit = true;
}
else if (0==std::strcmp( argv[argi], "-v") || 0==std::strcmp( argv[argi], "--version"))
{
std::cerr << "strusRpc version " << STRUS_RPC_VERSION_STRING << std::endl;
doExit = true;
}
else if (0==std::strcmp( argv[argi], "-m") || 0==std::strcmp( argv[argi], "--module"))
{
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects argument"), "--module");
modules.push_back( argv[argi]);
}
else if (0==std::strcmp( argv[argi], "-M") || 0==std::strcmp( argv[argi], "--moduledir"))
{
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects argument"), "--moduledir");
moduledirs.push_back( argv[argi]);
}
else if (0==std::strcmp( argv[argi], "-R") || 0==std::strcmp( argv[argi], "--resourcedir"))
{
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects argument"), "--resourcedir");
resourcedirs.push_back( argv[argi]);
}
else if (0==std::strcmp( argv[argi], "-p") || 0==std::strcmp( argv[argi], "--port"))
{
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects argument"), "--port");
try
{
port = strus::utils::touint( argv[argi]);
if (port == 0 || port > 65535)
{
throw strus::runtime_error( _TXT("value out of range"));
}
}
catch (const std::runtime_error& err)
{
throw strus::runtime_error( _TXT("illegal argument for option %s: %s"), "--port", err.what());
}
}
else if (0==std::strcmp( argv[argi], "-s") || 0==std::strcmp( argv[argi], "--storage"))
{
if (!storageconfig.empty()) throw strus::runtime_error( _TXT("option %s or %s specified twice"), "--storage","--configfile");
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects argument"), "--storage");
storageconfig.append( argv[argi]);
if (storageconfig.empty()) throw strus::runtime_error(_TXT("option %s with empty argument"), "--storage");
}
else if (0==std::strcmp( argv[argi], "-S") || 0==std::strcmp( argv[argi], "--configfile"))
{
if (!storageconfig.empty()) throw strus::runtime_error( _TXT("option %s or %s specified twice"), "--storage","--configfile");
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects argument"), "--configfile");
int ec = strus::readFile( argv[argi], storageconfig);
if (ec)
{
throw strus::runtime_error(_TXT("failed to read configuration file %s (file system error %u)"), argv[argi], ec);
}
std::string::iterator di = storageconfig.begin(), de = storageconfig.end();
for (; di != de; ++di)
{
if ((unsigned char)*di < 32) *di = ' ';
}
if (storageconfig.empty()) throw strus::runtime_error(_TXT("option %s with empty file"), "--configfile");
}
else if (0==std::strcmp( argv[argi], "-c") || 0==std::strcmp( argv[argi], "--create"))
{
doCreateIfNotExist = true;
}
else if (0==std::strcmp( argv[argi], "-T") || 0==std::strcmp( argv[argi], "--trace"))
{
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects argument (trace configuration)"), "--trace");
tracecfglist.push_back( argv[argi]);
}
else if (0==std::strcmp( argv[argi], "-t") || 0==std::strcmp( argv[argi], "--threads"))
{
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects number as argument"), "--threads");
try
{
nofThreads = strus::utils::touint( argv[argi]);
}
catch (const std::runtime_error& err)
{
throw strus::runtime_error(_TXT("illegal argument for option %s: %s"),"--threads", err.what());
}
}
else if (0==std::strcmp( argv[argi], "-l") || 0==std::strcmp( argv[argi], "--logfile"))
{
if (logfile.size()) throw strus::runtime_error(_TXT("duplicate definition of option %s"), "--logfile");
++argi;
if (argi == argc) throw strus::runtime_error(_TXT("option %s expects argument"), "--logfile");
logfile = argv[argi];
if (logfile.empty()) throw strus::runtime_error(_TXT("empty definition of option %s"), "--logfile");
}
else if (argv[argi][0] == '-')
{
throw strus::runtime_error(_TXT("unknown option %s"), argv[argi]);
}
else
{
throw strus::runtime_error( _TXT("no arguments expected (only options)"));
}
}
if (doExit) return 0;
init_global_context( logfile.empty()?0:logfile.c_str());
g_errorBuffer->setLogFile( g_glbctx.logf);
g_errorBuffer->setMaxNofThreads( strus_threadpool_size()+2);
// Create the global context:
std::auto_ptr<strus::ModuleLoaderInterface>
moduleLoader( strus::createModuleLoader( g_errorBuffer));
g_moduleLoader = moduleLoader.get();
if (!g_moduleLoader) throw strus::runtime_error( _TXT("failed to create module loader"));
std::vector<std::string>::const_iterator
di = moduledirs.begin(), de = moduledirs.end();
for (; di != de; ++di)
{
g_moduleLoader->addModulePath( *di);
}
moduleLoader->addSystemModulePath();
std::vector<std::string>::const_iterator
mi = modules.begin(), me = modules.end();
for (; mi != me; ++mi)
{
g_moduleLoader->loadModule( *mi);
}
std::vector<std::string>::const_iterator
pi = resourcedirs.begin(), pe = resourcedirs.end();
for (; pi != pe; ++pi)
{
g_moduleLoader->addResourcePath( *pi);
}
if (g_errorBuffer->hasError())
{
throw strus::runtime_error(_TXT("error in initialization: %s"), g_errorBuffer->fetchError());
}
// Declare trace proxy objects:
typedef strus::Reference<strus::TraceProxy> TraceReference;
std::vector<TraceReference> trace;
if (!tracecfglist.empty())
{
std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end();
for (; ti != te; ++ti)
{
trace.push_back( new strus::TraceProxy( g_moduleLoader, *ti, g_errorBuffer));
}
}
// Create objects:
std::auto_ptr<strus::StorageObjectBuilderInterface>
storageBuilder( g_moduleLoader->createStorageObjectBuilder());
if (!storageBuilder.get())
{
throw strus::runtime_error( _TXT("failed to create storage builder"));
}
std::auto_ptr<strus::AnalyzerObjectBuilderInterface>
analyzerBuilder( g_moduleLoader->createAnalyzerObjectBuilder());
if (!analyzerBuilder.get())
{
throw strus::runtime_error( _TXT("failed to create analyzer builder"));
}
// Create proxy objects if tracing enabled:
std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end();
for (; ti != te; ++ti)
{
strus::AnalyzerObjectBuilderInterface* aproxy = (*ti)->createProxy( analyzerBuilder.get());
analyzerBuilder.release();
analyzerBuilder.reset( aproxy);
strus::StorageObjectBuilderInterface* sproxy = (*ti)->createProxy( storageBuilder.get());
storageBuilder.release();
storageBuilder.reset( sproxy);
}
std::auto_ptr<strus::StorageClientInterface> storageClient;
g_storageObjectBuilder = storageBuilder.get();
g_analyzerObjectBuilder = analyzerBuilder.get();
if (!storageconfig.empty())
{
if (doCreateIfNotExist)
{
createStorageIfNotExist( storageconfig);
}
storageClient.reset( strus::createStorageClient( g_storageObjectBuilder, g_errorBuffer, storageconfig));
if (!storageClient.get())
{
throw strus::runtime_error( _TXT("failed to create storage client"), storageconfig.c_str());
}
std::cerr << _TXT("strus RPC server is hosting storage ") << "'" << storageconfig << "'" << std::endl;
g_storageClient = storageClient.get();
}
// Start server:
std::cerr << "strus RPC server listening on port " << port << std::endl;
int err = strus_run_server( (unsigned short)(unsigned int)port, nofThreads, &g_glbctx);
if (err)
{
throw strus::runtime_error( _TXT("server terminated with error (see logs)"));
}
std::cerr << _TXT("strus RPC server terminated") << std::endl;
// Cleanup when done:
done_global_context();
return 0;
}
catch (const std::exception& e)
{
const char* errormsg = g_errorBuffer?g_errorBuffer->fetchError():0;
if (errormsg)
{
std::cerr << e.what() << ": " << errormsg << std::endl;
}
else
{
std::cerr << e.what() << std::endl;
}
}
std::cerr << _TXT("strus RPC server terminated") << std::endl;
done_global_context();
return -1;
}
