int main( int argc, const char* argv[]) { int rt = 0; strus::DebugTraceInterface* dbgtrace = strus::createDebugTrace_standard( 2); if (!dbgtrace) { std::cerr << _TXT("failed to create debug trace") << std::endl; return -1; } strus::local_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2, dbgtrace/*passed with ownership*/)); if (!errorBuffer.get()) { std::cerr << _TXT("failed to create error buffer") << std::endl; return -1; } try { bool printUsageAndExit = false; strus::ProgramOptions opt( errorBuffer.get(), argc, argv, 13, "h,help", "v,version", "license", "G,debug:", "t,tokenizer:", "n,normalizer:", "m,module:", "M,moduledir:", "q,quot:", "P,plain", "F,fileinput", "R,resourcedir:", "T,trace:"); if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("failed to parse program arguments")); } if (opt( "help")) printUsageAndExit = true; // Enable debugging selected with option 'debug': { std::vector<std::string> dbglist = opt.list( "debug"); std::vector<std::string>::const_iterator gi = dbglist.begin(), ge = dbglist.end(); for (; gi != ge; ++gi) { if (!dbgtrace->enable( *gi)) { throw strus::runtime_error(_TXT("failed to enable debug '%s'"), gi->c_str()); } } } strus::local_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get())); if (!moduleLoader.get()) throw std::runtime_error( _TXT("failed to create module loader")); if (opt("moduledir")) { std::vector<std::string> modirlist( opt.list("moduledir")); std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end(); for (; mi != me; ++mi) { moduleLoader->addModulePath( *mi); } moduleLoader->addSystemModulePath(); } if (opt("module")) { std::vector<std::string> modlist( opt.list("module")); std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end(); for (; mi != me; ++mi) { if (!moduleLoader->loadModule( *mi)) { throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str()); } } } if (opt("license")) { std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts(); std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end(); if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl; for (; ti != te; ++ti) { std::cout << *ti << std::endl; } std::cout << std::endl; if (!printUsageAndExit) return 0; } if (opt( "version")) { std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl; std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl; std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl; std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl; std::cout << _TXT("Strus analyzer version ") << STRUS_ANALYZER_VERSION_STRING << std::endl; std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl; std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts(); std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end(); if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl; for (; vi != ve; ++vi) { std::cout << *vi << std::endl; } if (!printUsageAndExit) return 0; } else if (!printUsageAndExit) { if (opt.nofargs() > 1) { std::cerr << _TXT("too many arguments") << std::endl; printUsageAndExit = true; rt = 1; } if (opt.nofargs() < 1) { std::cerr << _TXT("too few arguments") << std::endl; printUsageAndExit = true; rt = 2; } } if (printUsageAndExit) { std::cout << _TXT("usage:") << " strusAnalyze [options] <phrase>" << std::endl; std::cout << "<phrase> = " << _TXT("path to phrase to analyze") << std::endl; std::cout << " " << _TXT("file or '-' for stdin if option -F is specified)") << std::endl; std::cout << "description: " << _TXT("tokenizes and normalizes a text segment") << std::endl; std::cout << " " << _TXT("and prints the result to stdout.") << std::endl; std::cout << _TXT("options:") << std::endl; std::cout << "-h|--help" << std::endl; std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl; std::cout << "-v|--version" << std::endl; std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl; std::cout << "--license" << std::endl; std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl; std::cout << "-G|--debug <COMP>" << std::endl; std::cout << " " << _TXT("Issue debug messages for component <COMP> to stderr") << std::endl; std::cout << "-m|--module <MOD>" << std::endl; std::cout << " " << _TXT("Load components from module <MOD>") << std::endl; std::cout << "-M|--moduledir <DIR>" << std::endl; std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl; std::cout << "-R|--resourcedir <DIR>" << std::endl; std::cout << " " << _TXT("Search resource files for analyzer first in <DIR>") << std::endl; std::cout << "-t|--tokenizer <CALL>" << std::endl; std::cout << " " << _TXT("Use the tokenizer <CALL> (default 'content')") << std::endl; std::cout << "-n|--normalizer <CALL>" << std::endl; std::cout << " " << _TXT("Use the normalizer <CALL> (default 'orig')") << std::endl; std::cout << "-q|--quot <STR>" << std::endl; std::cout << " " << _TXT("Use the string <STR> as quote for the result (default \"\'\")") << std::endl; std::cout << "-P|--plain" << std::endl; std::cout << " " << _TXT("Print results without quotes and without an end of line for each result") << std::endl; std::cout << "-F|--fileinput" << std::endl; std::cout << " " << _TXT("Interpret phrase argument as a file name containing the input") << std::endl; std::cout << "-T|--trace <CONFIG>" << std::endl; std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl; std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl; return rt; } // Declare trace proxy objects: typedef strus::Reference<strus::TraceProxy> TraceReference; std::vector<TraceReference> trace; if (opt("trace")) { std::vector<std::string> tracecfglist( opt.list("trace")); std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end(); for (; ti != te; ++ti) { trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get())); } } std::string resultQuot = "'"; bool resultPlain = false; if (opt( "plain")) { resultPlain = true; resultQuot.clear(); } if (opt( "quot")) { resultQuot = opt[ "quot"]; } std::string phrasestring = opt[0]; std::string tokenizer( "content"); if (opt( "tokenizer")) { tokenizer = opt[ "tokenizer"]; } std::string normalizer( "orig"); if (opt( "normalizer")) { normalizer = opt[ "normalizer"]; } // Set paths for locating resources: if (opt("resourcedir")) { std::vector<std::string> pathlist( opt.list("resourcedir")); std::vector<std::string>::const_iterator pi = pathlist.begin(), pe = pathlist.end(); for (; pi != pe; ++pi) { moduleLoader->addResourcePath( *pi); } } // Create objects for analyzer: strus::local_ptr<strus::RpcClientMessagingInterface> messaging; strus::local_ptr<strus::RpcClientInterface> rpcClient; strus::local_ptr<strus::AnalyzerObjectBuilderInterface> analyzerBuilder; if (opt("rpc")) { messaging.reset( strus::createRpcClientMessaging( opt[ "rpc"], errorBuffer.get())); if (!messaging.get()) throw std::runtime_error( _TXT("failed to create rpc client messaging")); rpcClient.reset( strus::createRpcClient( messaging.get(), errorBuffer.get())); if (!rpcClient.get()) throw std::runtime_error( _TXT("failed to create rpc client")); (void)messaging.release(); analyzerBuilder.reset( rpcClient->createAnalyzerObjectBuilder()); if (!analyzerBuilder.get()) throw std::runtime_error( _TXT("failed to create rpc analyzer object builder")); } else { analyzerBuilder.reset( moduleLoader->createAnalyzerObjectBuilder()); if (!analyzerBuilder.get()) throw std::runtime_error( _TXT("failed to create analyzer object builder")); } // Create proxy objects if tracing enabled: { std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end(); for (; ti != te; ++ti) { strus::AnalyzerObjectBuilderInterface* proxy = (*ti)->createProxy( analyzerBuilder.get()); analyzerBuilder.release(); analyzerBuilder.reset( proxy); } } if (errorBuffer->hasError()) { throw std::runtime_error( _TXT("error in initialization")); } // Create objects for analyzer: strus::local_ptr<strus::QueryAnalyzerInstanceInterface> analyzer( analyzerBuilder->createQueryAnalyzer()); if (!analyzer.get()) throw std::runtime_error( _TXT("failed to create analyzer")); const strus::TextProcessorInterface* textproc = analyzerBuilder->getTextProcessor(); if (!textproc) throw std::runtime_error( _TXT("failed to get text processor")); std::string analyzerConfig = strus::string_format( "[Element]\nfeature = %s %s text", normalizer.c_str(), tokenizer.c_str()); // Create phrase type (tokenizer and normalizer): if (!strus::load_QueryAnalyzer_program_std( analyzer.get(), textproc, analyzerConfig, errorBuffer.get())) { throw strus::runtime_error( _TXT("failed to load query analyzer: %s"), errorBuffer->fetchError()); } // Load the phrase: bool queryIsFile = opt("fileinput"); if (queryIsFile) { int ec; std::string ps; if (phrasestring == "-") { ec = strus::readStdin( ps); if (ec) throw strus::runtime_error( _TXT("failed to read query from stdin (errno %u)"), ec); } else { ec = strus::readFile( phrasestring, ps); if (ec) throw strus::runtime_error(_TXT("failed to read query from file %s (errno %u)"), phrasestring.c_str(), ec); } phrasestring = ps; } // Analyze the phrase and print the result: strus::local_ptr<strus::QueryAnalyzerContextInterface> qryanactx( analyzer->createContext()); if (!qryanactx.get()) throw std::runtime_error( _TXT("failed to create query analyzer context")); qryanactx->putField( 1, "", phrasestring); strus::analyzer::QueryTermExpression qry = qryanactx->analyze(); if (errorBuffer->hasError()) throw std::runtime_error( _TXT("query analysis failed")); std::vector<strus::analyzer::QueryTerm> terms; std::vector<strus::analyzer::QueryTermExpression::Instruction>::const_iterator ii = qry.instructions().begin(), ie = qry.instructions().end(); for (int iidx=0; ii != ie; ++ii,++iidx) { if (ii->opCode() == strus::analyzer::QueryTermExpression::Instruction::Term) { const strus::analyzer::QueryTerm& term = qry.term( ii->idx()); if (resultPlain) { if (iidx) std::cout << " "; std::cout << term.value(); } else { std::cout << resultQuot << term.value() << resultQuot << std::endl; } } } if (errorBuffer->hasError()) { throw std::runtime_error( _TXT("error in analyze phrase")); } std::cerr << _TXT("done.") << std::endl; if (!dumpDebugTrace( dbgtrace, NULL/*filename ~ NULL = stderr*/)) { std::cerr << _TXT("failed to dump debug trace to file") << std::endl; } return 0; } catch (const std::bad_alloc&) { std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl; return -2; } catch (const std::runtime_error& e) { const char* errormsg = errorBuffer->fetchError(); if (errormsg) { std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl; } else { std::cerr << _TXT("ERROR ") << e.what() << std::endl; } } catch (const std::exception& e) { std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl; } if (!dumpDebugTrace( dbgtrace, NULL/*filename ~ NULL = stderr*/)) { std::cerr << _TXT("failed to dump debug trace to file") << std::endl; } return -1; }
int main( int argc, const char* argv[]) { int rt = 0; 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; } strus::ProgramOptions opt; bool printUsageAndExit = false; try { opt = strus::ProgramOptions( argc, argv, 11, "h,help", "v,version", "license", "t,tokenizer:", "n,normalizer:", "m,module:", "M,moduledir:", "q,quot:", "p,plain", "R,resourcedir:", "T,trace:"); if (opt( "help")) printUsageAndExit = true; std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get())); if (!moduleLoader.get()) throw strus::runtime_error(_TXT("failed to create module loader")); if (opt("moduledir")) { std::vector<std::string> modirlist( opt.list("moduledir")); std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end(); for (; mi != me; ++mi) { moduleLoader->addModulePath( *mi); } moduleLoader->addSystemModulePath(); } if (opt("module")) { std::vector<std::string> modlist( opt.list("module")); std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end(); for (; mi != me; ++mi) { if (!moduleLoader->loadModule( *mi)) { throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str()); } } } if (opt("license")) { std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts(); std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end(); if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl; for (; ti != te; ++ti) { std::cout << *ti << std::endl; } std::cerr << std::endl; if (!printUsageAndExit) return 0; } if (opt( "version")) { std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl; std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl; std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl; std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl; std::cout << _TXT("Strus analyzer version ") << STRUS_ANALYZER_VERSION_STRING << std::endl; std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl; std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts(); std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end(); if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl; for (; vi != ve; ++vi) { std::cout << *vi << std::endl; } if (!printUsageAndExit) return 0; } else if (!printUsageAndExit) { if (opt.nofargs() > 1) { std::cerr << _TXT("too many arguments") << std::endl; printUsageAndExit = true; rt = 1; } if (opt.nofargs() < 1) { std::cerr << _TXT("too few arguments") << std::endl; printUsageAndExit = true; rt = 2; } } if (printUsageAndExit) { std::cout << _TXT("usage:") << " strusAnalyze [options] <phrasepath>" << std::endl; std::cout << "<phrasepath> = " << _TXT("path to phrase to analyze ('-' for stdin)") << std::endl; std::cout << "description: " << _TXT("tokenizes and normalizes a text segment") << std::endl; std::cout << " " << _TXT("and prints the result to stdout.") << std::endl; std::cout << _TXT("options:") << std::endl; std::cout << "-h|--help" << std::endl; std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl; std::cout << "-v|--version" << std::endl; std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl; std::cout << "--license" << std::endl; std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl; std::cout << "-m|--module <MOD>" << std::endl; std::cout << " " << _TXT("Load components from module <MOD>") << std::endl; std::cout << "-M|--moduledir <DIR>" << std::endl; std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl; std::cout << "-R|--resourcedir <DIR>" << std::endl; std::cout << " " << _TXT("Search resource files for analyzer first in <DIR>") << std::endl; std::cout << "-t|--tokenizer <CALL>" << std::endl; std::cout << " " << _TXT("Use the tokenizer <CALL> (default 'content')") << std::endl; std::cout << "-n|--normalizer <CALL>" << std::endl; std::cout << " " << _TXT("Use the normalizer <CALL> (default 'orig')") << std::endl; std::cout << "-q|--quot <STR>" << std::endl; std::cout << " " << _TXT("Use the string <STR> as quote for the result (default \"\'\")") << std::endl; std::cout << "-p|--plain" << std::endl; std::cout << " " << _TXT("Do not print position and define default quotes as empty") << std::endl; std::cout << "-T|--trace <CONFIG>" << std::endl; std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl; std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl; return rt; } // Declare trace proxy objects: typedef strus::Reference<strus::TraceProxy> TraceReference; std::vector<TraceReference> trace; if (opt("trace")) { std::vector<std::string> tracecfglist( opt.list("trace")); std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end(); for (; ti != te; ++ti) { trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get())); } } std::string resultQuot = "'"; bool resultPlain = false; if (opt( "plain")) { resultPlain = true; resultQuot.clear(); } if (opt( "quot")) { resultQuot = opt[ "quot"]; } std::string docpath = opt[0]; std::string tokenizer( "content"); if (opt( "tokenizer")) { tokenizer = opt[ "tokenizer"]; } std::string normalizer( "orig"); if (opt( "normalizer")) { normalizer = opt[ "normalizer"]; } // Set paths for locating resources: if (opt("resourcedir")) { std::vector<std::string> pathlist( opt.list("resourcedir")); std::vector<std::string>::const_iterator pi = pathlist.begin(), pe = pathlist.end(); for (; pi != pe; ++pi) { moduleLoader->addResourcePath( *pi); } } // Create root object for analyzer: std::auto_ptr<strus::AnalyzerObjectBuilderInterface> analyzerBuilder( moduleLoader->createAnalyzerObjectBuilder()); if (!analyzerBuilder.get()) throw strus::runtime_error(_TXT("failed to create analyzer object builder")); // Create proxy objects if tracing enabled: { std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end(); for (; ti != te; ++ti) { strus::AnalyzerObjectBuilderInterface* proxy = (*ti)->createProxy( analyzerBuilder.get()); analyzerBuilder.release(); analyzerBuilder.reset( proxy); } } // Create objects for analyzer: std::auto_ptr<strus::QueryAnalyzerInterface> analyzer( analyzerBuilder->createQueryAnalyzer()); if (!analyzer.get()) throw strus::runtime_error(_TXT("failed to create analyzer")); const strus::TextProcessorInterface* textproc = analyzerBuilder->getTextProcessor(); if (!textproc) throw strus::runtime_error(_TXT("failed to get text processor")); // Create phrase type (tokenizer and normalizer): std::string phraseType; if (!strus::loadQueryAnalyzerPhraseType( *analyzer, textproc, phraseType, "", normalizer, tokenizer, errorBuffer.get())) { throw strus::runtime_error(_TXT("failed to load analyze phrase type")); } // Load the phrase: std::string phrase; if (docpath == "-") { unsigned int ec = strus::readStdin( phrase); if (ec) throw strus::runtime_error( _TXT( "error reading input from stdin (errno %u)"), ec); } else { unsigned int ec = strus::readFile( docpath, phrase); if (ec) throw strus::runtime_error( _TXT( "error reading input file '%s' (errno %u)"), docpath.c_str(), ec); } // Analyze the phrase and print the result: std::vector<strus::analyzer::Term> terms = analyzer->analyzePhrase( phraseType, phrase); std::sort( terms.begin(), terms.end(), TermOrder()); std::vector<strus::analyzer::Term>::const_iterator ti = terms.begin(), te = terms.end(); for (; ti != te; ++ti) { if (!resultPlain) { std::cout << ti->pos() << " "; } std::cout << resultQuot << ti->value() << resultQuot << std::endl; } if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("error in analyze phrase")); } return 0; } catch (const std::bad_alloc&) { std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl; } catch (const std::runtime_error& e) { const char* errormsg = errorBuffer->fetchError(); if (errormsg) { std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl; } else { std::cerr << _TXT("ERROR ") << e.what() << std::endl; } } catch (const std::exception& e) { std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl; } return -1; }
int main( int argc_, const char* argv_[]) { int rt = 0; 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; } strus::ProgramOptions opt; bool printUsageAndExit = false; try { opt = strus::ProgramOptions( argc_, argv_, 14, "h,help", "v,version", "license", "Q,quiet", "u,user:"******"N,nofranks:", "I,firstrank:", "D,time", "m,module:", "M,moduledir:", "R,resourcedir:", "s,storage:", "r,rpc:", "T,trace:"); if (opt( "help")) printUsageAndExit = true; std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get())); if (!moduleLoader.get()) throw strus::runtime_error(_TXT("failed to create module loader")); if (opt("moduledir")) { if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc"); std::vector<std::string> modirlist( opt.list("moduledir")); std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end(); for (; mi != me; ++mi) { moduleLoader->addModulePath( *mi); } moduleLoader->addSystemModulePath(); } if (opt("module")) { if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--module", "--rpc"); std::vector<std::string> modlist( opt.list("module")); std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end(); for (; mi != me; ++mi) { if (!moduleLoader->loadModule( *mi)) { throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str()); } } } if (opt("license")) { std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts(); std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end(); if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl; for (; ti != te; ++ti) { std::cout << *ti << std::endl; } std::cerr << std::endl; if (!printUsageAndExit) return 0; } if (opt( "version")) { std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl; std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl; std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl; std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl; std::cout << _TXT("Strus analyzer version ") << STRUS_ANALYZER_VERSION_STRING << std::endl; std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl; std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl; std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts(); std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end(); if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl; for (; vi != ve; ++vi) { std::cout << *vi << std::endl; } if (!printUsageAndExit) return 0; } else if (!printUsageAndExit) { if (opt.nofargs() > 3) { std::cerr << _TXT("too many arguments") << std::endl; printUsageAndExit = true; rt = 1; } if (opt.nofargs() < 3) { std::cerr << _TXT("too few arguments") << std::endl; printUsageAndExit = true; rt = 2; } } if (printUsageAndExit) { std::cout << _TXT("usage:") << " strusQuery [options] <anprg> <qeprg> <query>" << std::endl; std::cout << "<anprg> = " << _TXT("path of query analyzer program") << std::endl; std::cout << "<qeprg> = " << _TXT("path of query eval program") << std::endl; std::cout << "<query> = " << _TXT("path of query or '-' for stdin") << std::endl; std::cout << _TXT("description: Executes a query or a list of queries from a file.") << std::endl; std::cout << _TXT("options:") << std::endl; std::cout << "-h|--help" << std::endl; std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl; std::cout << "-v|--version" << std::endl; std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl; std::cout << "--license" << std::endl; std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl; std::cout << "-s|--storage <CONFIG>" << std::endl; std::cout << " " << _TXT("Define the storage configuration string as <CONFIG>") << std::endl; if (!opt("rpc")) { std::cout << _TXT(" <CONFIG> is a semicolon ';' separated list of assignments:") << std::endl; printStorageConfigOptions( std::cout, moduleLoader.get(), (opt("storage")?opt["storage"]:""), errorBuffer.get()); } std::cout << "-u|--user <NAME>" << std::endl; std::cout << " " << _TXT("Use user name <NAME> for the query") << std::endl; std::cout << "-N|--nofranks <N>" << std::endl; std::cout << " " << _TXT("Return maximum <N> ranks as query result") << std::endl; std::cout << "-I|--firstrank <N>" << std::endl; std::cout << " " << _TXT("Return the result starting with rank <N> as first rank") << std::endl; std::cout << "-Q|--quiet" << std::endl; std::cout << " " << _TXT("No output of results") << std::endl; std::cout << "-D|--time" << std::endl; std::cout << " " << _TXT("Do print duration of pure query evaluation") << std::endl; std::cout << "-m|--module <MOD>" << std::endl; std::cout << " " << _TXT("Load components from module <MOD>") << std::endl; std::cout << "-M|--moduledir <DIR>" << std::endl; std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl; std::cout << "-R|--resourcedir <DIR>" << std::endl; std::cout << " " << _TXT("Search resource files for analyzer first in <DIR>") << std::endl; std::cout << "-r|--rpc <ADDR>" << std::endl; std::cout << " " << _TXT("Execute the command on the RPC server specified by <ADDR>") << std::endl; std::cout << "-T|--trace <CONFIG>" << std::endl; std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl; std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl; return rt; } // Parse arguments: bool quiet = opt( "quiet"); bool measureDuration = opt( "time"); std::string username; std::size_t nofRanks = 20; std::size_t firstRank = 0; std::string storagecfg; if (opt("user")) { username = opt[ "user"]; } if (opt("nofranks")) { nofRanks = opt.asUint( "nofranks"); } if (opt("firstrank")) { firstRank = opt.asUint( "firstrank"); } if (opt("storage")) { if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc"); storagecfg = opt["storage"]; } std::string analyzerprg = opt[0]; std::string queryprg = opt[1]; std::string querypath = opt[2]; // Declare trace proxy objects: typedef strus::Reference<strus::TraceProxy> TraceReference; std::vector<TraceReference> trace; if (opt("trace")) { std::vector<std::string> tracecfglist( opt.list("trace")); std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end(); for (; ti != te; ++ti) { trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get())); } } // Set paths for locating resources: if (opt("resourcedir")) { std::vector<std::string> pathlist( opt.list("resourcedir")); std::vector<std::string>::const_iterator pi = pathlist.begin(), pe = pathlist.end(); for (; pi != pe; ++pi) { moduleLoader->addResourcePath( *pi); } } std::string resourcepath; if (0!=strus::getParentPath( analyzerprg, resourcepath)) { throw strus::runtime_error( _TXT("failed to evaluate resource path")); } if (!resourcepath.empty()) { moduleLoader->addResourcePath( resourcepath); } // Create objects for query evaluation: std::auto_ptr<strus::RpcClientMessagingInterface> messaging; std::auto_ptr<strus::RpcClientInterface> rpcClient; std::auto_ptr<strus::AnalyzerObjectBuilderInterface> analyzerBuilder; std::auto_ptr<strus::StorageObjectBuilderInterface> storageBuilder; if (opt("rpc")) { messaging.reset( strus::createRpcClientMessaging( opt[ "rpc"], errorBuffer.get())); if (!messaging.get()) throw strus::runtime_error(_TXT("failed to create rpc client messaging")); rpcClient.reset( strus::createRpcClient( messaging.get(), errorBuffer.get())); if (!rpcClient.get()) throw strus::runtime_error(_TXT("failed to create rpc client")); (void)messaging.release(); analyzerBuilder.reset( rpcClient->createAnalyzerObjectBuilder()); if (!analyzerBuilder.get()) throw strus::runtime_error(_TXT("failed to create rpc analyzer object builder")); storageBuilder.reset( rpcClient->createStorageObjectBuilder()); if (!storageBuilder.get()) throw strus::runtime_error(_TXT("failed to create rpc storage object builder")); } else { analyzerBuilder.reset( moduleLoader->createAnalyzerObjectBuilder()); if (!analyzerBuilder.get()) throw strus::runtime_error(_TXT("failed to create analyzer object builder")); storageBuilder.reset( moduleLoader->createStorageObjectBuilder()); if (!storageBuilder.get()) throw strus::runtime_error(_TXT("failed to create storage object 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); } // Create objects: std::auto_ptr<strus::StorageClientInterface> storage( strus::createStorageClient( storageBuilder.get(), errorBuffer.get(), storagecfg)); if (!storage.get()) throw strus::runtime_error(_TXT("failed to create storage client")); strus::utils::ScopedPtr<strus::QueryAnalyzerInterface> analyzer( analyzerBuilder->createQueryAnalyzer()); if (!analyzer.get()) throw strus::runtime_error(_TXT("failed to create query analyzer")); strus::utils::ScopedPtr<strus::QueryEvalInterface> qeval( storageBuilder->createQueryEval()); if (!qeval.get()) throw strus::runtime_error(_TXT("failed to create query evaluation interface")); const strus::QueryProcessorInterface* qproc = storageBuilder->getQueryProcessor(); if (!qproc) throw strus::runtime_error(_TXT("failed to get query processor")); const strus::TextProcessorInterface* textproc = analyzerBuilder->getTextProcessor(); if (!textproc) throw strus::runtime_error(_TXT("failed to get text processor")); // Load query analyzer program: unsigned int ec; std::string analyzerProgramSource; ec = strus::readFile( analyzerprg, analyzerProgramSource); if (ec) throw strus::runtime_error(_TXT("failed to load analyzer program %s (errno %u)"), analyzerprg.c_str(), ec); if (!strus::loadQueryAnalyzerProgram( *analyzer, textproc, analyzerProgramSource, errorBuffer.get())) { throw strus::runtime_error(_TXT("failed to load query analyzer program")); } // Load query evaluation program: std::string qevalProgramSource; ec = strus::readFile( queryprg, qevalProgramSource); if (ec) throw strus::runtime_error(_TXT("failed to load query eval program %s (errno %u)"), queryprg.c_str(), ec); if (!strus::loadQueryEvalProgram( *qeval, qproc, qevalProgramSource, errorBuffer.get())) { throw strus::runtime_error(_TXT("failed to load query evaluation program")); } // Load query: std::string querystring; if (querypath == "-") { ec = strus::readStdin( querystring); if (ec) throw strus::runtime_error( _TXT("failed to read query string from stdin (errno %u)"), ec); } else { ec = strus::readFile( querypath, querystring); if (ec) throw strus::runtime_error(_TXT("failed to read query string from file %s (errno %u)"), querypath.c_str(), ec); } unsigned int nofQueries = 0; double startTime = 0.0; if (measureDuration) { startTime = getTimeStamp(); } std::string::const_iterator si = querystring.begin(), se = querystring.end(); std::string qs; while (strus::scanNextProgram( qs, si, se, errorBuffer.get())) { ++nofQueries; std::auto_ptr<strus::QueryInterface> query( qeval->createQuery( storage.get())); if (!query.get()) throw strus::runtime_error(_TXT("failed to create query object")); if (!strus::loadQuery( *query, analyzer.get(), qproc, qs, errorBuffer.get())) { throw strus::runtime_error(_TXT("failed to load query from source")); } query->setMaxNofRanks( nofRanks); query->setMinRank( firstRank); if (!username.empty()) { query->addUserName( username); } strus::QueryResult result = query->evaluate(); if (!quiet) { std::cout << strus::string_format( _TXT("evaluated till pass %u, got %u ranks (%u without restrictions applied):"), result.evaluationPass(), result.nofDocumentsRanked(), result.nofDocumentsVisited()) << std::endl; std::cout << strus::string_format( _TXT("ranked list (starting with rank %u, maximum %u results):"), firstRank, nofRanks) << std::endl; } std::vector<strus::ResultDocument>::const_iterator wi = result.ranks().begin(), we = result.ranks().end(); if (!quiet) { for (int widx=1; wi != we; ++wi,++widx) { std::cout << strus::string_format( _TXT( "[%u] %u score %f"), widx, wi->docno(), wi->weight()) << std::endl; std::vector<strus::SummaryElement>::const_iterator ai = wi->summaryElements().begin(), ae = wi->summaryElements().end(); for (; ai != ae; ++ai) { std::cout << "\t" << ai->name(); if (ai->index() >= 0) { std::cout << "[" << ai->index() << "]"; } std::cout << " = '" << ai->value() << "'"; std::cout << " " << ai->weight() << std::endl; } } } } if (measureDuration) { double endTime = getTimeStamp(); double duration = endTime - startTime; std::cerr << strus::string_format( _TXT("evaluated %u queries in %.4f seconds"), nofQueries, duration) << std::endl; } if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("unhandled error in command line query")); } return 0; } catch (const std::bad_alloc&) { std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl; } catch (const std::runtime_error& e) { const char* errormsg = errorBuffer->fetchError(); if (errormsg) { std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl; } else { std::cerr << _TXT("ERROR ") << e.what() << std::endl; } } catch (const std::exception& e) { std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl; } return -1; }
int main( int argc, const char* argv[]) { int rt = 0; 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; } strus::ProgramOptions opt; bool printUsageAndExit = false; try { opt = strus::ProgramOptions( argc, argv, 6, "h,help", "v,version", "license", "m,module:", "M,moduledir:", "T,trace:"); if (opt( "help")) { printUsageAndExit = true; } std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get())); if (!moduleLoader.get()) throw strus::runtime_error(_TXT("error creating module loader")); if (opt("moduledir")) { std::vector<std::string> modirlist( opt.list("moduledir")); std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end(); for (; mi != me; ++mi) { moduleLoader->addModulePath( *mi); } moduleLoader->addSystemModulePath(); } if (opt("module")) { std::vector<std::string> modlist( opt.list("module")); std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end(); for (; mi != me; ++mi) { if (!moduleLoader->loadModule( *mi)) { throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str()); } } } if (opt("license")) { std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts(); std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end(); if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl; for (; ti != te; ++ti) { std::cout << *ti << std::endl; } std::cerr << std::endl; if (!printUsageAndExit) return 0; } if (opt( "version")) { std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl; std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl; std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl; std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl; std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl; std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl; std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts(); std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end(); if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl; for (; vi != ve; ++vi) { std::cout << *vi << std::endl; } if (!printUsageAndExit) return 0; } else if (!printUsageAndExit) { if (opt.nofargs() < 2) { std::cerr << _TXT("too few arguments") << std::endl; printUsageAndExit = true; rt = 1; } if (opt.nofargs() > 2) { std::cerr << _TXT("too many arguments") << std::endl; printUsageAndExit = true; rt = 2; } } if (printUsageAndExit) { std::cout << _TXT("usage:") << " strusAlterMetaData [options] <config> <cmds>" << std::endl; std::cout << "<config> : " << _TXT("configuration string of the storage") << std::endl; std::cout << " " << _TXT("semicolon';' separated list of assignments:") << std::endl; printStorageConfigOptions( std::cout, moduleLoader.get(), (opt.nofargs()>=1?opt[0]:""), errorBuffer.get()); std::cout << "<cmds> : " << _TXT("semicolon separated list of commands:") << std::endl; std::cout << " alter <name> <newname> <newtype>" << std::endl; std::cout << " <name> :" << _TXT("name of the element to change") << std::endl; std::cout << " <newname> :" << _TXT("new name of the element") << std::endl; std::cout << " <newtype> :" << _TXT("new type (*) of the element") << std::endl; std::cout << " add <name> <type>" << std::endl; std::cout << " <name> :" << _TXT("name of the element to add") << std::endl; std::cout << " <type> :" << _TXT("type (*) of the element to add") << std::endl; std::cout << " delete <name>" << std::endl; std::cout << " <name> :" << _TXT("name of the element to remove") << std::endl; std::cout << " rename <name> <newname>" << std::endl; std::cout << " <name> :" << _TXT("name of the element to rename") << std::endl; std::cout << " <newname> :" << _TXT("new name of the element") << std::endl; std::cout << " clear <name>" << std::endl; std::cout << " <name> :" << _TXT("name of the element to clear all values") << std::endl; std::cout << "(*) :" << _TXT("type of an element is one of the following:") << std::endl; std::cout << " INT8 :" << _TXT("one byte signed integer value") << std::endl; std::cout << " UINT8 :" << _TXT("one byte unsigned integer value") << std::endl; std::cout << " INT16 :" << _TXT("two bytes signed integer value") << std::endl; std::cout << " UINT16 :" << _TXT("two bytes unsigned integer value") << std::endl; std::cout << " INT32 :" << _TXT("four bytes signed integer value") << std::endl; std::cout << " UINT32 :" << _TXT("four bytes unsigned integer value") << std::endl; std::cout << " FLOAT16 :" << _TXT("two bytes floating point value (IEEE 754 small)") << std::endl; std::cout << " FLOAT32 :" << _TXT("four bytes floating point value (IEEE 754 single)") << std::endl; std::cout << _TXT("description: Executes a list of alter the meta data table commands.") << std::endl; std::cout << _TXT("options:") << std::endl; std::cout << "-h|--help" << std::endl; std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl; std::cout << "-v|--version" << std::endl; std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl; std::cout << "--license" << std::endl; std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl; std::cout << "-m|--module <MOD>" << std::endl; std::cout << " " << _TXT("Load components from module <MOD>") << std::endl; std::cout << "-M|--moduledir <DIR>" << std::endl; std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl; std::cout << "-T|--trace <CONFIG>" << std::endl; std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl; std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl; return rt; } // Parse arguments: std::string storagecfg = opt[0]; std::vector<AlterMetaDataCommand> cmds = parseCommands( opt[1]); // Declare trace proxy objects: typedef strus::Reference<strus::TraceProxy> TraceReference; std::vector<TraceReference> trace; if (opt("trace")) { std::vector<std::string> tracecfglist( opt.list("trace")); std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end(); for (; ti != te; ++ti) { trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get())); } } // Create objects for altering the meta data table: std::auto_ptr<strus::StorageObjectBuilderInterface> builder; std::auto_ptr<strus::StorageAlterMetaDataTableInterface> md; builder.reset( moduleLoader->createStorageObjectBuilder()); if (!builder.get()) throw strus::runtime_error(_TXT("failed to create storage object builder")); // Create proxy objects if tracing enabled: std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end(); for (; ti != te; ++ti) { strus::StorageObjectBuilderInterface* builderproxy = (*ti)->createProxy( builder.get()); builder.release(); builder.reset( builderproxy); } md.reset( strus::createAlterMetaDataTable( builder.get(), errorBuffer.get(), storagecfg)); if (!md.get()) throw strus::runtime_error(_TXT("failed to create storage alter metadata table structure")); // Execute alter meta data table commands: std::vector<AlterMetaDataCommand>::const_iterator ci = cmds.begin(), ce = cmds.end(); for (; ci != ce; ++ci) { switch (ci->id()) { case AlterMetaDataCommand::Alter: md->alterElement( ci->name(), ci->newname(), ci->type()); break; case AlterMetaDataCommand::Add: md->addElement( ci->name(), ci->type()); break; case AlterMetaDataCommand::Delete: md->deleteElement( ci->name()); break; case AlterMetaDataCommand::Rename: md->renameElement( ci->name(), ci->newname()); break; case AlterMetaDataCommand::Clear: md->clearElement( ci->name()); break; } } std::cerr << _TXT("updating meta data table changes...") << std::endl; if (!md->commit()) throw strus::runtime_error(_TXT("alter meta data commit failed")); std::cerr << _TXT("done") << std::endl; if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("unhandled error in alter meta data")); } return 0; } catch (const std::bad_alloc&) { std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl; } catch (const std::runtime_error& e) { const char* errormsg = errorBuffer->fetchError(); if (errormsg) { std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl; } else { std::cerr << _TXT("ERROR ") << e.what() << std::endl; } } catch (const std::exception& e) { std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl; } return -1; }
int main( int argc_, const char* argv_[]) { int rt = 0; strus::DebugTraceInterface* dbgtrace = strus::createDebugTrace_standard( 2); if (!dbgtrace) { std::cerr << _TXT("failed to create debug trace") << std::endl; return -1; } strus::local_ptr<strus::ErrorBufferInterface> errorBuffer( strus::createErrorBuffer_standard( 0, 2, dbgtrace/*passed with ownership*/)); if (!errorBuffer.get()) { delete dbgtrace; std::cerr << _TXT("failed to create error buffer") << std::endl; return -1; } try { bool printUsageAndExit = false; bool withDebugInfo = false; strus::ProgramOptions opt( errorBuffer.get(), argc_, argv_, 18, "h,help", "v,version", "license", "G,debug:", "Q,quiet", "u,user:"******"N,nofranks:", "I,firstrank:", "F,fileinput", "D,time", "m,module:", "M,moduledir:", "R,resourcedir:", "s,storage:", "S,configfile:", "r,rpc:", "T,trace:", "V,verbose"); if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("failed to parse program arguments")); } if (opt( "help")) printUsageAndExit = true; // Enable debugging selected with option 'debug': { std::vector<std::string> dbglist = opt.list( "debug"); std::vector<std::string>::const_iterator gi = dbglist.begin(), ge = dbglist.end(); for (; gi != ge; ++gi) { if (*gi == "weighting") { withDebugInfo = true; } if (!dbgtrace->enable( *gi)) { throw strus::runtime_error(_TXT("failed to enable debug '%s'"), gi->c_str()); } } } strus::local_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get())); if (!moduleLoader.get()) throw std::runtime_error( _TXT("failed to create module loader")); if (opt("moduledir")) { if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc"); std::vector<std::string> modirlist( opt.list("moduledir")); std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end(); for (; mi != me; ++mi) { moduleLoader->addModulePath( *mi); } moduleLoader->addSystemModulePath(); } if (opt("module")) { if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--module", "--rpc"); std::vector<std::string> modlist( opt.list("module")); std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end(); for (; mi != me; ++mi) { if (!moduleLoader->loadModule( *mi)) { throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str()); } } } if (opt("license")) { std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts(); std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end(); if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl; for (; ti != te; ++ti) { std::cout << *ti << std::endl; } std::cout << std::endl; if (!printUsageAndExit) return 0; } if (opt( "version")) { std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl; std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl; std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl; std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl; std::cout << _TXT("Strus analyzer version ") << STRUS_ANALYZER_VERSION_STRING << std::endl; std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl; std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl; std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts(); std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end(); if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl; for (; vi != ve; ++vi) { std::cout << *vi << std::endl; } if (!printUsageAndExit) return 0; } else if (!printUsageAndExit) { if (opt.nofargs() > 3) { std::cerr << _TXT("too many arguments") << std::endl; printUsageAndExit = true; rt = 1; } if (opt.nofargs() < 3) { std::cerr << _TXT("too few arguments") << std::endl; printUsageAndExit = true; rt = 2; } } if (printUsageAndExit) { std::cout << _TXT("usage:") << " strusQuery [options] <anprg> <qeprg> <query>" << std::endl; std::cout << "<anprg> = " << _TXT("path of query analyzer program") << std::endl; std::cout << "<qeprg> = " << _TXT("path of query eval program") << std::endl; std::cout << "<query> = " << _TXT("query string") << std::endl; std::cout << " " << _TXT("file or '-' for stdin if option -F is specified)") << std::endl; std::cout << _TXT("description: Executes a query or a list of queries from a file.") << std::endl; std::cout << _TXT("options:") << std::endl; std::cout << "-h|--help" << std::endl; std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl; std::cout << "-v|--version" << std::endl; std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl; std::cout << "--license" << std::endl; std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl; std::cout << "-s|--storage <CONFIG>" << std::endl; std::cout << " " << _TXT("Define the storage configuration string as <CONFIG>") << std::endl; if (!opt("rpc")) { std::cout << _TXT(" <CONFIG> is a semicolon ';' separated list of assignments:") << std::endl; printStorageConfigOptions( std::cout, moduleLoader.get(), (opt("storage")?opt["storage"]:""), errorBuffer.get()); } std::cout << "-S|--configfile <FILENAME>" << std::endl; std::cout << " " << _TXT("Define the storage configuration file as <FILENAME>") << std::endl; std::cout << " " << _TXT("<FILENAME> is a file containing the configuration string") << std::endl; std::cout << "-u|--user <NAME>" << std::endl; std::cout << " " << _TXT("Use user name <NAME> for the query") << std::endl; std::cout << "-N|--nofranks <N>" << std::endl; std::cout << " " << _TXT("Return maximum <N> ranks as query result") << std::endl; std::cout << "-I|--firstrank <N>" << std::endl; std::cout << " " << _TXT("Return the result starting with rank <N> as first rank") << std::endl; std::cout << "-Q|--quiet" << std::endl; std::cout << " " << _TXT("No output of results") << std::endl; std::cout << "-D|--time" << std::endl; std::cout << " " << _TXT("Do print duration of pure query evaluation") << std::endl; std::cout << "-F|--fileinput" << std::endl; std::cout << " " << _TXT("Interpret query argument as a file name containing the input") << std::endl; std::cout << "-G|--debug <COMP>" << std::endl; std::cout << " " << _TXT("Issue debug messages for component <COMP> to stderr") << std::endl; std::cout << "-m|--module <MOD>" << std::endl; std::cout << " " << _TXT("Load components from module <MOD>") << std::endl; std::cout << "-M|--moduledir <DIR>" << std::endl; std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl; std::cout << "-R|--resourcedir <DIR>" << std::endl; std::cout << " " << _TXT("Search resource files for analyzer first in <DIR>") << std::endl; std::cout << "-r|--rpc <ADDR>" << std::endl; std::cout << " " << _TXT("Execute the command on the RPC server specified by <ADDR>") << std::endl; std::cout << "-T|--trace <CONFIG>" << std::endl; std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl; std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl; std::cout << "-V|--verbose" << std::endl; std::cout << " " << _TXT("Verbose mode: Print some info like query analysis") << std::endl; return rt; } // Parse arguments: bool quiet = opt( "quiet"); bool doMeasureDuration = opt( "time"); bool verbose = opt("verbose"); std::string username; std::size_t nofRanks = 20; std::size_t firstRank = 0; std::string storagecfg; bool queryIsFile = opt("fileinput"); if (opt("user")) { username = opt[ "user"]; } if (opt("nofranks")) { nofRanks = opt.asUint( "nofranks"); } if (opt("firstrank")) { firstRank = opt.asUint( "firstrank"); } if (opt("configfile")) { if (opt("storage")) throw strus::runtime_error(_TXT("conflicting configuration options specified: '%s' and '%s'"), "--storage", "--configfile"); std::string configfile = opt[ "configfile"]; int ec = strus::readFile( configfile, storagecfg); if (ec) throw strus::runtime_error(_TXT("failed to read configuration file %s (errno %u)"), configfile.c_str(), ec); std::string::iterator di = storagecfg.begin(), de = storagecfg.end(); for (; di != de; ++di) { if ((unsigned char)*di < 32) *di = ' '; } } if (opt("storage")) { if (opt("configfile")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--storage", "--configfile"); storagecfg = opt["storage"]; } // Declare trace proxy objects: typedef strus::Reference<strus::TraceProxy> TraceReference; std::vector<TraceReference> trace; if (opt("trace")) { std::vector<std::string> tracecfglist( opt.list("trace")); std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end(); for (; ti != te; ++ti) { trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get())); } } // Enable debugging selected with option 'debug': { std::vector<std::string> dbglist = opt.list( "debug"); std::vector<std::string>::const_iterator gi = dbglist.begin(), ge = dbglist.end(); for (; gi != ge; ++gi) { if (!dbgtrace->enable( *gi)) { throw strus::runtime_error(_TXT("failed to enable debug '%s'"), gi->c_str()); } } } // Set paths for locating resources: if (opt("resourcedir")) { std::vector<std::string> pathlist( opt.list("resourcedir")); std::vector<std::string>::const_iterator pi = pathlist.begin(), pe = pathlist.end(); for (; pi != pe; ++pi) { moduleLoader->addResourcePath( *pi); } } std::string analyzerprg = getFileArg( opt[0], moduleLoader.get()); std::string queryprg = getFileArg( opt[1], moduleLoader.get()); std::string querystring = opt[2]; if (errorBuffer->hasError()) { throw std::runtime_error( _TXT("error in initialization")); } // Create objects for query evaluation: strus::local_ptr<strus::RpcClientMessagingInterface> messaging; strus::local_ptr<strus::RpcClientInterface> rpcClient; strus::local_ptr<strus::AnalyzerObjectBuilderInterface> analyzerBuilder; strus::local_ptr<strus::StorageObjectBuilderInterface> storageBuilder; if (opt("rpc")) { messaging.reset( strus::createRpcClientMessaging( opt[ "rpc"], errorBuffer.get())); if (!messaging.get()) throw std::runtime_error( _TXT("failed to create rpc client messaging")); rpcClient.reset( strus::createRpcClient( messaging.get(), errorBuffer.get())); if (!rpcClient.get()) throw std::runtime_error( _TXT("failed to create rpc client")); (void)messaging.release(); analyzerBuilder.reset( rpcClient->createAnalyzerObjectBuilder()); if (!analyzerBuilder.get()) throw std::runtime_error( _TXT("failed to create rpc analyzer object builder")); storageBuilder.reset( rpcClient->createStorageObjectBuilder()); if (!storageBuilder.get()) throw std::runtime_error( _TXT("failed to create rpc storage object builder")); } else { analyzerBuilder.reset( moduleLoader->createAnalyzerObjectBuilder()); if (!analyzerBuilder.get()) throw std::runtime_error( _TXT("failed to create analyzer object builder")); storageBuilder.reset( moduleLoader->createStorageObjectBuilder()); if (!storageBuilder.get()) throw std::runtime_error( _TXT("failed to create storage object 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); } // Create objects: strus::local_ptr<strus::StorageClientInterface> storage( strus::createStorageClient( storageBuilder.get(), errorBuffer.get(), storagecfg)); if (!storage.get()) throw strus::runtime_error(_TXT("failed to create storage client: %s"), errorBuffer->fetchError()); strus::local_ptr<strus::QueryAnalyzerInstanceInterface> analyzer( analyzerBuilder->createQueryAnalyzer()); if (!analyzer.get()) throw strus::runtime_error(_TXT("failed to create query analyzer: %s"), errorBuffer->fetchError()); strus::local_ptr<strus::QueryEvalInterface> qeval( storageBuilder->createQueryEval()); if (!qeval.get()) throw strus::runtime_error(_TXT("failed to create query evaluation interface: %s"), errorBuffer->fetchError()); const strus::QueryProcessorInterface* qproc = storageBuilder->getQueryProcessor(); if (!qproc) throw strus::runtime_error(_TXT("failed to get query processor: %s"), errorBuffer->fetchError()); const strus::TextProcessorInterface* textproc = analyzerBuilder->getTextProcessor(); if (!textproc) throw strus::runtime_error(_TXT("failed to get text processor: %s"), errorBuffer->fetchError()); if (errorBuffer->hasError()) throw strus::runtime_error(_TXT("error in initialization: %s"), errorBuffer->fetchError()); // Load query analyzer program: if (!strus::load_QueryAnalyzer_programfile_std( analyzer.get(), textproc, analyzerprg, errorBuffer.get())) { throw strus::runtime_error(_TXT("failed to load query analyzer program: %s"), errorBuffer->fetchError()); } // Load query evaluation program: std::string qevalProgramSource; std::string queryprgpath = strus::isExplicitPath( queryprg) ? queryprg : textproc->getResourceFilePath( queryprg); int ec = strus::readFile( queryprgpath, qevalProgramSource); if (ec) throw strus::runtime_error(_TXT("failed to load query eval program %s (errno %u)"), queryprg.c_str(), ec); if (!strus::load_queryeval_program( *qeval, analyzer->queryTermTypes(), qproc, qevalProgramSource, errorBuffer.get())) { throw strus::runtime_error(_TXT("failed to load query evaluation program: %s"), errorBuffer->fetchError()); } // Load query: if (queryIsFile) { std::string qs; if (querystring == "-") { ec = strus::readStdin( qs); if (ec) throw strus::runtime_error( _TXT("failed to read query from stdin (errno %u)"), ec); } else { ec = strus::readFile( querystring, qs); if (ec) throw strus::runtime_error(_TXT("failed to read query from file %s (errno %u)"), querystring.c_str(), ec); } querystring = qs; } unsigned int nofQueries = 0; double startTime = 0.0; if (doMeasureDuration) { startTime = getTimeStamp(); } std::string::const_iterator si = querystring.begin(), se = querystring.end(); std::string qs; while (strus::scanNextProgram( qs, si, se, errorBuffer.get())) { ++nofQueries; strus::local_ptr<strus::QueryInterface> query( qeval->createQuery( storage.get())); if (!query.get()) throw strus::runtime_error(_TXT("failed to create query object: %s"), errorBuffer->fetchError()); std::string selectionFeatureSet; std::string weightingFeatureSet; std::vector<std::string> selfset = qeval->getSelectionFeatureSets(); if (!selfset.empty()) selectionFeatureSet = selfset[0]; std::vector<std::string> weightset = qeval->getWeightingFeatureSets(); if (!weightset.empty()) weightingFeatureSet = weightset[0]; if (!strus::loadQuery( *query, analyzer.get(), selectionFeatureSet, weightingFeatureSet, qproc, qs, errorBuffer.get())) { throw strus::runtime_error(_TXT("failed to load query from source: %s"), errorBuffer->fetchError()); } if (withDebugInfo) { query->setDebugMode( true); } query->setMaxNofRanks( nofRanks); query->setMinRank( firstRank); if (!username.empty()) { query->addAccess( username); } if (verbose) { std::cerr << "Query:" << std::endl; std::cerr << query->tostring() << std::endl; } strus::QueryResult result = query->evaluate(); if (!quiet) { std::cout << strus::string_format( _TXT("evaluated till pass %u, got %u ranks (%u without restrictions applied):"), result.evaluationPass(), result.nofRanked(), result.nofVisited()) << std::endl; std::cout << strus::string_format( _TXT("ranked list (starting with rank %u, maximum %u results):"), (unsigned int)firstRank, (unsigned int)nofRanks) << std::endl; } std::vector<strus::ResultDocument>::const_iterator wi = result.ranks().begin(), we = result.ranks().end(); if (!quiet) { for (int widx=1; wi != we; ++wi,++widx) { std::cout << strus::string_format( _TXT( "[%u] score %f"), widx, wi->weight()) << std::endl; std::vector<strus::SummaryElement>::const_iterator ai = wi->summaryElements().begin(), ae = wi->summaryElements().end(); for (; ai != ae; ++ai) { std::cout << "\t" << ai->name(); if (ai->index() >= 0) { std::cout << "[" << ai->index() << "]"; } std::cout << " = '" << ai->value() << "'"; std::cout << " " << ai->weight() << std::endl; } } } } if (doMeasureDuration) { double endTime = getTimeStamp(); double duration = endTime - startTime; std::cerr << strus::string_format( _TXT("evaluated %u queries in %.4f seconds"), nofQueries, duration) << std::endl; } if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("unhandled error in command line query: %s"), errorBuffer->fetchError()); } std::cerr << _TXT("done.") << std::endl; if (!dumpDebugTrace( dbgtrace, NULL/*filename ~ NULL = stderr*/)) { std::cerr << _TXT("failed to dump debug trace to file") << std::endl; } return 0; } catch (const std::bad_alloc&) { std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl; return -2; } catch (const std::runtime_error& e) { const char* errormsg = errorBuffer->fetchError(); if (errormsg) { std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl; } else { std::cerr << _TXT("ERROR ") << e.what() << std::endl; } } catch (const std::exception& e) { std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl; } if (!dumpDebugTrace( dbgtrace, NULL/*filename ~ NULL = stderr*/)) { std::cerr << _TXT("failed to dump debug trace to file") << std::endl; } return -1; }
int main( int argc, const char* argv[]) { int rt = 0; 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; } strus::ProgramOptions opt; bool printUsageAndExit = false; try { opt = strus::ProgramOptions( argc, argv, 9, "h,help", "v,version", "license", "m,module:", "M,moduledir:", "r,rpc:", "s,storage:", "e,exists", "T,trace:"); if (opt( "help")) printUsageAndExit = true; std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get())); if (!moduleLoader.get()) throw strus::runtime_error( _TXT("error creating module loader")); if (opt("moduledir")) { if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc"); std::vector<std::string> modirlist( opt.list("moduledir")); std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end(); for (; mi != me; ++mi) { moduleLoader->addModulePath( *mi); } moduleLoader->addSystemModulePath(); } if (opt("module")) { if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc"); std::vector<std::string> modlist( opt.list("module")); std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end(); for (; mi != me; ++mi) { if (!moduleLoader->loadModule( *mi)) { throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str()); } } } if (opt("license")) { std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts(); std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end(); if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl; for (; ti != te; ++ti) { std::cout << *ti << std::endl; } std::cerr << std::endl; if (!printUsageAndExit) return 0; } if (opt( "version")) { std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl; std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl; std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl; std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl; std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl; std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl; std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts(); std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end(); if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl; for (; vi != ve; ++vi) { std::cout << *vi << std::endl; } if (!printUsageAndExit) return 0; } else if (!printUsageAndExit) { if (opt.nofargs() > 0) { std::cerr << _TXT("too many arguments") << std::endl; printUsageAndExit = true; rt = 1; } } if (printUsageAndExit) { std::cout << _TXT("usage:") << " strusCheckStorage [options]" << std::endl; std::cout << _TXT("description: Checks a storage for corrupt data.") << std::endl; std::cout << _TXT("options:") << std::endl; std::cout << "-h|--help" << std::endl; std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl; std::cout << "-v|--version" << std::endl; std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl; std::cout << "--license" << std::endl; std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl; std::cout << "-s|--storage <CONFIG>" << std::endl; std::cout << " " << _TXT("Define the storage configuration string as <CONFIG>") << std::endl; if (!opt("rpc")) { std::cout << _TXT(" <CONFIG> is a semicolon ';' separated list of assignments:") << std::endl; printStorageConfigOptions( std::cout, moduleLoader.get(), (opt("storage")?opt["storage"]:""), errorBuffer.get()); } std::cout << "-e|--exists" << std::endl; std::cout << " " << _TXT("Checks if the database of the storage exists and return 'yes'/'no'") << std::endl; std::cout << "-m|--module <MOD>" << std::endl; std::cout << " " << _TXT("Load components from module <MOD>") << std::endl; std::cout << "-M|--moduledir <DIR>" << std::endl; std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl; std::cout << "-r|--rpc <ADDR>" << std::endl; std::cout << " " << _TXT("Execute the commands on the RPC server specified by <ADDR>") << std::endl; std::cout << "-T|--trace <CONFIG>" << std::endl; std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl; std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl; return rt; } // Declare trace proxy objects: typedef strus::Reference<strus::TraceProxy> TraceReference; std::vector<TraceReference> trace; if (opt("trace")) { std::vector<std::string> tracecfglist( opt.list("trace")); std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end(); for (; ti != te; ++ti) { trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get())); } } std::string storagecfg; if (opt("storage")) { if (opt("rpc")) throw strus::runtime_error(_TXT("specified mutual exclusive options %s and %s"), "--moduledir", "--rpc"); storagecfg = opt["storage"]; } // Create objects to check storage: std::auto_ptr<strus::RpcClientMessagingInterface> messaging; std::auto_ptr<strus::RpcClientInterface> rpcClient; std::auto_ptr<strus::StorageObjectBuilderInterface> storageBuilder; if (opt("rpc")) { messaging.reset( strus::createRpcClientMessaging( opt[ "rpc"], errorBuffer.get())); if (!messaging.get()) throw strus::runtime_error( _TXT("error creating rpc client messaging")); rpcClient.reset( strus::createRpcClient( messaging.get(), errorBuffer.get())); if (!rpcClient.get()) throw strus::runtime_error( _TXT("error creating rpc client")); (void)messaging.release(); storageBuilder.reset( rpcClient->createStorageObjectBuilder()); if (!storageBuilder.get()) throw strus::runtime_error( _TXT("error creating rpc storage object builder")); } else { storageBuilder.reset( moduleLoader->createStorageObjectBuilder()); if (!storageBuilder.get()) throw strus::runtime_error( _TXT("error creating storage object builder")); } // Create proxy objects if tracing enabled: std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end(); for (; ti != te; ++ti) { strus::StorageObjectBuilderInterface* sproxy = (*ti)->createProxy( storageBuilder.get()); storageBuilder.release(); storageBuilder.reset( sproxy); } if (opt("exists")) { const strus::DatabaseInterface* dbi = storageBuilder->getDatabase( storagecfg); if (!dbi) throw strus::runtime_error(_TXT("could not find key/value store database")); if (dbi->exists( storagecfg)) { std::cout << "yes" << std::endl; } else { std::cout << "no" << std::endl; } if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("unhandled error in analyze")); } } else { std::auto_ptr<strus::StorageClientInterface> storage( strus::createStorageClient( storageBuilder.get(), errorBuffer.get(), storagecfg)); if (!storage.get()) throw strus::runtime_error(_TXT("failed to create storage client")); if (!storage->checkStorage( std::cerr)) { if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("error in check storage")); } std::cerr << _TXT("check storage failed") << std::endl; } else { std::cerr << _TXT("done") << std::endl; } } return 0; } catch (const std::bad_alloc&) { std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl; } catch (const std::runtime_error& e) { const char* errormsg = errorBuffer->fetchError(); if (errormsg) { std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl; } else { std::cerr << _TXT("ERROR ") << e.what() << std::endl; } } catch (const std::exception& e) { std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl; } return -1; }
int main( int argc, const char* argv[]) { int rt = 0; 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; } strus::ProgramOptions opt; bool printUsageAndExit = false; try { opt = strus::ProgramOptions( argc, argv, 8, "h,help", "v,version", "license", "m,module:", "M,moduledir:", "s,storage:", "S,configfile:", "T,trace:"); if (opt( "help")) printUsageAndExit = true; std::auto_ptr<strus::ModuleLoaderInterface> moduleLoader( strus::createModuleLoader( errorBuffer.get())); if (!moduleLoader.get()) throw strus::runtime_error(_TXT("failed to create module loader")); if (opt("moduledir")) { std::vector<std::string> modirlist( opt.list("moduledir")); std::vector<std::string>::const_iterator mi = modirlist.begin(), me = modirlist.end(); for (; mi != me; ++mi) { moduleLoader->addModulePath( *mi); } moduleLoader->addSystemModulePath(); } if (opt("module")) { std::vector<std::string> modlist( opt.list("module")); std::vector<std::string>::const_iterator mi = modlist.begin(), me = modlist.end(); for (; mi != me; ++mi) { if (!moduleLoader->loadModule( *mi)) { throw strus::runtime_error(_TXT("error failed to load module %s"), mi->c_str()); } } } if (opt("license")) { std::vector<std::string> licenses_3rdParty = moduleLoader->get3rdPartyLicenseTexts(); std::vector<std::string>::const_iterator ti = licenses_3rdParty.begin(), te = licenses_3rdParty.end(); if (ti != te) std::cout << _TXT("3rd party licenses:") << std::endl; for (; ti != te; ++ti) { std::cout << *ti << std::endl; } std::cerr << std::endl; if (!printUsageAndExit) return 0; } if (opt( "version")) { std::cout << _TXT("Strus utilities version ") << STRUS_UTILITIES_VERSION_STRING << std::endl; std::cout << _TXT("Strus module version ") << STRUS_MODULE_VERSION_STRING << std::endl; std::cout << _TXT("Strus rpc version ") << STRUS_RPC_VERSION_STRING << std::endl; std::cout << _TXT("Strus trace version ") << STRUS_TRACE_VERSION_STRING << std::endl; std::cout << _TXT("Strus storage version ") << STRUS_STORAGE_VERSION_STRING << std::endl; std::cout << _TXT("Strus base version ") << STRUS_BASE_VERSION_STRING << std::endl; std::vector<std::string> versions_3rdParty = moduleLoader->get3rdPartyVersionTexts(); std::vector<std::string>::const_iterator vi = versions_3rdParty.begin(), ve = versions_3rdParty.end(); if (vi != ve) std::cout << _TXT("3rd party versions:") << std::endl; for (; vi != ve; ++vi) { std::cout << *vi << std::endl; } if (!printUsageAndExit) return 0; } else if (!printUsageAndExit) { if (opt.nofargs() > 1) { std::cerr << _TXT("too many arguments") << std::endl; printUsageAndExit = true; rt = 1; } } std::string storagecfg; int nof_storagecfg = 0; if (opt("configfile")) { nof_storagecfg += 1; std::string configfile = opt[ "configfile"]; int ec = strus::readFile( configfile, storagecfg); if (ec) throw strus::runtime_error(_TXT("failed to read configuration file %s (errno %u)"), configfile.c_str(), ec); std::string::iterator di = storagecfg.begin(), de = storagecfg.end(); for (; di != de; ++di) { if ((unsigned char)*di < 32) *di = ' '; } } if (opt("storage")) { nof_storagecfg += 1; storagecfg = opt[ "storage"]; } if (opt.nofargs() == 1) { std::cerr << _TXT("warning: passing storage as first parameter instead of option -s (deprecated)") << std::endl; nof_storagecfg += 1; storagecfg = opt[0]; } if (nof_storagecfg > 1) { std::cerr << _TXT("conflicting configuration options specified: --storage and --configfile") << std::endl; rt = 10003; printUsageAndExit = true; } else if (!printUsageAndExit && nof_storagecfg == 0) { std::cerr << _TXT("missing configuration option: --storage or --configfile has to be defined") << std::endl; rt = 10004; printUsageAndExit = true; } if (printUsageAndExit) { std::cout << _TXT("usage:") << " strusCreate [options]" << std::endl; std::cout << _TXT("description: Creates a storage with its key value store database.") << std::endl; std::cout << _TXT("options:") << std::endl; std::cout << "-h|--help" << std::endl; std::cout << " " << _TXT("Print this usage and do nothing else") << std::endl; std::cout << "-v|--version" << std::endl; std::cout << " " << _TXT("Print the program version and do nothing else") << std::endl; std::cout << "--license" << std::endl; std::cout << " " << _TXT("Print 3rd party licences requiring reference") << std::endl; std::cout << "-m|--module <MOD>" << std::endl; std::cout << " " << _TXT("Load components from module <MOD>") << std::endl; std::cout << "-M|--moduledir <DIR>" << std::endl; std::cout << " " << _TXT("Search modules to load first in <DIR>") << std::endl; std::cout << "-s|--storage <CONFIG>" << std::endl; std::cout << " " << _TXT("Define the storage configuration string as <CONFIG>") << std::endl; std::cout << " " << _TXT("<CONFIG> is a semicolon ';' separated list of assignments:") << std::endl; printStorageConfigOptions( std::cout, moduleLoader.get(), storagecfg, errorBuffer.get()); std::cout << "-S|--configfile <FILENAME>" << std::endl; std::cout << " " << _TXT("Define the storage configuration file as <FILENAME>") << std::endl; std::cout << " " << _TXT("<FILENAME> is a file containing the configuration string") << std::endl; std::cout << "-T|--trace <CONFIG>" << std::endl; std::cout << " " << _TXT("Print method call traces configured with <CONFIG>") << std::endl; std::cout << " " << strus::string_format( _TXT("Example: %s"), "-T \"log=dump;file=stdout\"") << std::endl; return rt; } // Declare trace proxy objects: typedef strus::Reference<strus::TraceProxy> TraceReference; std::vector<TraceReference> trace; if (opt("trace")) { std::vector<std::string> tracecfglist( opt.list("trace")); std::vector<std::string>::const_iterator ti = tracecfglist.begin(), te = tracecfglist.end(); for (; ti != te; ++ti) { trace.push_back( new strus::TraceProxy( moduleLoader.get(), *ti, errorBuffer.get())); } } // Create root object: std::auto_ptr<strus::StorageObjectBuilderInterface> storageBuilder( moduleLoader->createStorageObjectBuilder()); if (!storageBuilder.get()) throw strus::runtime_error(_TXT("failed to create storage object builder")); // Create proxy objects if tracing enabled: std::vector<TraceReference>::const_iterator ti = trace.begin(), te = trace.end(); for (; ti != te; ++ti) { strus::StorageObjectBuilderInterface* sproxy = (*ti)->createProxy( storageBuilder.get()); storageBuilder.release(); storageBuilder.reset( sproxy); } // Create objects: std::string dbname; (void)strus::extractStringFromConfigString( dbname, storagecfg, "database", errorBuffer.get()); const strus::DatabaseInterface* dbi = storageBuilder->getDatabase( dbname); if (!dbi) throw strus::runtime_error(_TXT("failed to get database interface")); const strus::StorageInterface* sti = storageBuilder->getStorage(); if (!sti) throw strus::runtime_error(_TXT("failed to get storage interface")); if (!sti->createStorage( storagecfg, dbi)) { throw strus::runtime_error(_TXT("failed to create storage")); } if (errorBuffer->hasError()) { throw strus::runtime_error(_TXT("unhandled error in create storage")); } std::cerr << _TXT("storage successfully created.") << std::endl; return 0; } catch (const std::bad_alloc&) { std::cerr << _TXT("ERROR ") << _TXT("out of memory") << std::endl; } catch (const std::runtime_error& e) { const char* errormsg = errorBuffer->fetchError(); if (errormsg) { std::cerr << _TXT("ERROR ") << e.what() << ": " << errormsg << std::endl; } else { std::cerr << _TXT("ERROR ") << e.what() << std::endl; } } catch (const std::exception& e) { std::cerr << _TXT("EXCEPTION ") << e.what() << std::endl; } return -1; }