int CommandLineTestRunner::RunAllTests(int ac, const char** av)
{
int result = 0;
ConsoleTestOutput output;
#ifndef DISABLE_MEMORYLEAK_PLUGIN
MemoryLeakWarningPlugin memLeakWarn(DEF_PLUGIN_MEM_LEAK);
//memLeakWarn.disable();
TestRegistry::getCurrentRegistry()->installPlugin(&memLeakWarn);
#endif
{
CommandLineTestRunner runner(ac, av, &output);
result = runner.runAllTestsMain();
}
#ifndef DISABLE_MEMORYLEAK_PLUGIN
if (result == 0) {
output << memLeakWarn.FinalReport(0);
}
#endif
return result;
}
void test_container_mt_stop() {
test_mt_handler th;
proton::container c(th);
c.auto_stop(false);
container_runner runner(c);
auto t = std::thread(runner);
// Must ensure that thread is joined or detached
try {
test_listen_handler lh;
c.listen("//:0", lh); // Also opens a connection
ASSERT_EQUAL("start", th.wait());
ASSERT_EQUAL("open", th.wait());
c.stop();
t.join();
} catch (...) {
// We don't join as we don't know if we'll be stuck waiting
if (t.joinable()) {
t.detach();
}
throw;
}
}
void socketServer(int ac, char **av)
{
if(ac <= 1) {
std::cout<<"server ipv4:127.0.0.1:5000"<<std::endl;
return ;
}
bool can_continue(true);
EventLoop::EpollRunner runner(EventLoop::SignalSet(SIGINT),
[&can_continue](int sig)
{
if(sig == SIGINT) can_continue = false;
});
Thread::Server server(runner);
server.NewListeningSocket(boost::lexical_cast<EventLoop::SocketAddress>(av[1]));
runner.run([&can_continue]() { return can_continue;});
std::cout<<"done"<<std::endl;
return;
}
// run all tests
int main(int argc, char **argv) {
// change if you want to run only one test
bool runAll = true;
const char* suiteToRun = "Parser53TestClass";
std::vector<const char*> testCasesToRun;
//testCasesToRun.push_back("ScanFileShouldNotifyClassObserver");
int ret = 0;
if (runAll) {
ret = UnitTest::RunAllTests();
}
else {
UnitTest::TestReporterStdout reporter;
UnitTest::TestRunner runner(reporter);
SingleTestsPredicateClass pred(testCasesToRun);
ret = runner.RunTestsIf(UnitTest::Test::GetTestList(), suiteToRun, pred, 0);
}
// calling cleanup here so that we can run this binary through a memory leak detector
// ICU will cache many things and that will cause the detector to output "possible leaks"
u_cleanup();
return ret;
}
virtual bool run(const string& dbname , BSONObj& cmdObj, int, string& errmsg, BSONObjBuilder& result, bool) {
string coll = cmdObj[ "captrunc" ].valuestrsafe();
uassert( 13416, "captrunc must specify a collection", !coll.empty() );
NamespaceString nss( dbname, coll );
int n = cmdObj.getIntField( "n" );
bool inc = cmdObj.getBoolField( "inc" ); // inclusive range?
Client::WriteContext ctx( nss.ns() );
Collection* collection = ctx.ctx().db()->getCollection( nss.ns() );
massert( 13417, "captrunc collection not found or empty", collection);
boost::scoped_ptr<Runner> runner(InternalPlanner::collectionScan(nss.ns(),
InternalPlanner::BACKWARD));
DiskLoc end;
// We remove 'n' elements so the start is one past that
for( int i = 0; i < n + 1; ++i ) {
Runner::RunnerState state = runner->getNext(NULL, &end);
massert( 13418, "captrunc invalid n", Runner::RUNNER_ADVANCED == state);
}
collection->temp_cappedTruncateAfter( end, inc );
return true;
}
void run() {
Client::WriteContext ctx(&_txn, ns());
Database* db = ctx.ctx().db();
Collection* coll = db->getCollection(&_txn, ns());
if (!coll) {
coll = db->createCollection(&_txn, ns());
}
WorkingSet* ws = new WorkingSet();
MockStage* ms = new MockStage(ws);
for (int i = 0; i < numObj(); ++i) {
WorkingSetMember member;
member.state = WorkingSetMember::OWNED_OBJ;
member.obj = fromjson("{a: [1,2,3], b:[1,2,3], c:[1,2,3], d:[1,2,3,4]}");
ms->pushBack(member);
member.obj = fromjson("{a:1, b:1, c:1}");
ms->pushBack(member);
}
SortStageParams params;
params.collection = coll;
params.pattern = BSON("b" << -1 << "c" << 1 << "a" << 1);
params.limit = 0;
// We don't get results back since we're sorting some parallel arrays.
PlanExecutor runner(ws,
new FetchStage(&_txn,
ws,
new SortStage(&_txn, params, ws, ms), NULL, coll),
coll);
PlanExecutor::ExecState runnerState = runner.getNext(NULL, NULL);
ASSERT_EQUALS(PlanExecutor::EXEC_ERROR, runnerState);
ctx.commit();
}
/**
* A template used by many tests below.
* Fill out numObj objects, sort them in the order provided by 'direction'.
* If extAllowed is true, sorting will use use external sorting if available.
* If limit is not zero, we limit the output of the sort stage to 'limit' results.
*/
void sortAndCheck(int direction, Collection* coll) {
WorkingSet* ws = new WorkingSet();
MockStage* ms = new MockStage(ws);
// Insert a mix of the various types of data.
insertVarietyOfObjects(ms, coll);
SortStageParams params;
params.collection = coll;
params.pattern = BSON("foo" << direction);
params.limit = limit();
// Must fetch so we can look at the doc as a BSONObj.
PlanExecutor runner(ws,
new FetchStage(&_txn, ws,
new SortStage(&_txn, params, ws, ms), NULL, coll),
coll);
// Look at pairs of objects to make sure that the sort order is pairwise (and therefore
// totally) correct.
BSONObj last;
ASSERT_EQUALS(PlanExecutor::ADVANCED, runner.getNext(&last, NULL));
// Count 'last'.
int count = 1;
BSONObj current;
while (PlanExecutor::ADVANCED == runner.getNext(¤t, NULL)) {
int cmp = sgn(current.woSortOrder(last, params.pattern));
// The next object should be equal to the previous or oriented according to the sort
// pattern.
ASSERT(cmp == 0 || cmp == 1);
++count;
last = current;
}
checkCount(count);
}
void run() {
Client::ReadContext ctx(&_txn, ns());
// Configure the scan.
CollectionScanParams params;
params.collection = ctx.ctx().db()->getCollection( &_txn, ns() );
params.direction = CollectionScanParams::FORWARD;
params.tailable = false;
// Make a scan and have the runner own it.
WorkingSet* ws = new WorkingSet();
PlanStage* ps = new CollectionScan(&_txn, params, ws, NULL);
PlanExecutor runner(ws, ps, params.collection);
int count = 0;
for (BSONObj obj; PlanExecutor::ADVANCED == runner.getNext(&obj, NULL); ) {
// Make sure we get the objects in the order we want
ASSERT_EQUALS(count, obj["foo"].numberInt());
++count;
}
ASSERT_EQUALS(numObj(), count);
}
int main()
{
return UnitTest::RunAllTests();
try
{
UnitTest::TestReporterStdout reporter;
UnitTest::TestRunner runner(reporter);
return runner.RunTestsIf(
UnitTest::Test::GetTestList(),
"ParamTests",
UnitTest::True(),
0);
}
catch(std::exception const& e)
{
printf("%s", e.what());
// If you are feeling mad (not in main) you could rethrow!
}
}
vector<BSONObj> Helpers::findAll( const string& ns , const BSONObj& query ) {
Lock::assertAtLeastReadLocked(ns);
Client::Context ctx(ns);
CanonicalQuery* cq;
uassert(17236, "Could not canonicalize " + query.toString(),
CanonicalQuery::canonicalize(ns, query, &cq).isOK());
Runner* rawRunner;
uassert(17237, "Could not get runner for query " + query.toString(),
getRunner(ctx.db()->getCollection( ns ), cq, &rawRunner).isOK());
vector<BSONObj> all;
auto_ptr<Runner> runner(rawRunner);
Runner::RunnerState state;
BSONObj obj;
while (Runner::RUNNER_ADVANCED == (state = runner->getNext(&obj, NULL))) {
all.push_back(obj);
}
return all;
}
/* fetch a single object from collection ns that matches query
set your db SavedContext first
*/
DiskLoc Helpers::findOne(Collection* collection, const BSONObj &query, bool requireIndex) {
if ( !collection )
return DiskLoc();
CanonicalQuery* cq;
const WhereCallbackReal whereCallback(collection->ns().db());
massert(17244, "Could not canonicalize " + query.toString(),
CanonicalQuery::canonicalize(collection->ns(), query, &cq, whereCallback).isOK());
Runner* rawRunner;
size_t options = requireIndex ? QueryPlannerParams::NO_TABLE_SCAN : QueryPlannerParams::DEFAULT;
massert(17245, "Could not get runner for query " + query.toString(),
getRunner(collection, cq, &rawRunner, options).isOK());
auto_ptr<Runner> runner(rawRunner);
Runner::RunnerState state;
DiskLoc loc;
if (Runner::RUNNER_ADVANCED == (state = runner->getNext(NULL, &loc))) {
return loc;
}
return DiskLoc();
}
void WinTestRunner::run()
{
// Note: The following code is some evil hack to
// add batch capability to the MFC based WinTestRunner.
std::string cmdLine(AfxGetApp()->m_lpCmdLine);
if (cmdLine.size() >= 2 && cmdLine[0] == '/' && (cmdLine[1] == 'b' || cmdLine[1] == 'B'))
{
// We're running in batch mode.
std::string outPath;
if (cmdLine.size() > 4 && cmdLine[2] == ':')
outPath = cmdLine.substr(3);
else
outPath = "CON";
std::ofstream ostr(outPath.c_str());
if (ostr.good())
{
TestRunner runner(ostr);
for (std::vector<Test*>::iterator it = _tests.begin(); it != _tests.end(); ++it)
runner.addTest((*it)->toString(), *it);
_tests.clear();
std::vector<std::string> args;
args.push_back("WinTestRunner");
args.push_back("-all");
bool success = runner.run(args);
ExitProcess(success ? 0 : 1);
}
else ExitProcess(2);
}
else
{
// We're running in interactive mode.
TestRunnerDlg dlg;
dlg.setTests(_tests);
dlg.DoModal();
}
}
Status getOplogStartHack(CanonicalQuery* cq, Runner** runnerOut) {
// Make an oplog start finding stage.
WorkingSet* oplogws = new WorkingSet();
OplogStart* stage = new OplogStart(cq->ns(), cq->root(), oplogws);
// Takes ownership of ws and stage.
auto_ptr<InternalRunner> runner(new InternalRunner(cq->ns(), stage, oplogws));
runner->setYieldPolicy(Runner::YIELD_AUTO);
// The stage returns a DiskLoc of where to start.
DiskLoc startLoc;
Runner::RunnerState state = runner->getNext(NULL, &startLoc);
// This is normal. The start of the oplog is the beginning of the collection.
if (Runner::RUNNER_EOF == state) { return getRunner(cq, runnerOut); }
// This is not normal. An error was encountered.
if (Runner::RUNNER_ADVANCED != state) {
return Status(ErrorCodes::InternalError,
"quick oplog start location had error...?");
}
// cout << "diskloc is " << startLoc.toString() << endl;
// Build our collection scan...
CollectionScanParams params;
params.ns = cq->ns();
params.start = startLoc;
params.direction = CollectionScanParams::FORWARD;
params.tailable = cq->getParsed().hasOption(QueryOption_CursorTailable);
WorkingSet* ws = new WorkingSet();
CollectionScan* cs = new CollectionScan(params, ws, cq->root());
// Takes ownership of cq, cs, ws.
*runnerOut = new SingleSolutionRunner(cq, NULL, cs, ws);
return Status::OK();
}
int
main(int argc, char *argv[])
{
if (argc < 2)
{
CopyRight(stderr, argv[0]);
GMX_ERROR(gmx::eeInvalidInput,
"Not enough command-line arguments");
}
std::auto_ptr<gmx::TrajectoryAnalysisModule>
mod(gmx::createTrajectoryAnalysisModule(argv[1]));
if (mod.get() == NULL)
{
CopyRight(stderr, argv[0]);
GMX_ERROR(gmx::eeInvalidInput,
"Unknown analysis module given as the first command-line argument");
}
--argc;
++argv;
gmx::TrajectoryAnalysisCommandLineRunner runner(mod.get());
return runner.run(argc, argv);
}
int main(int argc, char* argv[]) {
// 根据命令行参数加载配置文件等处理过程
Utils::loadCommandLine(argc, argv);
// 工作模式配置为 执行轨迹跟踪
if (CFG_sModeExecute == "track") {
TrackRunner runner(CFG_iImageLoadBegin, CFG_iImageLoadEnd);
runner.initFirstFrame();
int cnt = 0;
while (runner.hasNext()) {
int idxImgCur = runner.runKeyStep();
cnt++;
}
runner.lm();
cv::waitKey();
}
// 工作模式配置为 并行批量特征预处理
else if (CFG_sModeExecute == "feature") {
#pragma omp parallel for
for (int idx = CFG_iImageLoadBegin; idx <= CFG_iImageLoadEnd; idx++) {
FeatureState fs(idx);
fs.detect(CFG_iMaxFeatures);
printf("FeatureDetect[%d]-\n",idx);
}
}
getchar();
return 0;
}
int main(int ac, const char** av)
{
#ifdef INCLUDE_GTEST_TESTS
GTestConvertor convertor;
convertor.addAllGTestToTestRegistry();
#endif
MemoryReporterPlugin plugin;
MockSupportPlugin mockPlugin;
TestRegistry::getCurrentRegistry()->installPlugin(&plugin);
TestRegistry::getCurrentRegistry()->installPlugin(&mockPlugin);
#ifndef GMOCK_RENAME_MAIN
return CommandLineTestRunner::RunAllTests(ac, av);
#else
/* Don't have any memory leak detector when running the Google Test tests */
testing::GMOCK_FLAG(verbose) = testing::internal::kWarningVerbosity;
ConsoleTestOutput output;
CommandLineTestRunner runner(ac, av, &output, TestRegistry::getCurrentRegistry());
return runner.runAllTestsMain();
#endif
}
int main()
{
sce::Sled::Assert::setAssertHandler(FailTestOnAssertHandler);
sce::Sled::Logging::setLogHandler(FailTestOnLogErrorHandler);
sce::Sled::ScopedNetwork sn;
if (!sn.IsValid())
UnitTest::ReportAssert("Networking failed!", __FILE__, __LINE__);
#ifdef UNITTEST_XML_NAME
#define UNITTEST_DIRECT_TO_STRING(arg) #arg
#define UNITTEST_INDIRECT_TO_STRING(arg) UNITTEST_DIRECT_TO_STRING(arg)
UnitTest::TestReporterStdout stdoutReporter;
UnitTest::CompositeTestReporter reporter;
reporter.AddReporter(&stdoutReporter);
UnitTest::TestRunner runner(reporter);
return runner.RunTestsIf(UnitTest::Test::GetTestList(), NULL, UnitTest::True(), 0);
#else
#error "UNITTEST_XML_NAME must be defined and set to the basename of the executable."
#endif
}
int main(int argc, const char* argv[])
{
Game g;
ifstream cfgfile("monopoly.cfg");
g.load(cfgfile);
cfgfile.close();
cout << "Game is loaded and ready to start!!!" << endl;
cin.ignore();
GameRunner runner(g, 20); // run for 10 rolls!
runner.runGame();
cout << "Game is finished!!!" << endl;
cin.ignore();
return 0;
}
/*
BMessageRunner(BMessenger target, const BMessage *message,
bigtime_t interval, int32 count, BMessenger replyTo)
@case 5 target is valid, message is valid,
interval == LONGLONG_MAX, count > 0
@results InitCheck() should return B_OK.
GetInfo() should return B_OK.
No message should be delivered.
*/
void TBMessageRunnerTester::BMessageRunnerB5()
{
// R5: doesn't behave very well. In worst case registrar time loop gets
// locked up and system wide message runners don't get messages anymore.
#ifndef TEST_R5
MessageRunnerTestApp app(kTesterSignature);
MessageRunnerTestLooper *looper = app.TestLooper();
BMessenger target(looper);
BMessage message(MSG_RUNNER_MESSAGE);
bigtime_t interval = LONGLONG_MAX;
int32 count = 5;
MessageRunnerTestHandler *handler = app.TestHandler();
BMessenger replyTo(handler);
BMessageRunner runner(target, &message, interval, count, replyTo);
bigtime_t startTime = system_time();
CHK(runner.InitCheck() == B_OK);
interval = max(interval, kMinTimeInterval);
check_message_runner_info(runner, B_OK, interval, count);
snooze(10000);
CHK(looper->CheckMessages(startTime, interval, 0));
CHK(app.CountReplies() == 0);
CHK(handler->CountReplies() == 0);
#endif
}
/*
void GetAppList(const char *signature, BList *teamIDList) const
@case 1 signature or teamIDList are NULL
@results Should do nothing/should not modify teamIDList.
*/
void GetAppListTester::GetAppListTestB1()
{
// R5: crashes when passing a NULL signature/BList
#ifndef TEST_R5
const char *signature = "application/x-vnd.obos-app-run-testapp1";
// create a list with some dummy entries
BList emptyList;
BList list;
list.AddItem((void*)-7);
list.AddItem((void*)-42);
// NULL signature and list
BRoster roster;
roster.GetAppList(NULL, NULL);
// NULL signature
BList list1(list);
roster.GetAppList(NULL, &list1);
check_list(list1, list, list, emptyList);
// NULL list
AppRunner runner(true);
CHK(runner.Run("AppRunTestApp1") == B_OK);
roster.GetAppList(signature, NULL);
runner.WaitFor(true);
#endif
}
int countResults(CollectionScanParams::Direction direction, const BSONObj& filterObj) {
Client::ReadContext ctx(&_txn, ns());
// Configure the scan.
CollectionScanParams params;
params.collection = ctx.ctx().db()->getCollection( &_txn, ns() );
params.direction = direction;
params.tailable = false;
// Make the filter.
StatusWithMatchExpression swme = MatchExpressionParser::parse(filterObj);
verify(swme.isOK());
auto_ptr<MatchExpression> filterExpr(swme.getValue());
// Make a scan and have the runner own it.
WorkingSet* ws = new WorkingSet();
PlanStage* ps = new CollectionScan(&_txn, params, ws, filterExpr.get());
PlanExecutor runner(ws, ps, params.collection);
// Use the runner to count the number of objects scanned.
int count = 0;
for (BSONObj obj; PlanExecutor::ADVANCED == runner.getNext(&obj, NULL); ) { ++count; }
return count;
}
extern "C" int main(int argcount, char* argvec[])
#endif
{
#if defined(__native_client__)
std::cerr << "Running game_main" << std::endl;
chdir("/frogatto");
{
char buf[256];
const char* const res = getcwd(buf,sizeof(buf));
std::cerr << "Current working directory: " << res << std::endl;
}
#endif
#ifdef _MSC_VER
freopen("CON", "w", stderr);
freopen("CON", "w", stdout);
#endif
#if defined(__APPLE__) && TARGET_OS_MAC
chdir([[[NSBundle mainBundle] resourcePath] fileSystemRepresentation]);
#endif
#ifdef NO_STDERR
std::freopen("/dev/null", "w", stderr);
std::cerr.sync_with_stdio(true);
#endif
std::cerr << "Frogatto engine version " << preferences::version() << "\n";
LOG( "After print engine version" );
#if defined(TARGET_BLACKBERRY)
chdir("app/native");
std::cout<< "Changed working directory to: " << getcwd(0, 0) << std::endl;
#endif
game_logic::init_callable_definitions();
std::string level_cfg = "titlescreen.cfg";
bool unit_tests_only = false, skip_tests = false;
bool run_benchmarks = false;
std::vector<std::string> benchmarks_list;
std::string utility_program;
std::vector<std::string> util_args;
std::string server = "wesnoth.org";
#if defined(UTILITY_IN_PROC)
bool create_utility_in_new_process = false;
std::string utility_name;
#endif
bool is_child_utility = false;
const char* profile_output = NULL;
std::string profile_output_buf;
#if defined(__ANDROID__)
//monstartup("libapplication.so");
#endif
std::string orig_level_cfg = level_cfg;
std::string override_level_cfg = "";
int modules_loaded = 0;
std::vector<std::string> argv;
for(int n = 1; n < argcount; ++n) {
#if defined(UTILITY_IN_PROC)
std::string sarg(argvec[n]);
if(sarg.compare(0, 15, "--utility-proc=") == 0) {
create_utility_in_new_process = true;
utility_name = "--utility-child=" + sarg.substr(15);
} else {
argv.push_back(argvec[n]);
}
#else
argv.push_back(argvec[n]);
#endif
if(argv.size() >= 2 && argv[argv.size()-2] == "-NSDocumentRevisionsDebugMode" && argv.back() == "YES") {
//XCode passes these arguments by default when debugging -- make sure they are ignored.
argv.resize(argv.size()-2);
}
}
std::cerr << "Build Options:";
for(auto bo : preferences::get_build_options()) {
std::cerr << " " << bo;
}
std::cerr << std::endl;
#if defined(UTILITY_IN_PROC)
if(create_utility_in_new_process) {
argv.push_back(utility_name);
#if defined(_MSC_VER)
// app name is ignored for windows, we get windows to tell us.
is_child_utility = create_utility_process("", argv);
#else
is_child_utility = create_utility_process(argvec[0], argv);
#endif
if(!is_child_utility) {
argv.pop_back();
}
#if defined(_MSC_VER)
atexit(terminate_utility_process);
#endif
}
#endif
if(sys::file_exists("./master-config.cfg")) {
std::cerr << "LOADING CONFIGURATION FROM master-config.cfg" << std::endl;
variant cfg = json::parse_from_file("./master-config.cfg");
if(cfg.is_map()) {
if( cfg["id"].is_null() == false) {
std::cerr << "SETTING MODULE PATH FROM master-config.cfg: " << cfg["id"].as_string() << std::endl;
preferences::set_preferences_path_from_module(cfg["id"].as_string());
//XXX module::set_module_name(cfg["id"].as_string(), cfg["id"].as_string());
}
if(cfg["arguments"].is_null() == false) {
std::vector<std::string> additional_args = cfg["arguments"].as_list_string();
argv.insert(argv.begin(), additional_args.begin(), additional_args.end());
std::cerr << "ADDING ARGUMENTS FROM master-config.cfg:";
for(size_t n = 0; n < cfg["arguments"].num_elements(); ++n) {
std::cerr << " " << cfg["arguments"][n].as_string();
}
std::cerr << std::endl;
}
}
}
stats::record_program_args(argv);
for(size_t n = 0; n < argv.size(); ++n) {
const int argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
if(arg_name == "--module") {
if(load_module(arg_value, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << arg_value << "\n";
return -1;
}
++modules_loaded;
} else if(arg == "--tests") {
unit_tests_only = true;
}
}
if(modules_loaded == 0 && !unit_tests_only) {
if(load_module(DEFAULT_MODULE, &argv) != 0) {
std::cerr << "FAILED TO LOAD MODULE: " << DEFAULT_MODULE << "\n";
return -1;
}
}
preferences::load_preferences();
LOG( "After load_preferences()" );
// load difficulty settings after module, before rest of args.
difficulty::manager();
for(size_t n = 0; n < argv.size(); ++n) {
const size_t argc = argv.size();
const std::string arg(argv[n]);
std::string arg_name, arg_value;
std::string::const_iterator equal = std::find(arg.begin(), arg.end(), '=');
if(equal != arg.end()) {
arg_name = std::string(arg.begin(), equal);
arg_value = std::string(equal+1, arg.end());
}
std::cerr << "ARGS: " << arg << std::endl;
if(arg.substr(0,4) == "-psn") {
// ignore.
} else if(arg_name == "--module") {
// ignore already processed.
} else if(arg_name == "--profile" || arg == "--profile") {
profile_output_buf = arg_value;
profile_output = profile_output_buf.c_str();
} else if(arg_name == "--utility" || arg_name == "--utility-child") {
if(arg_name == "--utility-child") {
is_child_utility = true;
}
utility_program = arg_value;
for(++n; n < argc; ++n) {
const std::string arg(argv[n]);
util_args.push_back(arg);
}
break;
} else if(arg == "--benchmarks") {
run_benchmarks = true;
} else if(arg_name == "--benchmarks") {
run_benchmarks = true;
benchmarks_list = util::split(arg_value);
} else if(arg == "--tests") {
// ignore as already processed.
} else if(arg == "--no-tests") {
skip_tests = true;
} else if(arg_name == "--width") {
std::string w(arg_value);
preferences::set_actual_screen_width(boost::lexical_cast<int>(w));
} else if(arg == "--width" && n+1 < argc) {
std::string w(argv[++n]);
preferences::set_actual_screen_width(boost::lexical_cast<int>(w));
} else if(arg_name == "--height") {
std::string h(arg_value);
preferences::set_actual_screen_height(boost::lexical_cast<int>(h));
} else if(arg == "--height" && n+1 < argc) {
std::string h(argv[++n]);
preferences::set_actual_screen_height(boost::lexical_cast<int>(h));
} else if(arg_name == "--level") {
override_level_cfg = arg_value;
} else if(arg == "--level" && n+1 < argc) {
override_level_cfg = argv[++n];
} else if(arg_name == "--host") {
server = arg_value;
} else if(arg == "--host" && n+1 < argc) {
server = argv[++n];
} else if(arg == "--compiled") {
preferences::set_load_compiled(true);
#ifndef NO_EDITOR
} else if(arg == "--edit") {
preferences::set_edit_on_start(true);
#endif
} else if(arg == "--no-compiled") {
preferences::set_load_compiled(false);
#if defined(TARGET_PANDORA)
} else if(arg == "--no-fbo") {
preferences::set_fbo(false);
} else if(arg == "--no-bequ") {
preferences::set_bequ(false);
#endif
} else if(arg == "--help" || arg == "-h") {
print_help(std::string(argvec[0]));
return 0;
} else {
const bool res = preferences::parse_arg(argv[n].c_str());
if(!res) {
std::cerr << "unrecognized arg: '" << arg << "'\n";
return -1;
}
}
}
checksum::manager checksum_manager;
#ifndef NO_EDITOR
sys::filesystem_manager fs_manager;
#endif // NO_EDITOR
preferences::expand_data_paths();
background_task_pool::manager bg_task_pool_manager;
LOG( "After expand_data_paths()" );
std::cerr << "Preferences dir: " << preferences::user_data_path() << '\n';
//make sure that the user data path exists.
if(!preferences::setup_preferences_dir()) {
std::cerr << "cannot create preferences dir!\n";
}
std::cerr << "\n";
const tbs::internal_server_manager internal_server_manager_scope(preferences::internal_tbs_server());
if(utility_program.empty() == false
&& test::utility_needs_video(utility_program) == false) {
#if defined(UTILITY_IN_PROC)
if(is_child_utility) {
ASSERT_LOG(ipc::semaphore::create(shared_sem_name, 1) != false,
"Unable to create shared semaphore: " << errno);
std::cerr.sync_with_stdio(true);
}
#endif
test::run_utility(utility_program, util_args);
return 0;
}
#if defined(TARGET_PANDORA)
EGL_Open();
#endif
#if defined(__ANDROID__)
std::freopen("stdout.txt","w",stdout);
std::freopen("stderr.txt","w",stderr);
std::cerr.sync_with_stdio(true);
#endif
LOG( "Start of main" );
if(!skip_tests && !test::run_tests()) {
return -1;
}
if(unit_tests_only) {
return 0;
}
// Create the main window.
// Initalise SDL and Open GL.
main_window = graphics::window_manager_ptr(new graphics::window_manager());
main_window->create_window(preferences::actual_screen_width(), preferences::actual_screen_height());
#ifdef TARGET_OS_HARMATTAN
g_type_init();
#endif
i18n::init ();
LOG( "After i18n::init()" );
#if TARGET_OS_IPHONE || defined(TARGET_BLACKBERRY) || defined(__ANDROID__)
//on the iPhone and PlayBook, try to restore the auto-save if it exists
if(sys::file_exists(preferences::auto_save_file_path()) && sys::read_file(std::string(preferences::auto_save_file_path()) + ".stat") == "1") {
level_cfg = "autosave.cfg";
sys::write_file(std::string(preferences::auto_save_file_path()) + ".stat", "0");
}
#endif
if(override_level_cfg.empty() != true) {
level_cfg = override_level_cfg;
orig_level_cfg = level_cfg;
}
const stats::manager stats_manager;
#ifndef NO_EDITOR
const external_text_editor::manager editor_manager;
#endif // NO_EDITOR
#if defined(USE_BOX2D)
box2d::manager b2d_manager;
#endif
const load_level_manager load_manager;
{ //manager scope
const font::manager font_manager;
const sound::manager sound_manager;
#if !defined(__native_client__)
const joystick::manager joystick_manager;
#endif
graphics::texture::manager texture_manager;
#ifndef NO_EDITOR
editor::manager editor_manager;
#endif
variant preloads;
loading_screen loader;
try {
variant gui_node = json::parse_from_file(preferences::load_compiled() ? "data/compiled/gui.cfg" : "data/gui.cfg");
gui_section::init(gui_node);
loader.draw_and_increment(_("Initializing GUI"));
framed_gui_element::init(gui_node);
sound::init_music(json::parse_from_file("data/music.cfg"));
graphical_font::init_for_locale(i18n::get_locale());
preloads = json::parse_from_file("data/preload.cfg");
int preload_items = preloads["preload"].num_elements();
loader.set_number_of_items(preload_items+7); // 7 is the number of items that will be loaded below
custom_object::init();
loader.draw_and_increment(_("Initializing custom object functions"));
init_custom_object_functions(json::parse_from_file("data/functions.cfg"));
loader.draw_and_increment(_("Initializing textures"));
loader.load(preloads);
loader.draw_and_increment(_("Initializing tiles"));
tile_map::init(json::parse_from_file("data/tiles.cfg"));
game_logic::formula_object::load_all_classes();
} catch(const json::parse_error& e) {
std::cerr << "ERROR PARSING: " << e.error_message() << "\n";
return 0;
}
loader.draw(_("Loading level"));
#if defined(__native_client__)
while(1) {
}
#endif
#if defined(__APPLE__) && !(TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE) && !defined(USE_SHADERS)
GLint swapInterval = 1;
CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &swapInterval);
#endif
loader.finish_loading();
//look to see if we got any quit events while loading.
{
SDL_Event event;
while(input::sdl_poll_event(&event)) {
if(event.type == SDL_QUIT) {
return 0;
}
}
}
formula_profiler::manager profiler(profile_output);
#ifdef USE_SHADERS
texture_frame_buffer::init(preferences::actual_screen_width(), preferences::actual_screen_height());
#else
texture_frame_buffer::init();
#endif
if(run_benchmarks) {
if(benchmarks_list.empty() == false) {
test::run_benchmarks(&benchmarks_list);
} else {
test::run_benchmarks();
}
return 0;
} else if(utility_program.empty() == false && test::utility_needs_video(utility_program) == true) {
test::run_utility(utility_program, util_args);
return 0;
}
bool quit = false;
while(!quit && !show_title_screen(level_cfg)) {
boost::intrusive_ptr<level> lvl(load_level(level_cfg));
#if !defined(__native_client__)
//see if we're loading a multiplayer level, in which case we
//connect to the server.
multiplayer::manager mp_manager(lvl->is_multiplayer());
if(lvl->is_multiplayer()) {
multiplayer::setup_networked_game(server);
}
if(lvl->is_multiplayer()) {
last_draw_position() = screen_position();
std::string level_cfg = "waiting-room.cfg";
boost::intrusive_ptr<level> wait_lvl(load_level(level_cfg));
wait_lvl->finish_loading();
wait_lvl->set_multiplayer_slot(0);
if(wait_lvl->player()) {
wait_lvl->player()->set_current_level(level_cfg);
}
wait_lvl->set_as_current_level();
level_runner runner(wait_lvl, level_cfg, orig_level_cfg);
multiplayer::sync_start_time(*lvl, boost::bind(&level_runner::play_cycle, &runner));
lvl->set_multiplayer_slot(multiplayer::slot());
}
#endif
last_draw_position() = screen_position();
assert(lvl.get());
if(!lvl->music().empty()) {
sound::play_music(lvl->music());
}
if(lvl->player() && level_cfg != "autosave.cfg") {
lvl->player()->set_current_level(level_cfg);
lvl->player()->get_entity().save_game();
}
set_scene_title(lvl->title());
try {
quit = level_runner(lvl, level_cfg, orig_level_cfg).play_level();
level_cfg = orig_level_cfg;
} catch(multiplayer_exception&) {
}
}
level::clear_current_level();
} //end manager scope, make managers destruct before calling SDL_Quit
// controls::debug_dump_controls();
#if defined(TARGET_PANDORA) || defined(TARGET_TEGRA)
EGL_Destroy();
#endif
preferences::save_preferences();
#if !defined(_MSC_VER) && defined(UTILITY_IN_PROC)
if(create_utility_in_new_process) {
terminate_utility_process();
}
#endif
std::set<variant*> loading;
swap_variants_loading(loading);
if(loading.empty() == false) {
fprintf(stderr, "Illegal object: %p\n", (void*)(*loading.begin())->as_callable_loading());
ASSERT_LOG(false, "Unresolved unserialized objects: " << loading.size());
}
//#ifdef _MSC_VER
// ExitProcess(0);
//#endif
return 0;
}
Status cloneCollectionAsCapped( Database* db,
const string& shortFrom,
const string& shortTo,
double size,
bool temp,
bool logForReplication ) {
string fromNs = db->name() + "." + shortFrom;
string toNs = db->name() + "." + shortTo;
Collection* fromCollection = db->getCollection( fromNs );
if ( !fromCollection )
return Status( ErrorCodes::NamespaceNotFound,
str::stream() << "source collection " << fromNs << " does not exist" );
if ( db->getCollection( toNs ) )
return Status( ErrorCodes::NamespaceExists, "to collection already exists" );
// create new collection
{
Client::Context ctx( toNs );
BSONObjBuilder spec;
spec.appendBool( "capped", true );
spec.append( "size", size );
if ( temp )
spec.appendBool( "temp", true );
Status status = userCreateNS( ctx.db(), toNs, spec.done(), logForReplication );
if ( !status.isOK() )
return status;
}
Collection* toCollection = db->getCollection( toNs );
invariant( toCollection ); // we created above
// how much data to ignore because it won't fit anyway
// datasize and extentSize can't be compared exactly, so add some padding to 'size'
long long excessSize =
static_cast<long long>( fromCollection->dataSize() -
( toCollection->storageSize() * 2 ) );
scoped_ptr<Runner> runner( InternalPlanner::collectionScan(fromNs,
fromCollection,
InternalPlanner::FORWARD ) );
while ( true ) {
BSONObj obj;
Runner::RunnerState state = runner->getNext(&obj, NULL);
switch( state ) {
case Runner::RUNNER_EOF:
return Status::OK();
case Runner::RUNNER_DEAD:
db->dropCollection( toNs );
return Status( ErrorCodes::InternalError, "runner turned dead while iterating" );
case Runner::RUNNER_ERROR:
return Status( ErrorCodes::InternalError, "runner error while iterating" );
case Runner::RUNNER_ADVANCED:
if ( excessSize > 0 ) {
excessSize -= ( 4 * obj.objsize() ); // 4x is for padding, power of 2, etc...
continue;
}
toCollection->insertDocument( obj, true );
if ( logForReplication )
logOp( "i", toNs.c_str(), obj );
getDur().commitIfNeeded();
}
}
invariant( false ); // unreachable
}
unsigned long long addExistingToIndex( OperationContext* txn,
Collection* collection,
const IndexDescriptor* descriptor,
IndexAccessMethod* accessMethod,
bool canBeKilled ) {
string ns = collection->ns().ns(); // our copy for sanity
bool dupsAllowed = !descriptor->unique();
bool dropDups = descriptor->dropDups();
string curopMessage;
{
stringstream ss;
ss << "Index Build";
if ( canBeKilled )
ss << "(background)";
curopMessage = ss.str();
}
ProgressMeter& progress =
cc().curop()->setMessage( curopMessage.c_str(),
curopMessage,
collection->numRecords() );
unsigned long long n = 0;
unsigned long long numDropped = 0;
auto_ptr<Runner> runner(InternalPlanner::collectionScan(ns,collection));
std::string idxName = descriptor->indexName();
// After this yields in the loop, idx may point at a different index (if indexes get
// flipped, see insert_makeIndex) or even an empty IndexDetails, so nothing below should
// depend on idx. idxNo should be recalculated after each yield.
BSONObj js;
DiskLoc loc;
while (Runner::RUNNER_ADVANCED == runner->getNext(&js, &loc)) {
try {
if ( !dupsAllowed && dropDups ) {
LastError::Disabled led( lastError.get() );
addKeysToIndex(txn, collection, descriptor, accessMethod, js, loc);
}
else {
addKeysToIndex(txn, collection, descriptor, accessMethod, js, loc);
}
}
catch( AssertionException& e ) {
if (ErrorCodes::isInterruption(DBException::convertExceptionCode(e.getCode()))) {
txn->checkForInterrupt();
}
// TODO: Does exception really imply dropDups exception?
if (dropDups) {
bool runnerEOF = runner->isEOF();
runner->saveState();
BSONObj toDelete;
collection->deleteDocument( txn, loc, false, true, &toDelete );
logOp( txn, "d", ns.c_str(), toDelete );
if (!runner->restoreState(txn)) {
// Runner got killed somehow. This probably shouldn't happen.
if (runnerEOF) {
// Quote: "We were already at the end. Normal.
// TODO: Why is this normal?
}
else {
uasserted(ErrorCodes::CursorNotFound,
"cursor gone during bg index; dropDups");
}
break;
}
// We deleted a record, but we didn't actually yield the dblock.
// TODO: Why did the old code assume we yielded the lock?
numDropped++;
}
else {
log() << "background addExistingToIndex exception " << e.what() << endl;
throw;
}
}
n++;
progress.hit();
txn->recoveryUnit()->commitIfNeeded();
if (canBeKilled) {
// Checking for interrupt here is necessary because the bg index
// interruptors can only interrupt this index build while they hold
// a write lock, and yieldAndCheckIfOK only checks for
// interrupt prior to yielding our write lock. We need to check the kill flag
// here before another iteration of the loop.
txn->checkForInterrupt();
}
progress.setTotalWhileRunning( collection->numRecords() );
}
progress.finished();
if ( dropDups && numDropped )
log() << "\t index build dropped: " << numDropped << " dups";
return n;
}
SmartPointer<ISafeRunnableRunner> SafeRunnable::CreateDefaultRunner()
{
ISafeRunnableRunner::Pointer runner(new DefaultSafeRunnableRunner());
return runner;
}
/**
* This is called by db/ops/query.cpp. This is the entry point for answering a query.
*/
std::string newRunQuery(CanonicalQuery* cq, CurOp& curop, Message &result) {
QLOG() << "Running query on new system: " << cq->toString();
// This is a read lock.
Client::ReadContext ctx(cq->ns(), storageGlobalParams.dbpath);
// Parse, canonicalize, plan, transcribe, and get a runner.
Runner* rawRunner = NULL;
// We use this a lot below.
const LiteParsedQuery& pq = cq->getParsed();
// Need to call cq->toString() now, since upon error getRunner doesn't guarantee
// cq is in a consistent state.
string cqStr = cq->toString();
// We'll now try to get the query runner that will execute this query for us. There
// are a few cases in which we know upfront which runner we should get and, therefore,
// we shortcut the selection process here.
//
// (a) If the query is over a collection that doesn't exist, we get a special runner
// that's is so (a runner) which doesn't return results, the EOFRunner.
//
// (b) if the query is a replication's initial sync one, we get a SingleSolutinRunner
// that uses a specifically designed stage that skips extents faster (see details in
// exec/oplogstart.h)
//
// Otherwise we go through the selection of which runner is most suited to the
// query + run-time context at hand.
Status status = Status::OK();
if (ctx.ctx().db()->getCollection(cq->ns()) == NULL) {
rawRunner = new EOFRunner(cq, cq->ns());
}
else if (pq.hasOption(QueryOption_OplogReplay)) {
status = getOplogStartHack(cq, &rawRunner);
}
else {
// Takes ownership of cq.
size_t options = QueryPlannerParams::DEFAULT;
if (shardingState.needCollectionMetadata(pq.ns())) {
options |= QueryPlannerParams::INCLUDE_SHARD_FILTER;
}
status = getRunner(cq, &rawRunner, options);
}
if (!status.isOK()) {
uasserted(17007, "Couldn't get runner for query because: " + status.reason() + " query is " + cqStr);
}
verify(NULL != rawRunner);
auto_ptr<Runner> runner(rawRunner);
// We freak out later if this changes before we're done with the query.
const ChunkVersion shardingVersionAtStart = shardingState.getVersion(cq->ns());
// Handle query option $maxTimeMS (not used with commands).
curop.setMaxTimeMicros(static_cast<unsigned long long>(pq.getMaxTimeMS()) * 1000);
killCurrentOp.checkForInterrupt(); // May trigger maxTimeAlwaysTimeOut fail point.
// uassert if we are not on a primary, and not a secondary with SlaveOk query parameter set.
replVerifyReadsOk(&pq);
// If this exists, the collection is sharded.
// If it doesn't exist, we can assume we're not sharded.
// If we're sharded, we might encounter data that is not consistent with our sharding state.
// We must ignore this data.
CollectionMetadataPtr collMetadata;
if (!shardingState.needCollectionMetadata(pq.ns())) {
collMetadata = CollectionMetadataPtr();
}
else {
collMetadata = shardingState.getCollectionMetadata(pq.ns());
}
// Run the query.
// bb is used to hold query results
// this buffer should contain either requested documents per query or
// explain information, but not both
BufBuilder bb(32768);
bb.skip(sizeof(QueryResult));
// How many results have we obtained from the runner?
int numResults = 0;
// If we're replaying the oplog, we save the last time that we read.
OpTime slaveReadTill;
// Do we save the Runner in a ClientCursor for getMore calls later?
bool saveClientCursor = false;
// We turn on auto-yielding for the runner here. The runner registers itself with the
// active runners list in ClientCursor.
ClientCursor::registerRunner(runner.get());
runner->setYieldPolicy(Runner::YIELD_AUTO);
auto_ptr<DeregisterEvenIfUnderlyingCodeThrows> safety(
new DeregisterEvenIfUnderlyingCodeThrows(runner.get()));
BSONObj obj;
Runner::RunnerState state;
// uint64_t numMisplacedDocs = 0;
// set this outside loop. we will need to use this both within loop and when deciding
// to fill in explain information
const bool isExplain = pq.isExplain();
while (Runner::RUNNER_ADVANCED == (state = runner->getNext(&obj, NULL))) {
// Add result to output buffer. This is unnecessary if explain info is requested
if (!isExplain) {
bb.appendBuf((void*)obj.objdata(), obj.objsize());
}
// Count the result.
++numResults;
// Possibly note slave's position in the oplog.
if (pq.hasOption(QueryOption_OplogReplay)) {
BSONElement e = obj["ts"];
if (Date == e.type() || Timestamp == e.type()) {
slaveReadTill = e._opTime();
}
}
// TODO: only one type of 2d search doesn't support this. We need a way to pull it out
// of CanonicalQuery. :(
const bool supportsGetMore = true;
if (isExplain) {
if (enoughForExplain(pq, numResults)) {
break;
}
}
else if (!supportsGetMore && (enough(pq, numResults)
|| bb.len() >= MaxBytesToReturnToClientAtOnce)) {
break;
}
else if (enoughForFirstBatch(pq, numResults, bb.len())) {
QLOG() << "Enough for first batch, wantMore=" << pq.wantMore()
<< " numToReturn=" << pq.getNumToReturn()
<< " numResults=" << numResults
<< endl;
// If only one result requested assume it's a findOne() and don't save the cursor.
if (pq.wantMore() && 1 != pq.getNumToReturn()) {
QLOG() << " runner EOF=" << runner->isEOF() << endl;
saveClientCursor = !runner->isEOF();
}
break;
}
}
// If we cache the runner later, we want to deregister it as it receives notifications
// anyway by virtue of being cached.
//
// If we don't cache the runner later, we are deleting it, so it must be deregistered.
//
// So, no matter what, deregister the runner.
safety.reset();
// Caller expects exceptions thrown in certain cases:
// * in-memory sort using too much RAM.
if (Runner::RUNNER_ERROR == state) {
uasserted(17144, "Runner error, memory limit for sort probably exceeded");
}
// Why save a dead runner?
if (Runner::RUNNER_DEAD == state) {
saveClientCursor = false;
}
else if (pq.hasOption(QueryOption_CursorTailable)) {
// If we're tailing a capped collection, we don't bother saving the cursor if the
// collection is empty. Otherwise, the semantics of the tailable cursor is that the
// client will keep trying to read from it. So we'll keep it around.
Collection* collection = ctx.ctx().db()->getCollection(cq->ns());
if (collection && collection->numRecords() != 0 && pq.getNumToReturn() != 1) {
saveClientCursor = true;
}
}
// TODO(greg): This will go away soon.
if (!shardingState.getVersion(pq.ns()).isWriteCompatibleWith(shardingVersionAtStart)) {
// if the version changed during the query we might be missing some data and its safe to
// send this as mongos can resend at this point
throw SendStaleConfigException(pq.ns(), "version changed during initial query",
shardingVersionAtStart,
shardingState.getVersion(pq.ns()));
}
// Append explain information to query results by asking the runner to produce them.
if (isExplain) {
TypeExplain* bareExplain;
Status res = runner->getExplainPlan(&bareExplain);
if (!res.isOK()) {
error() << "could not produce explain of query '" << pq.getFilter()
<< "', error: " << res.reason();
// If numResults and the data in bb don't correspond, we'll crash later when rooting
// through the reply msg.
BSONObj emptyObj;
bb.appendBuf((void*)emptyObj.objdata(), emptyObj.objsize());
// The explain output is actually a result.
numResults = 1;
// TODO: we can fill out millis etc. here just fine even if the plan screwed up.
}
else {
boost::scoped_ptr<TypeExplain> explain(bareExplain);
// Fill in the missing run-time fields in explain, starting with propeties of
// the process running the query.
std::string server = mongoutils::str::stream()
<< getHostNameCached() << ":" << serverGlobalParams.port;
explain->setServer(server);
// We might have skipped some results due to chunk migration etc. so our count is
// correct.
explain->setN(numResults);
// Clock the whole operation.
explain->setMillis(curop.elapsedMillis());
BSONObj explainObj = explain->toBSON();
bb.appendBuf((void*)explainObj.objdata(), explainObj.objsize());
// The explain output is actually a result.
numResults = 1;
}
}
long long ccId = 0;
if (saveClientCursor) {
// We won't use the runner until it's getMore'd.
runner->saveState();
// Allocate a new ClientCursor. We don't have to worry about leaking it as it's
// inserted into a global map by its ctor.
ClientCursor* cc = new ClientCursor(runner.get(), cq->getParsed().getOptions(),
cq->getParsed().getFilter());
ccId = cc->cursorid();
QLOG() << "caching runner with cursorid " << ccId
<< " after returning " << numResults << " results" << endl;
// ClientCursor takes ownership of runner. Release to make sure it's not deleted.
runner.release();
// TODO document
if (pq.hasOption(QueryOption_OplogReplay) && !slaveReadTill.isNull()) {
cc->slaveReadTill(slaveReadTill);
}
// TODO document
if (pq.hasOption(QueryOption_Exhaust)) {
curop.debug().exhaust = true;
}
// Set attributes for getMore.
cc->setCollMetadata(collMetadata);
cc->setPos(numResults);
// If the query had a time limit, remaining time is "rolled over" to the cursor (for
// use by future getmore ops).
cc->setLeftoverMaxTimeMicros(curop.getRemainingMaxTimeMicros());
}
else {
QLOG() << "not caching runner but returning " << numResults << " results\n";
}
// Add the results from the query into the output buffer.
result.appendData(bb.buf(), bb.len());
bb.decouple();
// Fill out the output buffer's header.
QueryResult* qr = static_cast<QueryResult*>(result.header());
qr->cursorId = ccId;
curop.debug().cursorid = (0 == ccId ? -1 : ccId);
qr->setResultFlagsToOk();
qr->setOperation(opReply);
qr->startingFrom = 0;
qr->nReturned = numResults;
curop.debug().ntoskip = pq.getSkip();
curop.debug().nreturned = numResults;
// curop.debug().exhaust is set above.
return curop.debug().exhaust ? pq.ns() : "";
}
AbstractCommand::ReturnCodes Record::record()
{
if (! checkInRepository())
return NotInRepo;
moveToRoot(CheckFileSystem);
if (m_mode != Unset)
m_all = m_mode == AllChanges;
const bool needHunks = !m_all || m_patchName.isEmpty();
ChangeSet changeSet;
changeSet.fillFromCurrentChanges(rebasedArguments(), needHunks);
changeSet.waitForFinishFirstFile();
bool shouldDoRecord = changeSet.count() > 0;
if (!shouldDoRecord) {
Logger::warn() << "No changes!" << endl;
return Ok;
}
QString email = m_author;
if (email.isEmpty())
email = getenv("EMAIL");
QStringList environment;
if (! email.isEmpty()) {
QRegExp re("(.*) <([@\\S]+)>");
if (re.exactMatch(email)) { // meaning its an email AND name
environment << "GIT_AUTHOR_NAME="+ re.cap(1);
environment << "GIT_COMMITTER_NAME="+ re.cap(1);
environment << "GIT_AUTHOR_EMAIL="+ re.cap(2);
environment << "GIT_COMMITTER_EMAIL="+ re.cap(2);
}
else if (m_author.isEmpty()) { // if its an account or shell wide option; just use the git defs.
environment << "GIT_AUTHOR_EMAIL="+ email;
environment << "GIT_COMMITTER_EMAIL="+ email;
}
else {
Logger::error() << "Author format invalid. Please provide author formatted like; `name <email@host>\n";
return InvalidOptions;
}
}
if (shouldDoRecord && !m_all && m_mode != Index) { // then do interview
HunksCursor cursor(changeSet);
cursor.setConfiguration(m_config);
Interview interview(cursor, name());
interview.setUsePager(shouldUsePager());
if (! interview.start()) {
Logger::warn() << "Cancelled." << endl;
return UserCancelled;
}
}
if (shouldDoRecord && !m_all && m_mode != Index) { // check if there is anything selected
shouldDoRecord = changeSet.hasAcceptedChanges();
if (! shouldDoRecord) {
Logger::warn() << "Ok, if you don't want to record anything, that's fine!" <<endl;
return UserCancelled;
}
}
if (dryRun())
return Ok;
if ((m_editComment || m_patchName.isEmpty()) && getenv("EDITOR")) {
class Deleter : public QObject {
public:
Deleter() : commitMessage(0) { }
~Deleter() {
if (commitMessage)
commitMessage->remove();
}
QFile *commitMessage;
};
Deleter parent;
QFile *commitMessage;
int i = 0;
do {
commitMessage = new QFile(QString("vng-record-%1").arg(i++), &parent);
} while (commitMessage->exists());
parent.commitMessage = commitMessage; // make sure the file is removed from FS.
if (! commitMessage->open(QIODevice::WriteOnly)) {
Logger::error() << "Vng failed. Could not create a temporary file for the record message '"
<< commitMessage->fileName() << "`\n";
return WriteError;
}
const char * defaultCommitMessage1 = "\n***END OF DESCRIPTION***"; // we will look for this string later
const char * defaultCommitMessage2 = "\nPlace the long patch description above the ***END OF DESCRIPTION*** marker.\n\nThis patch contains the following changes:\n\n";
if (! m_patchName.isEmpty())
commitMessage->write(m_patchName);
else
commitMessage->write("\n", 1);
commitMessage->write(defaultCommitMessage1, strlen(defaultCommitMessage1));
commitMessage->write(defaultCommitMessage2, strlen(defaultCommitMessage2));
QBuffer buffer;
changeSet.writeDiff(buffer, m_all ? ChangeSet::AllHunks : ChangeSet::UserSelection);
ChangeSet actualChanges;
actualChanges.fillFromDiffFile(buffer);
QTextStream out (commitMessage);
for (int i=0; i < actualChanges.count(); ++i) {
File file = actualChanges.file(i);
file.outputWhatsChanged(out, m_config, true, false);
}
for (int i=0; i < changeSet.count(); ++i) {
File file = changeSet.file(i);
if (file.isBinary() && (m_all || file.binaryChangeAcceptance() == Vng::Accepted))
out << "M " << QString::fromLocal8Bit(file.fileName());
else if (file.fileName().isEmpty() && (m_all || file.renameAcceptance() == Vng::Accepted))
out << "D " << QString::fromLocal8Bit(file.oldFileName());
}
out.flush();
commitMessage->close();
QDateTime modification = QFileInfo(*commitMessage).lastModified();
QString command = QString("%1 %2").arg(getenv("EDITOR")).arg(commitMessage->fileName());
int rc = system(command.toAscii().data());
if (rc != 0) {
// this will keep patchName empty and we fall through to the interview.
Logger::warn() << "Vng-Warning: Could not start editor '" << getenv("EDITOR") << "`\n";
Logger::warn().flush();
}
else if (modification == QFileInfo(*commitMessage).lastModified()) {
Logger::warn() << "unchanged, won't record\n";
return UserCancelled;
}
else {
// get data until the separator line.
commitMessage->open(QIODevice::ReadOnly);
m_patchName = commitMessage->readAll();
commitMessage->close();
int cuttoff = m_patchName.indexOf(defaultCommitMessage1);
if (cuttoff > 0)
m_patchName.truncate(cuttoff);
for (int i = m_patchName.length()-1; i >= 0; --i) {
if (m_patchName[i] == '\n' || m_patchName[i] == '\r' || m_patchName[i] == ' ')
m_patchName.resize(i); // shrink
else break;
}
}
}
if (m_patchName.isEmpty())
m_patchName = Interview::ask("What is the patch name? ").toUtf8();
ReturnCodes rc = addFilesPerAcceptance(changeSet, m_all);
if (rc != Ok)
return rc;
QProcess git;
QStringList arguments;
arguments << "write-tree";
GitRunner runner(git, arguments);
rc = runner.start(GitRunner::WaitForStandardOutput);
if (rc != Ok) {
Logger::error() << "Git write-tree failed!, aborting record\n";
return rc;
}
char buf[1024];
Vng::readLine(&git, buf, sizeof(buf));
QString tree(buf);
git.waitForFinished(); // patiently wait for it to finish..
Logger::debug() << "The tree got git ref; " << tree;
Logger::debug().flush(); // flush since we do an ask next
arguments.clear();
git.setEnvironment(environment);
arguments << "commit-tree" << tree.left(40);
if (!m_config.isEmptyRepo())
arguments << "-p" << "HEAD" ;
runner.setArguments(arguments);
rc = runner.start(GitRunner::WaitUntilReadyForWrite);
if (rc != Ok) {
Logger::error() << "Git commit-tree failed!, aborting record\n";
return rc;
}
git.write(m_patchName);
git.write("\n");
git.closeWriteChannel();
Vng::readLine(&git, buf, sizeof(buf));
QString commit(buf);
Logger::debug() << "commit is ref; " << commit;
git.waitForFinished(); // patiently wait for it to finish..
if (commit.isEmpty()) {
Logger::error() << "Git update-ref failed to produce a reference!, aborting record\n";
return GitFailed;
}
m_sha1 = commit.left(40);
arguments.clear();
arguments << "update-ref" << "HEAD" << m_sha1;
runner.setArguments(arguments);
rc = runner.start(GitRunner::WaitUntilFinished);
if (rc != Ok) {
Logger::error() << "Git update-ref failed!, aborting record\n";
return rc;
}
// We removed files from the index in case they were freshly added, but the user didn't want it in this commit.
// we have to re-add those files.
arguments.clear();
arguments << "update-index" << "--add";
for (int i=0; i < changeSet.count(); ++i) {
File file = changeSet.file(i);
if (! file.oldFileName().isEmpty())
continue; // not a new added file.
if (file.renameAcceptance() == Vng::Rejected)
arguments.append(file.fileName());
}
if (arguments.count() > 2) {
runner.setArguments(arguments);
runner.start(GitRunner::WaitUntilFinished);
}
int endOfLine = m_patchName.indexOf('\n');
if (endOfLine > 0)
m_patchName.truncate(endOfLine);
Logger::warn() << "Finished recording patch `" << m_patchName << "'" << endl;
return Ok;
}
/*
* Runs the command object cmdobj on the db with name dbname and puts result in result.
* @param dbname, name of db
* @param cmdobj, object that contains entire command
* @param options
* @param errmsg, reference to error message
* @param result, reference to builder for result
* @param fromRepl
* @return true if successful, false otherwise
*/
bool FTSCommand::_run(const string& dbname,
BSONObj& cmdObj,
int cmdOptions,
const string& ns,
const string& searchString,
string language, // "" for not-set
int limit,
BSONObj& filter,
BSONObj& projection,
string& errmsg,
BSONObjBuilder& result ) {
Timer comm;
// Rewrite the cmd as a normal query.
BSONObjBuilder queryBob;
queryBob.appendElements(filter);
BSONObjBuilder textBob;
textBob.append("$search", searchString);
if (!language.empty()) {
textBob.append("$language", language);
}
queryBob.append("$text", textBob.obj());
// This is the query we exec.
BSONObj queryObj = queryBob.obj();
// We sort by the score.
BSONObj sortSpec = BSON("$s" << BSON("$meta" << "text"));
// We also project the score into the document and strip it out later during the reformatting
// of the results.
BSONObjBuilder projBob;
projBob.appendElements(projection);
projBob.appendElements(sortSpec);
BSONObj projObj = projBob.obj();
CanonicalQuery* cq;
if (!CanonicalQuery::canonicalize(ns, queryObj, sortSpec, projObj, 0, limit, BSONObj(), &cq).isOK()) {
errmsg = "Can't parse filter / create query";
return false;
}
Runner* rawRunner;
if (!getRunner(cq, &rawRunner, 0).isOK()) {
errmsg = "can't get query runner";
return false;
}
auto_ptr<Runner> runner(rawRunner);
BSONArrayBuilder resultBuilder(result.subarrayStart("results"));
// Quoth: "leave a mb for other things"
int resultSize = 1024 * 1024;
int numReturned = 0;
BSONObj obj;
while (Runner::RUNNER_ADVANCED == runner->getNext(&obj, NULL)) {
if ((resultSize + obj.objsize()) >= BSONObjMaxUserSize) {
break;
}
// We return an array of results. Add another element.
BSONObjBuilder oneResultBuilder(resultBuilder.subobjStart());
oneResultBuilder.append("score", obj["$s"].number());
// Strip out the score from the returned obj.
BSONObjIterator resIt(obj);
BSONObjBuilder resBob;
while (resIt.more()) {
BSONElement elt = resIt.next();
if (!mongoutils::str::equals("$s", elt.fieldName())) {
resBob.append(elt);
}
}
oneResultBuilder.append("obj", resBob.obj());
BSONObj addedArrayObj = oneResultBuilder.done();
resultSize += addedArrayObj.objsize();
numReturned++;
}
resultBuilder.done();
// returns some stats to the user
BSONObjBuilder stats(result.subobjStart("stats"));
// Fill in nscanned from the explain.
TypeExplain* bareExplain;
Status res = runner->getExplainPlan(&bareExplain);
if (res.isOK()) {
auto_ptr<TypeExplain> explain(bareExplain);
stats.append("nscanned", explain->getNScanned());
stats.append("nscannedObjects", explain->getNScannedObjects());
}
stats.appendNumber( "n" , numReturned );
stats.append( "timeMicros", (int)comm.micros() );
stats.done();
return true;
}
bool group( OperationContext* txn,
Database* db,
const std::string& ns,
const BSONObj& query,
BSONObj keyPattern,
const std::string& keyFunctionCode,
const std::string& reduceCode,
const char * reduceScope,
BSONObj initial,
const std::string& finalize,
string& errmsg,
BSONObjBuilder& result ) {
const string userToken = ClientBasic::getCurrent()->getAuthorizationSession()
->getAuthenticatedUserNamesToken();
auto_ptr<Scope> s = globalScriptEngine->getPooledScope(db->name(), "group" + userToken);
if ( reduceScope )
s->init( reduceScope );
s->setObject( "$initial" , initial , true );
s->exec( "$reduce = " + reduceCode , "$group reduce setup" , false , true , true , 100 );
s->exec( "$arr = [];" , "$group reduce setup 2" , false , true , true , 100 );
ScriptingFunction f = s->createFunction(
"function(){ "
" if ( $arr[n] == null ){ "
" next = {}; "
" Object.extend( next , $key ); "
" Object.extend( next , $initial , true ); "
" $arr[n] = next; "
" next = null; "
" } "
" $reduce( obj , $arr[n] ); "
"}" );
ScriptingFunction keyFunction = 0;
if ( keyFunctionCode.size() ) {
keyFunction = s->createFunction( keyFunctionCode.c_str() );
}
double keysize = keyPattern.objsize() * 3;
double keynum = 1;
Collection* collection = db->getCollection( txn, ns );
const WhereCallbackReal whereCallback(txn, StringData(db->name()));
map<BSONObj,int,BSONObjCmp> map;
list<BSONObj> blah;
if (collection) {
CanonicalQuery* cq;
if (!CanonicalQuery::canonicalize(ns, query, &cq, whereCallback).isOK()) {
uasserted(17212, "Can't canonicalize query " + query.toString());
return 0;
}
Runner* rawRunner;
if (!getRunner(txn,collection, cq, &rawRunner).isOK()) {
uasserted(17213, "Can't get runner for query " + query.toString());
return 0;
}
auto_ptr<Runner> runner(rawRunner);
const ScopedRunnerRegistration safety(runner.get());
BSONObj obj;
Runner::RunnerState state;
while (Runner::RUNNER_ADVANCED == (state = runner->getNext(&obj, NULL))) {
BSONObj key = getKey(obj , keyPattern , keyFunction , keysize / keynum,
s.get() );
keysize += key.objsize();
keynum++;
int& n = map[key];
if ( n == 0 ) {
n = map.size();
s->setObject( "$key" , key , true );
uassert(17203, "group() can't handle more than 20000 unique keys",
n <= 20000 );
}
s->setObject( "obj" , obj , true );
s->setNumber( "n" , n - 1 );
if ( s->invoke( f , 0, 0 , 0 , true ) ) {
throw UserException(17214,
(string)"reduce invoke failed: " + s->getError());
}
}
}
if (!finalize.empty()) {
s->exec( "$finalize = " + finalize , "$group finalize define" ,
false , true , true , 100 );
ScriptingFunction g = s->createFunction(
"function(){ "
" for(var i=0; i < $arr.length; i++){ "
" var ret = $finalize($arr[i]); "
" if (ret !== undefined) "
" $arr[i] = ret; "
" } "
"}" );
s->invoke( g , 0, 0 , 0 , true );
}
result.appendArray( "retval" , s->getObject( "$arr" ) );
result.append( "count" , keynum - 1 );
result.append( "keys" , (int)(map.size()) );
s->exec( "$arr = [];" , "$group reduce setup 2" , false , true , true , 100 );
s->gc();
return true;
}
int main(int argc, const char* argv[]) {
try {
TCLAP::CmdLine cmd("Xylene", ' ', "pre-release");
TCLAP::SwitchArg asXML("", "xml", "Read file using the XML parser", cmd);
TCLAP::SwitchArg printTokens("", "tokens", "Print token list", cmd);
TCLAP::SwitchArg printAST("", "ast", "Print AST (if applicable)", cmd);
TCLAP::SwitchArg printIR("", "ir", "Print LLVM IR (if applicable)", cmd);
TCLAP::SwitchArg doNotParse("", "no-parse", "Don't parse the token list", cmd);
TCLAP::SwitchArg doNotRun("", "no-run", "Don't execute the AST", cmd);
std::vector<std::string> runnerValues {"llvm-lli", "llvm-llc"};
TCLAP::ValuesConstraint<std::string> runnerConstraint(runnerValues);
TCLAP::ValueArg<std::string> runner("r", "runner", "How to run this code", false,
"llvm-lli", &runnerConstraint, cmd, nullptr);
TCLAP::ValueArg<std::string> code("e", "eval", "Code to evaluate", false,
std::string(), "string", cmd, nullptr);
TCLAP::ValueArg<std::string> filePath("f", "file", "Load code from this file",
false, std::string(), "path", cmd, nullptr);
cmd.parse(argc, argv);
if (code.getValue().empty() && filePath.getValue().empty()) {
TCLAP::ArgException arg("Must specify either option -e or -f");
cmd.getOutput()->failure(cmd, arg);
}
std::unique_ptr<AST> ast;
if (asXML.getValue()) {
if (doNotParse.getValue()) return NORMAL_EXIT;
if (filePath.getValue().empty()) {
TCLAP::ArgException arg("XML option only works with files");
cmd.getOutput()->failure(cmd, arg);
}
ast = std::make_unique<AST>(XMLParser().parse(rapidxml::file<>(filePath.getValue().c_str())).getTree());
} else {
std::string input;
if (!filePath.getValue().empty()) {
std::ifstream file(filePath.getValue());
std::stringstream buffer;
buffer << file.rdbuf();
input = buffer.str();
} else {
input = code.getValue();
}
auto lx = Lexer();
lx.tokenize(input, filePath.getValue().empty() ? "<cli-eval>" : filePath.getValue());
if (printTokens.getValue()) for (auto tok : lx.getTokens()) println(tok);
if (doNotParse.getValue()) return NORMAL_EXIT;
ast = std::make_unique<AST>(TokenParser().parse(lx.getTokens()).getTree());
}
if (printAST.getValue()) ast->print();
if (doNotRun.getValue()) return NORMAL_EXIT;
CompileVisitor::Link v = CompileVisitor::create("Command Line Module", *ast);
v->visit();
if (printIR.getValue()) v->getModule()->dump();
if (runner.getValue() == "llvm-lli") {
return Runner(v).run();
} else if (runner.getValue() == "llvm-llc") {
println("Not yet implemented!");
// TODO
}
} catch (const TCLAP::ExitException& arg) {
return CLI_ERROR;
} catch (const TCLAP::ArgException& arg) {
println("TCLAP error", arg.error(), "for", arg.argId());
return TCLAP_ERROR;
} catch (const Error& err) {
println(err.what());
return USER_PROGRAM_ERROR;
}
// If we're debugging, crash the program on InternalError
#ifndef CRASH_ON_INTERNAL_ERROR
catch (const InternalError& err) {
println(err.what());
return INTERNAL_ERROR;
}
#endif
return 0;
}