Status storeMongoDumpOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
mongoDumpGlobalParams.repair = hasParam("repair");
if (mongoDumpGlobalParams.repair){
if (!hasParam("dbpath")) {
return Status(ErrorCodes::BadValue, "repair mode only works with --dbpath");
}
if (!hasParam("db")) {
return Status(ErrorCodes::BadValue,
"repair mode only works on 1 db at a time right now");
}
}
mongoDumpGlobalParams.query = getParam("query");
mongoDumpGlobalParams.useOplog = hasParam("oplog");
if (mongoDumpGlobalParams.useOplog) {
if (hasParam("query") || hasParam("db") || hasParam("collection")) {
return Status(ErrorCodes::BadValue, "oplog mode is only supported on full dumps");
}
}
mongoDumpGlobalParams.outputFile = getParam("out");
mongoDumpGlobalParams.snapShotQuery = false;
if (!hasParam("query") && !hasParam("dbpath") && !hasParam("forceTableScan")) {
mongoDumpGlobalParams.snapShotQuery = true;
}
// Make the default db "" if it was not explicitly set
if (!params.count("db")) {
toolGlobalParams.db = "";
}
if (mongoDumpGlobalParams.outputFile == "-") {
// write output to standard error to avoid mangling output
// must happen early to avoid sending junk to stdout
toolGlobalParams.canUseStdout = false;
}
return Status::OK();
}
int Scenario::loadMapBuf(string mapn) {
mapname=mapn;
ifstream mapfile;
string tmpline;
string loadfile=config.datadir+mapname;
mapfile.open(loadfile.c_str());
if (mapfile) {
cout << "Loading new map: " << loadfile << endl;
} else {
cout << "Map loading failed: " << loadfile << " not found!\n";
return 2;
}
mapbuf.clear();
/* We parse the parameters to add a name if it was missing
This whole file reading looks much more complicated because
of this (otherwise there would only be mapbuf.push_back(tmpline) */
string cname;
Uint16 x,y;
ParameterMap parameters;
bool header=true;
std::map<string,Uint16> namecount;
while (getline(mapfile,tmpline)) {
if (header) {
mapbuf.push_back(tmpline);
std::istringstream tmpstream(tmpline);
tmpstream >> cname;
if (cname[0]=='#') {
if (cname=="#ENDHEADER") header=false;
continue;
}
} else {
cname.erase();
x=y=0;
std::istringstream tmpstream(tmpline);
tmpstream >> cname >> x >> y;
if (cname.empty() || cname[0]=='#') {
mapbuf.push_back(tmpline);
continue;
} else {
namecount[cname]++;
}
string parameterlist((istreambuf_iterator<char>(tmpstream)), istreambuf_iterator<char>());
parameters=getParameters(parameterlist);
if (!hasParam(parameters,"name")) {
if (parameters.empty()) tmpline+=" name="+cname+itos(namecount[cname]);
else tmpline+=", name="+cname+itos(namecount[cname]);
}
mapbuf.push_back(tmpline);
}
}
Object* ObjectsPool::addObjectbyName(const string& obj, Sint16 x, Sint16 y, const ParameterMap& objparam, bool outside) {
ParameterMap parameters;
if (hasParam(objparam,"file")) {
parameters=getFileParameters(objparam.find("file")->second);
ParameterMap::const_iterator it=objparam.begin();
while (it!=objparam.end()) {
if (it->first!="file") parameters[it->first]=it->second;
++it;
}
} else {
parameters=objparam;
}
//Set names...
if (!hasParam(parameters,"name")) parameters["name"]=getNextObjectName(obj);
if (obj=="Wall") return (addObject(new Wall(x,y,parameters), outside));
else if (obj=="Exit") return (addObject(new Exit(x,y,parameters), outside));
else if (obj=="Water") return (addObject(new Water(x,y,parameters), outside));
else if (obj=="Teleporter") return (addObject(new Teleporter(x,y,parameters), outside));
else if (obj=="Wind") return (addObject(new Wind(x,y,parameters), outside));
else if (obj=="Geyser") return (addObject(new Geyser(x,y,parameters), outside));
else if (obj=="Trigger") return (addObject(new Trigger(x,y,parameters), outside));
else if (obj=="Door") return (addObject(new Door(x,y,parameters), outside));
else if (obj=="Spike") return (addObject(new Spike(x,y,parameters), outside));
else if (obj=="Heart") return (addObject(new Heart(x,y,parameters), outside));
else if (obj=="Key") return (addObject(new Key(x,y,parameters), outside));
else if (obj=="Bomb") return (addObject(new Bomb(x,y,parameters), outside));
else if (obj=="TriggeredBomb") return (addObject(new TriggeredBomb(x,y,parameters), outside));
else if (obj=="DeadPlayer") return (addObject(new DeadPlayer(x,y,parameters), outside));
else if (obj=="Erik") return (addObject(new Erik(x,y,parameters), outside));
else if (obj=="Olaf") return (addObject(new Olaf(x,y,parameters), outside));
else if (obj=="Baleog") return (addObject(new Baleog(x,y,parameters), outside));
else if (obj=="Fang") return (addObject(new Fang(x,y,parameters), outside));
else if (obj=="Scorch") return (addObject(new Scorch(x,y,parameters), outside));
else if (obj=="Plant") return (addObject(new Plant(x,y,parameters), outside));
else if (obj=="Zombie") return (addObject(new Zombie(x,y,parameters), outside));
else {
cout << "Object " << obj << " unknown, skipping...\n";
return NULL;
}
}
Status storeMongoExportOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
ret = storeFieldOptions(params, args);
if (!ret.isOK()) {
return ret;
}
mongoExportGlobalParams.outputFile = getParam("out");
mongoExportGlobalParams.outputFileSpecified = hasParam("out");
mongoExportGlobalParams.csv = hasParam("csv");
mongoExportGlobalParams.jsonArray = hasParam("jsonArray");
mongoExportGlobalParams.query = getParam("query", "");
mongoExportGlobalParams.snapShotQuery = false;
if (!hasParam("query") && !hasParam("dbpath") && !hasParam("forceTableScan")) {
mongoExportGlobalParams.snapShotQuery = true;
}
mongoExportGlobalParams.slaveOk = toolsParsedOptions["slaveOk"].as<bool>();
mongoExportGlobalParams.limit = getParam("limit", 0);
mongoExportGlobalParams.skip = getParam("skip", 0);
return Status::OK();
}
Status storeMongoStatOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
if (hasParam("http")) {
mongoStatGlobalParams.http = true;
toolGlobalParams.noconnection = true;
}
if (hasParam("host") && getParam("host").find(',') != string::npos) {
toolGlobalParams.noconnection = true;
mongoStatGlobalParams.many = true;
}
if (hasParam("discover")) {
mongoStatGlobalParams.discover = true;
mongoStatGlobalParams.many = true;
}
mongoStatGlobalParams.showHeaders = !hasParam("noheaders");
mongoStatGlobalParams.rowCount = getParam("rowcount", 0);
mongoStatGlobalParams.sleep = getParam("sleep", 1);
mongoStatGlobalParams.allFields = hasParam("all");
// Make the default db "admin" if it was not explicitly set
if (!toolsParsedOptions.count("db")) {
toolGlobalParams.db = "admin";
}
// Make the default db "admin" if it was not explicitly set
if (!toolsParsedOptions.count("db")) {
toolGlobalParams.db = "admin";
}
return Status::OK();
}
int runNormal() {
bool showHeaders = ! hasParam( "noheaders" );
int rowCount = getParam( "rowcount" , 0 );
int rowNum = 0;
auth();
BSONObj prev = stats();
if ( prev.isEmpty() )
return -1;
int maxLockedDbWidth = 0;
while ( rowCount == 0 || rowNum < rowCount ) {
sleepsecs((int)ceil(_statUtil.getSeconds()));
BSONObj now;
try {
now = stats();
}
catch ( std::exception& e ) {
cout << "can't get data: " << e.what() << endl;
continue;
}
if ( now.isEmpty() )
return -2;
try {
BSONObj out = _statUtil.doRow( prev , now );
// adjust width up as longer 'locked db' values appear
setMaxLockedDbWidth( &out, &maxLockedDbWidth );
if ( showHeaders && rowNum % 10 == 0 ) {
printHeaders( out );
}
printData( out , out );
}
catch ( AssertionException& e ) {
cout << "\nerror: " << e.what() << "\n"
<< now
<< endl;
}
prev = now;
rowNum++;
}
return 0;
}
Status storeBSONToolOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
bsonToolGlobalParams.objcheck = true;
if (hasParam("objcheck") && hasParam("noobjcheck")) {
return Status(ErrorCodes::BadValue, "can't have both --objcheck and --noobjcheck");
}
if (hasParam("objcheck")) {
bsonToolGlobalParams.objcheck = true;
}
else if (hasParam("noobjcheck")) {
bsonToolGlobalParams.objcheck = false;
}
if (hasParam("filter")) {
bsonToolGlobalParams.hasFilter = true;
bsonToolGlobalParams.filter = getParam("filter");
}
return Status::OK();
}
Status storeMongoFilesOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
mongoFilesGlobalParams.command = getParam("command");
mongoFilesGlobalParams.gridFSFilename = getParam("file");
mongoFilesGlobalParams.localFile = getParam("local", mongoFilesGlobalParams.gridFSFilename);
mongoFilesGlobalParams.contentType = getParam("type", "");
mongoFilesGlobalParams.replace = hasParam("replace");
return Status::OK();
}
bool Tool::isMaster() {
if ( hasParam("dbpath") ) {
return true;
}
BSONObj info;
bool isMaster;
bool ok = conn().isMaster(isMaster, &info);
if (ok && !isMaster) {
cerr << "ERROR: trying to write to non-master " << conn().toString() << endl;
cerr << "isMaster info: " << info << endl;
return false;
}
return true;
}
Status storeMongoTopOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
mongoTopGlobalParams.sleep = getParam("sleep", 1);
mongoTopGlobalParams.useLocks = hasParam("locks");
// Make the default db "admin" if it was not explicitly set
if (!params.count("db")) {
toolGlobalParams.db = "admin";
}
return Status::OK();
}
Status storeMongoOplogOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
if (!hasParam("from")) {
return Status(ErrorCodes::BadValue, "need to specify --from");
}
else {
mongoOplogGlobalParams.from = getParam("from");
}
mongoOplogGlobalParams.seconds = getParam("seconds", 86400);
mongoOplogGlobalParams.ns = getParam("oplogns");
return Status::OK();
}
Status storeMongoImportOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
Status ret = storeGeneralToolOptions(params, args);
if (!ret.isOK()) {
return ret;
}
ret = storeFieldOptions(params, args);
if (!ret.isOK()) {
return ret;
}
mongoImportGlobalParams.filename = getParam("file");
mongoImportGlobalParams.drop = hasParam("drop");
mongoImportGlobalParams.ignoreBlanks = hasParam("ignoreBlanks");
if (hasParam("upsert") || hasParam("upsertFields")) {
mongoImportGlobalParams.upsert = true;
string uf = getParam("upsertFields");
if (uf.empty()) {
mongoImportGlobalParams.upsertFields.push_back("_id");
}
else {
StringSplitter(uf.c_str(), ",").split(mongoImportGlobalParams.upsertFields);
}
}
else {
mongoImportGlobalParams.upsert = false;
}
mongoImportGlobalParams.doimport = !hasParam("noimport");
mongoImportGlobalParams.type = getParam("type", "json");
mongoImportGlobalParams.jsonArray = hasParam("jsonArray");
mongoImportGlobalParams.headerLine = hasParam("headerline");
mongoImportGlobalParams.stopOnError = hasParam("stopOnError");
return Status::OK();
}
void OMLItem::_extractCheckClosed(const std::wstring& text, std::wstring::size_type posClose)
{
// Se il tag [img] non ha il parametro 'src', mi aspetto una chiusura, poich il suo body sar il parametro 'src'.
if( ( (m_tagName == _S("img")) && (hasParam(_S("src"))) ) ||
(m_tagName == _S("br")) ||
(m_tagName == _S("hr")) )
{
m_directClose = true;
}
else
{
// Alcuni tag non sono chiudibili direttamente.
// Copre anche l'eccezione (Issue:10)
if( (m_tagName == _S("url")) )
{
m_directClose = false;
}
else
{
m_directClose = ( (posClose>0) && (text[posClose-1] == chForwardSlash) );
}
}
}
Monster::Monster(Sint16 xcord, Sint16 ycord, const ParameterMap& param):
Character(xcord,ycord,param),
Dai(0),
Dattack(0) {
state=STATE_FALL;
otype|=OTYPE_MONSTER;
enemy_types|=OTYPE_PLAYER;
dense_types|=OTYPE_PLAYER;
/* Parameters */
if (hasParam(parameters,"anim_left")) anim_left=loadAnimation(getParameters(parameters["anim_left"],':'));
else anim_left.reset(new EmptyAnimation(&anim_right));
if (hasParam(parameters,"anim_right")) anim_right=loadAnimation(getParameters(parameters["anim_right"],':'));
else anim_right.reset(new EmptyAnimation(&anim_orig));
if (!hasParam(parameters,"maxhealth")) maxhealth=1;
if (!hasParam(parameters,"health")) health=min(1,(int)maxhealth);
if (!hasParam(parameters,"maxspeedx")) maxspeedx=50;
if (!hasParam(parameters,"maxspeedy")) maxspeedy=0;
if (hasParam(parameters,"audio_hit")) au_hit=scenario->sndcache->loadWAV(parameters["audio_hit"]);
else au_hit=scenario->sndcache->loadWAV("monhit.wav");
animation.reset(new EmptyAnimation((state&STATE_LEFT) ? &anim_left : &anim_right));
}
Erik::Erik(Sint16 xcord, Sint16 ycord, const ParameterMap& param):
Player(xcord,ycord,param),
jump(V_JUMP),
jump2(V_JUMP2) {
weapon=Weapon(-1,W_PRESSURE,WS_PRESSURE);
/* Parameters */
if (hasParam(parameters,"anim_erik_jump_left")) anim_erik_jump_left=loadAnimation(getParameters(parameters["anim_erik_jump_left"],':'));
if (hasParam(parameters,"anim_erik_jump_right")) anim_erik_jump_right=loadAnimation(getParameters(parameters["anim_erik_jump_right"],':'));
if (hasParam(parameters,"anim_erik_jump2_left")) anim_erik_jump2_left=loadAnimation(getParameters(parameters["anim_erik_jump2_left"],':'));
if (hasParam(parameters,"anim_erik_jump2_right")) anim_erik_jump2_right=loadAnimation(getParameters(parameters["anim_erik_jump2_right"],':'));
if (hasParam(parameters,"anim_erik_start_run_left")) anim_erik_start_run_left=loadAnimation(getParameters(parameters["anim_erik_start_run_left"],':'));
if (hasParam(parameters,"anim_erik_start_run_right")) anim_erik_start_run_right=loadAnimation(getParameters(parameters["anim_erik_start_run_right"],':'));
if (hasParam(parameters,"anim_erik_run_left")) anim_erik_run_left=loadAnimation(getParameters(parameters["anim_erik_run_left"],':'));
if (hasParam(parameters,"anim_erik_run_right")) anim_erik_run_right=loadAnimation(getParameters(parameters["anim_erik_run_right"],':'));
if (hasParam(parameters,"anim_erik_swim_left")) anim_erik_swim_left=loadAnimation(getParameters(parameters["anim_erik_swim_left"],':'));
if (hasParam(parameters,"anim_erik_swim_right")) anim_erik_swim_right=loadAnimation(getParameters(parameters["anim_erik_swim_right"],':'));
if (hasParam(parameters,"anim_erik_swim_up_left")) anim_erik_swim_up_left=loadAnimation(getParameters(parameters["anim_erik_swim_up_left"],':'));
if (hasParam(parameters,"anim_erik_swim_up_right")) anim_erik_swim_up_right=loadAnimation(getParameters(parameters["anim_erik_swim_up_right"],':'));
if (hasParam(parameters,"anim_erik_hit_water_left")) anim_erik_hit_water_left=loadAnimation(getParameters(parameters["anim_erik_hit_water_left"],':'));
if (hasParam(parameters,"anim_erik_hit_water_right")) anim_erik_hit_water_right=loadAnimation(getParameters(parameters["anim_erik_hit_water_right"],':'));
if (!hasParam(parameters,"audio_hit")) au_hit=scenario->sndcache->loadWAV("erikhit.wav");
if (hasParam(parameters,"audio_jump")) au_jump=scenario->sndcache->loadWAV(parameters["audio_jump"]);
else au_jump=scenario->sndcache->loadWAV("rboots.wav");
if (hasParam(parameters,"audio_run")) au_jump=scenario->sndcache->loadWAV(parameters["audio_run"]);
else au_run=NULL;
}
int runMany() {
StateMap threads;
{
string orig = getParam( "host" );
bool showPorts = false;
if ( orig == "" )
orig = "localhost";
if ( orig.find( ":" ) != string::npos || hasParam( "port" ) )
showPorts = true;
StringSplitter ss( orig.c_str() , "," );
while ( ss.more() ) {
string host = ss.next();
if ( showPorts && host.find( ":" ) == string::npos) {
// port supplied, but not for this host. use default.
if ( hasParam( "port" ) )
host += ":" + _params["port"].as<string>();
else
host += ":27017";
}
_add( threads , host );
}
}
sleepsecs(1);
int row = 0;
bool discover = hasParam( "discover" );
int maxLockedDbWidth = 0;
while ( 1 ) {
sleepsecs( (int)ceil(_statUtil.getSeconds()) );
// collect data
vector<Row> rows;
for ( map<string,shared_ptr<ServerState> >::iterator i=threads.begin(); i!=threads.end(); ++i ) {
scoped_lock lk( i->second->lock );
if ( i->second->error.size() ) {
rows.push_back( Row( i->first , i->second->error ) );
}
else if ( i->second->prev.isEmpty() || i->second->now.isEmpty() ) {
rows.push_back( Row( i->first ) );
}
else {
BSONObj out = _statUtil.doRow( i->second->prev , i->second->now );
rows.push_back( Row( i->first , out ) );
}
if ( discover && ! i->second->now.isEmpty() ) {
if ( _discover( threads , i->first , i->second ) )
break;
}
}
// compute some stats
unsigned longestHost = 0;
BSONObj biggest;
for ( unsigned i=0; i<rows.size(); i++ ) {
if ( rows[i].host.size() > longestHost )
longestHost = rows[i].host.size();
if ( rows[i].data.nFields() > biggest.nFields() )
biggest = rows[i].data;
// adjust width up as longer 'locked db' values appear
setMaxLockedDbWidth( &rows[i].data, &maxLockedDbWidth );
}
{
// check for any headers not in biggest
// TODO: we put any new headers at end,
// ideally we would interleave
set<string> seen;
BSONObjBuilder b;
{
// iterate biggest
BSONObjIterator i( biggest );
while ( i.more() ) {
BSONElement e = i.next();
seen.insert( e.fieldName() );
b.append( e );
}
}
// now do the rest
for ( unsigned j=0; j<rows.size(); j++ ) {
BSONObjIterator i( rows[j].data );
while ( i.more() ) {
BSONElement e = i.next();
if ( seen.count( e.fieldName() ) )
continue;
seen.insert( e.fieldName() );
b.append( e );
}
}
biggest = b.obj();
}
// display data
cout << endl;
// header
if ( row++ % 5 == 0 && ! biggest.isEmpty() ) {
cout << setw( longestHost ) << "" << "\t";
printHeaders( biggest );
}
// rows
for ( unsigned i=0; i<rows.size(); i++ ) {
cout << setw( longestHost ) << rows[i].host << "\t";
if ( rows[i].err.size() )
cout << rows[i].err << endl;
else if ( rows[i].data.isEmpty() )
cout << "no data" << endl;
else
printData( rows[i].data , biggest );
}
}
return 0;
}
int Tool::main( int argc , char ** argv ) {
static StaticObserver staticObserver;
cmdLine.prealloc = false;
// The default value may vary depending on compile options, but for tools
// we want durability to be disabled.
cmdLine.dur = false;
#if( BOOST_VERSION >= 104500 )
boost::filesystem::path::default_name_check( boost::filesystem2::no_check );
#else
boost::filesystem::path::default_name_check( boost::filesystem::no_check );
#endif
_name = argv[0];
/* using the same style as db.cpp */
int command_line_style = (((po::command_line_style::unix_style ^
po::command_line_style::allow_guessing) |
po::command_line_style::allow_long_disguise) ^
po::command_line_style::allow_sticky);
try {
po::options_description all_options("all options");
all_options.add(*_options).add(*_hidden_options);
po::store( po::command_line_parser( argc , argv ).
options(all_options).
positional( _positonalOptions ).
style(command_line_style).run() , _params );
po::notify( _params );
}
catch (po::error &e) {
cerr << "ERROR: " << e.what() << endl << endl;
printHelp(cerr);
::_exit(EXIT_BADOPTIONS);
}
// hide password from ps output
for (int i=0; i < (argc-1); ++i) {
if (!strcmp(argv[i], "-p") || !strcmp(argv[i], "--password")) {
char* arg = argv[i+1];
while (*arg) {
*arg++ = 'x';
}
}
}
if ( _params.count( "help" ) ) {
printHelp(cout);
::_exit(0);
}
if ( _params.count( "version" ) ) {
printVersion(cout);
::_exit(0);
}
if ( _params.count( "verbose" ) ) {
logLevel = 1;
}
for (string s = "vv"; s.length() <= 10; s.append("v")) {
if (_params.count(s)) {
logLevel = s.length();
}
}
#ifdef MONGO_SSL
if (_params.count("ssl")) {
mongo::cmdLine.sslOnNormalPorts = true;
}
#endif
preSetup();
bool useDirectClient = hasParam( "dbpath" );
if ( ! useDirectClient ) {
_host = "127.0.0.1";
if ( _params.count( "host" ) )
_host = _params["host"].as<string>();
if ( _params.count( "port" ) )
_host += ':' + _params["port"].as<string>();
if ( _noconnection ) {
// do nothing
}
else {
string errmsg;
ConnectionString cs = ConnectionString::parse( _host , errmsg );
if ( ! cs.isValid() ) {
cerr << "invalid hostname [" << _host << "] " << errmsg << endl;
::_exit(-1);
}
_conn = cs.connect( errmsg );
if ( ! _conn ) {
cerr << "couldn't connect to [" << _host << "] " << errmsg << endl;
::_exit(-1);
}
(_usesstdout ? cout : cerr ) << "connected to: " << _host << endl;
}
}
else {
if ( _params.count( "directoryperdb" ) ) {
directoryperdb = true;
}
verify( lastError.get( true ) );
if (_params.count("journal")){
cmdLine.dur = true;
}
Client::initThread("tools");
_conn = new DBDirectClient();
_host = "DIRECT";
static string myDbpath = getParam( "dbpath" );
dbpath = myDbpath.c_str();
try {
acquirePathLock();
}
catch ( DBException& ) {
cerr << endl << "If you are running a mongod on the same "
"path you should connect to that instead of direct data "
"file access" << endl << endl;
dbexit( EXIT_CLEAN );
::_exit(-1);
}
FileAllocator::get()->start();
dur::startup();
}
if ( _params.count( "db" ) )
_db = _params["db"].as<string>();
if ( _params.count( "collection" ) )
_coll = _params["collection"].as<string>();
if ( _params.count( "username" ) )
_username = _params["username"].as<string>();
if ( _params.count( "password" )
&& ( _password.empty() ) ) {
_password = askPassword();
}
if (_params.count("ipv6"))
enableIPv6();
int ret = -1;
try {
ret = run();
}
catch ( DBException& e ) {
cerr << "assertion: " << e.toString() << endl;
ret = -1;
}
catch(const boost::filesystem::filesystem_error &fse) {
/*
https://jira.mongodb.org/browse/SERVER-2904
Simple tools that don't access the database, such as
bsondump, aren't throwing DBExceptions, but are throwing
boost exceptions.
The currently available set of error codes don't seem to match
boost documentation. boost::filesystem::not_found_error
(from http://www.boost.org/doc/libs/1_31_0/libs/filesystem/doc/exception.htm)
doesn't seem to exist in our headers. Also, fse.code() isn't
boost::system::errc::no_such_file_or_directory when this
happens, as you would expect. And, determined from
experimentation that the command-line argument gets turned into
"\\?" instead of "/?" !!!
*/
#if defined(_WIN32)
if (/*(fse.code() == boost::system::errc::no_such_file_or_directory) &&*/
(fse.path1() == "\\?"))
printHelp(cerr);
else
#endif // _WIN32
cerr << "error: " << fse.what() << endl;
ret = -1;
}
if ( currentClient.get() )
currentClient.get()->shutdown();
if ( useDirectClient )
dbexit( EXIT_CLEAN );
::_exit(ret);
}
int Tool::main( int argc , char ** argv ){
static StaticObserver staticObserver;
cmdLine.prealloc = false;
boost::filesystem::path::default_name_check( boost::filesystem::no_check );
_name = argv[0];
/* using the same style as db.cpp */
int command_line_style = (((po::command_line_style::unix_style ^
po::command_line_style::allow_guessing) |
po::command_line_style::allow_long_disguise) ^
po::command_line_style::allow_sticky);
try {
po::options_description all_options("all options");
all_options.add(*_options).add(*_hidden_options);
po::store( po::command_line_parser( argc , argv ).
options(all_options).
positional( _positonalOptions ).
style(command_line_style).run() , _params );
po::notify( _params );
} catch (po::error &e) {
cerr << "ERROR: " << e.what() << endl << endl;
printHelp(cerr);
return EXIT_BADOPTIONS;
}
// hide password from ps output
for (int i=0; i < (argc-1); ++i){
if (!strcmp(argv[i], "-p") || !strcmp(argv[i], "--password")){
char* arg = argv[i+1];
while (*arg){
*arg++ = 'x';
}
}
}
if ( _params.count( "help" ) ){
printHelp(cout);
return 0;
}
if ( _params.count( "verbose" ) ) {
logLevel = 1;
}
for (string s = "vv"; s.length() <= 10; s.append("v")) {
if (_params.count(s)) {
logLevel = s.length();
}
}
preSetup();
bool useDirectClient = hasParam( "dbpath" );
if ( ! useDirectClient ) {
_host = "127.0.0.1";
if ( _params.count( "host" ) )
_host = _params["host"].as<string>();
if ( _params.count( "port" ) )
_host += ':' + _params["port"].as<string>();
if ( _noconnection ){
// do nothing
}
else if ( _host.find( "," ) == string::npos ){
DBClientConnection * c = new DBClientConnection( _autoreconnect );
_conn = c;
string errmsg;
if ( ! c->connect( _host , errmsg ) ){
cerr << "couldn't connect to [" << _host << "] " << errmsg << endl;
return -1;
}
}
else {
log(1) << "using pairing" << endl;
DBClientPaired * c = new DBClientPaired();
_paired = true;
_conn = c;
if ( ! c->connect( _host ) ){
cerr << "couldn't connect to paired server: " << _host << endl;
return -1;
}
}
(_usesstdout ? cout : cerr ) << "connected to: " << _host << endl;
}
else {
if ( _params.count( "directoryperdb" ) ) {
directoryperdb = true;
}
assert( lastError.get( true ) );
Client::initThread("tools");
_conn = new DBDirectClient();
_host = "DIRECT";
static string myDbpath = getParam( "dbpath" );
dbpath = myDbpath.c_str();
try {
acquirePathLock();
}
catch ( DBException& e ){
cerr << endl << "If you are running a mongod on the same "
"path you should connect to that instead of direct data "
"file access" << endl << endl;
dbexit( EXIT_CLEAN );
return -1;
}
theFileAllocator().start();
}
if ( _params.count( "db" ) )
_db = _params["db"].as<string>();
if ( _params.count( "collection" ) )
_coll = _params["collection"].as<string>();
if ( _params.count( "username" ) )
_username = _params["username"].as<string>();
if ( _params.count( "password" )
&& ( _password.empty() ) ) {
_password = askPassword();
}
if (_params.count("ipv6"))
enableIPv6();
int ret = -1;
try {
ret = run();
}
catch ( DBException& e ){
cerr << "assertion: " << e.toString() << endl;
ret = -1;
}
if ( currentClient.get() )
currentClient->shutdown();
if ( useDirectClient )
dbexit( EXIT_CLEAN );
return ret;
}
bool useLocks() {
return hasParam( "locks" );
}
EmptyAnimationPtr Object::loadAnimation(const ParameterMap& parameters) {
double scale_factor=1;
BasePointType bp_type=BP_MD;
Uint16 animation_type=ATYPE_LOOP;
double fps=0;
AllignType allign_type=AT_MD;
if (hasParam(parameters,"scale")) {
if (parameters.find("scale")->second == "lvl") scale_factor=config.lvlscale;
else scale_factor=atof(parameters.find("scale")->second.c_str());
}
if (hasParam(parameters,"bp_type")) {
if (parameters.find("bp_type")->second.find("hleft") !=string::npos) {
if (parameters.find("bp_type")->second.find("vup") !=string::npos) bp_type=BP_LU;
else if (parameters.find("bp_type")->second.find("vmiddle") !=string::npos) bp_type=BP_LM;
else if (parameters.find("bp_type")->second.find("vdown") !=string::npos) bp_type=BP_LD;
} else if (parameters.find("bp_type")->second.find("hmiddle") !=string::npos) {
if (parameters.find("bp_type")->second.find("vup") !=string::npos) bp_type=BP_MU;
else if (parameters.find("bp_type")->second.find("vmiddle") !=string::npos) bp_type=BP_MM;
else if (parameters.find("bp_type")->second.find("vdown") !=string::npos) bp_type=BP_MD;
} else if (parameters.find("bp_type")->second.find("hright") !=string::npos) {
if (parameters.find("bp_type")->second.find("vup") !=string::npos) bp_type=BP_RU;
else if (parameters.find("bp_type")->second.find("vmiddle") !=string::npos) bp_type=BP_RM;
else if (parameters.find("bp_type")->second.find("vdown") !=string::npos) bp_type=BP_RD;
}
}
if (hasParam(parameters,"type")) {
animation_type=NOTHING;
if (parameters.find("type")->second.find("once") !=string::npos) animation_type|=ATYPE_ONCE;
if (parameters.find("type")->second.find("loop") !=string::npos) animation_type|=ATYPE_LOOP;
if (parameters.find("type")->second.find("swing") !=string::npos) animation_type|=ATYPE_SWING;
if (parameters.find("type")->second.find("step") !=string::npos) animation_type|=ATYPE_STEP;
if (parameters.find("type")->second.find("reverse") !=string::npos) animation_type<<=1;
if (animation_type==NOTHING) animation_type=ATYPE_LOOP;
if (parameters.find("type")->second.find("switch") !=string::npos) animation_type|=ATYPE_ST_SWITCH;
}
if (hasParam(parameters,"fps")) fps=atof(parameters.find("fps")->second.c_str());
if (hasParam(parameters,"allign_type")) {
if (parameters.find("allign_type")->second.find("hleft") !=string::npos) {
if (parameters.find("allign_type")->second.find("vup") !=string::npos) allign_type=AT_LU;
else if (parameters.find("allign_type")->second.find("vmiddle") !=string::npos) allign_type=AT_LM;
else if (parameters.find("allign_type")->second.find("vdown") !=string::npos) allign_type=AT_LD;
} else if (parameters.find("allign_type")->second.find("hmiddle") !=string::npos) {
if (parameters.find("allign_type")->second.find("vup") !=string::npos) allign_type=AT_MU;
else if (parameters.find("allign_type")->second.find("vmiddle") !=string::npos) allign_type=AT_MM;
else if (parameters.find("allign_type")->second.find("vdown") !=string::npos) allign_type=AT_MD;
} else if (parameters.find("allign_type")->second.find("hright") !=string::npos) {
if (parameters.find("allign_type")->second.find("vup") !=string::npos) allign_type=AT_RU;
else if (parameters.find("allign_type")->second.find("vmiddle") !=string::npos) allign_type=AT_RM;
else if (parameters.find("allign_type")->second.find("vdown") !=string::npos) allign_type=AT_RD;
}
}
/* Use animation name */
if (hasParam(parameters,"name")) {
string anim_name=parameters.find("name")->second;
return loadAnimation(anim_name,scale_factor,bp_type,animation_type,fps,allign_type);
/* Use a base image */
} else if (hasParam(parameters,"image")) {
string image_name=parameters.find("image")->second;
Uint16 frames=1;
Uint16 start_pos=0;
if (hasParam(parameters,"frames")) frames=atoi(parameters.find("frames")->second.c_str());
if (hasParam(parameters,"start_pos")) start_pos=atoi(parameters.find("start_pos")->second.c_str());
/* threat as horizontal animation (constant width, height) with <image_hor_frames> frames */
if (hasParam(parameters,"image_hor_frames")) {
Uint16 image_hor_frames=atoi(parameters.find("image_hor_frames")->second.c_str());
return loadAnimation(scenario->imgcache->loadImage(image_hor_frames,image_name,scale_factor),frames,bp_type,animation_type,fps,start_pos,allign_type);
/* threat as horizontal animation (constant width, height) with width <image_hor_width> and an optional shift */
} else if (hasParam(parameters,"image_hor_width")) {
Uint16 image_hor_width=atoi(parameters.find("image_hor_width")->second.c_str());
Uint16 image_hor_shift=0;
if (hasParam(parameters,"image_hor_shift")) image_hor_shift=atoi(parameters.find("image_hor_shift")->second.c_str());
return loadAnimation(scenario->imgcache->loadImage(image_hor_width,image_hor_shift,image_name,scale_factor),frames,bp_type,animation_type,fps,start_pos,allign_type);
/* threat as constant width/height animation based on a base rectangle */
} else if (hasParam(parameters,"image_rect")) {
ParameterMap rect_param=getParameters(parameters.find("image_rect")->second,';');
SDL_Rect rect;
rect.x=rect.y=0;
rect.w=rect.h=10;
if (hasParam(rect_param,"x")) rect.x=atoi(rect_param.find("x")->second.c_str());
if (hasParam(rect_param,"y")) rect.y=atoi(rect_param.find("y")->second.c_str());
if (hasParam(rect_param,"w")) rect.w=atoi(rect_param.find("w")->second.c_str());
if (hasParam(rect_param,"h")) rect.h=atoi(rect_param.find("h")->second.c_str());
return loadAnimation(scenario->imgcache->loadImage(rect,image_name,scale_factor),frames,bp_type,animation_type,fps,start_pos,allign_type);
/* get informations from an image description file */
} else {
string image_desc=image_name+".dsc";
if (hasParam(parameters,"image_desc")) image_desc=parameters.find("image_desc")->second;
return loadAnimation(scenario->imgcache->loadImage(image_name,scale_factor,image_desc),frames,bp_type,animation_type,fps,start_pos,allign_type);
}
/* no suitable animation found */
} else {
cout << "Invalid animation parameters!" << endl;
return EmptyAnimationPtr(new EmptyAnimation());
}
}
bool OsirisLink::isValid() const
{
bool valid = true;
if(getParam("type") == OS_OSIRISLINK_TYPE_PORTAL)
{
if(hasParam("portal") == false)
return false;
PortalID portal = static_cast<String>(getParam("portal")).to_ascii();
if(portal.validate(false) == false)
return false;
#ifdef OS_OSIRIS_VERSION_RAZOR
if(hasParam("pov") == false)
return false;
PovID pov = static_cast<String>(getParam("pov")).to_ascii();
if(pov.empty())
return false;
#endif
}
else if(getParam("type") == OS_OSIRISLINK_TYPE_ISIS)
{
if(hasParam("portal") == false)
return false;
PortalID portal = static_cast<String>(getParam("portal")).to_ascii();
if(portal.validate(false) == false)
return false;
#ifdef OS_OSIRIS_VERSION_RAZOR
if(hasParam("pov") == false)
return false;
PovID pov = static_cast<String>(getParam("pov")).to_ascii();
if(pov.empty())
return false;
#endif
if(hasParam("name") == false)
return false;
if(hasParam("url") == false)
return false;
// TODO: check if is a url.
}
else if(getParam("type") == OS_OSIRISLINK_TYPE_FILE)
{
if(hasParam("id") == false)
return false;
EntityID id = static_cast<String>(getParam("id")).to_ascii();
if(id.empty())
return false;
if(hasParam("portal"))
{
PortalID portal = static_cast<String>(getParam("portal")).to_ascii();
if(portal.validate(false) == false)
return false;
}
#ifdef OS_OSIRIS_VERSION_RAZOR
if(hasParam("pov"))
{
PovID pov = static_cast<String>(getParam("pov")).to_ascii();
if(pov.empty())
return false;
}
#endif
}
else if(getParam("type") == OS_OSIRISLINK_TYPE_URL)
{
if(hasParam("url") == false)
return false;
// TODO: check if is a url
}
else if(getParam("type") == OS_OSIRISLINK_TYPE_RES)
{
if(hasParam("path") == false)
return false;
// We don't check if is a path.
}
else
return false;
return true;
}
std::string OsirisLink::generate() const
{
#ifdef OS_OSIRIS_VERSION_RAZOR
bool newFormat = true;
#else
bool newFormat = false;
#endif
if(isValid() == false)
return "";
if(hasParam("type") == false)
return "";
if(newFormat)
{
std::string out = "";
for(OsirisLinkParams::const_iterator i = m_params.begin(); i != m_params.end(); ++i)
{
std::string key = i->first;
std::wstring value = i->second;
if(key != "type") // Type forced below, simply to ensure it's the first.
{
if(value != _W(""))
{
out += "&" + key + "=" + HttpParser::urlEncodeW(value);
}
}
}
return "osiris:?type=" + HttpParser::urlEncodeW(getParam("type")) + out;
}
else
{
if(getParam("type") == OS_OSIRISLINK_TYPE_PORTAL)
{
if(hasParam("portal") == false)
return "";
std::string out = "osiris://|portal|" + HttpParser::urlEncodeW(getParam("portal")) + "|";
if(hasParam("name"))
out += "name=" + HttpParser::urlEncodeW(getParam("name")) + "|";
if(hasParam("description"))
out += "description=" + HttpParser::urlEncodeW(getParam("description")) + "|";
if(hasParam("user"))
out += "user="******"010000002") + getParam("pov")) + "|";
return out;
}
else if(getParam("type") == OS_OSIRISLINK_TYPE_ISIS)
{
if(hasParam("portal") == false)
return "";
std::string out = "osiris://|isis|" + HttpParser::urlEncodeW(getParam("portal")) + "|";
if(hasParam("name"))
out += "name=" + HttpParser::urlEncodeW(getParam("name")) + "|";
if(hasParam("url"))
out += "url=" + HttpParser::urlEncodeW(getParam("url")) + "|";
return out;
}
else if(getParam("type") == OS_OSIRISLINK_TYPE_FILE)
{
std::string out = "osiris://|file|" + HttpParser::urlEncodeW(getParam("id")) + "|";
return out;
}
else if(getParam("type") == OS_OSIRISLINK_TYPE_URL)
{
std::wstring url = getParam("url");
StringVector array1;
utils::split(url, _S("?"), array1);
std::wstring params = _W("");
if(array1.size()>=2)
{
url = array1[0].to_wide();
params = array1[1].to_wide();
}
if(hasParam("portal"))
{
if(params.empty() == false)
params += _W("&");
params += _W("portal=") + getParam("portal");
}
/*
std::string out = "osiris://|url|" + HttpParser::urlEncodeW(url) + "|";
if(params != _W(""))
out += HttpParser::urlEncodeW(params) + "|";
*/
std::string out = "osiris://|url|" + utils::wtoa(url) + "|";
if(params != _W(""))
out += utils::wtoa(params) + "|";
return out;
}
else if(getParam("type") == OS_OSIRISLINK_TYPE_RES)
{
std::string out = "osiris://|skin|" + HttpParser::urlEncodeW(getParam("path")) + "|";
return out;
}
else
{
return "";
}
}
}
Status storeGeneralToolOptions(const moe::Environment& params,
const std::vector<std::string>& args) {
toolGlobalParams.name = args[0];
storageGlobalParams.prealloc = false;
// The default value may vary depending on compile options, but for tools
// we want durability to be disabled.
storageGlobalParams.dur = false;
// Set authentication parameters
if (params.count("authenticationDatabase")) {
toolGlobalParams.authenticationDatabase =
params["authenticationDatabase"].as<string>();
}
if (params.count("authenticationMechanism")) {
toolGlobalParams.authenticationMechanism =
params["authenticationMechanism"].as<string>();
}
if (params.count("verbose")) {
logger::globalLogDomain()->setMinimumLoggedSeverity(logger::LogSeverity::Debug(1));
}
for (string s = "vv"; s.length() <= 12; s.append("v")) {
if (params.count(s)) {
logger::globalLogDomain()->setMinimumLoggedSeverity(
logger::LogSeverity::Debug(s.length()));
}
}
toolGlobalParams.quiet = params.count("quiet");
#ifdef MONGO_SSL
Status ret = storeSSLClientOptions(params);
if (!ret.isOK()) {
return ret;
}
#endif
if (args.empty()) {
return Status(ErrorCodes::InternalError, "Cannot get binary name: argv array is empty");
}
// setup binary name
toolGlobalParams.name = args[0];
size_t i = toolGlobalParams.name.rfind('/');
if (i != string::npos) {
toolGlobalParams.name = toolGlobalParams.name.substr(i + 1);
}
toolGlobalParams.db = "test";
toolGlobalParams.coll = "";
toolGlobalParams.noconnection = false;
if (params.count("db"))
toolGlobalParams.db = params["db"].as<string>();
if (params.count("collection"))
toolGlobalParams.coll = params["collection"].as<string>();
if (params.count("username"))
toolGlobalParams.username = params["username"].as<string>();
if (params.count("password")) {
toolGlobalParams.password = params["password"].as<string>();
if (toolGlobalParams.password.empty()) {
toolGlobalParams.password = askPassword();
}
}
if (params.count("ipv6")) {
enableIPv6();
}
toolGlobalParams.dbpath = getParam("dbpath");
toolGlobalParams.useDirectClient = hasParam("dbpath");
if (toolGlobalParams.useDirectClient && params.count("journal")) {
storageGlobalParams.dur = true;
}
if (!toolGlobalParams.useDirectClient) {
toolGlobalParams.connectionString = "127.0.0.1";
if (params.count("host")) {
toolGlobalParams.hostSet = true;
toolGlobalParams.host = params["host"].as<string>();
toolGlobalParams.connectionString = params["host"].as<string>();
}
if (params.count("port")) {
toolGlobalParams.portSet = true;
toolGlobalParams.port = params["port"].as<string>();
toolGlobalParams.connectionString += ':' + params["port"].as<string>();
}
}
else {
if (params.count("directoryperdb")) {
storageGlobalParams.directoryperdb = true;
}
toolGlobalParams.connectionString = "DIRECT";
}
return Status::OK();
}