bool FreezeScript::parseSlice(const string& n, const Slice::UnitPtr& u, const vector<string>& files, const vector<string>& cppArgs, bool debug, const std::string& extraArgs) { // // Parse the Slice files. // for(vector<string>::const_iterator p = files.begin(); p != files.end(); ++p) { PreprocessorPtr icecpp = Preprocessor::create(n, *p, cppArgs); FILE* cppHandle = icecpp->preprocess(false, extraArgs); if(cppHandle == 0) { return false; } int status = u->parse(*p, cppHandle, debug); if(!icecpp->close()) { return false; } if(status != EXIT_SUCCESS) { return false; } } u->mergeModules(); return true; }
static Slice::TypePtr findType(const Slice::UnitPtr& u, const string& type) { Slice::TypeList l; string t; if(type == "::Ice::Object") { t = "Object"; } else if(type == "::Ice::Object*") { t = "Object*"; } else { t = type; } l = u->lookupType(t, false); if(l.empty()) { return 0; } return l.front(); }
static int run(const Ice::StringSeq& originalArgs, const Ice::CommunicatorPtr& communicator, const FreezeScript::CompactIdResolverIPtr& resolver) { vector<string> cppArgs; bool debug; bool ice = true; // Needs to be true in order to create default definitions. bool underscore; string outputFile; string inputFile; vector<string> slice; bool evictor; string keyTypeName; string valueTypeName; string selectExpr; string dbEnvName, dbName; const string appName = originalArgs[0]; IceUtilInternal::Options opts; opts.addOpt("h", "help"); opts.addOpt("v", "version"); opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("d", "debug"); opts.addOpt("", "ice"); opts.addOpt("", "underscore"); opts.addOpt("o", "", IceUtilInternal::Options::NeedArg); opts.addOpt("f", "", IceUtilInternal::Options::NeedArg); opts.addOpt("", "load", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat); opts.addOpt("e"); opts.addOpt("", "key", IceUtilInternal::Options::NeedArg); opts.addOpt("", "value", IceUtilInternal::Options::NeedArg); opts.addOpt("", "select", IceUtilInternal::Options::NeedArg); opts.addOpt("c", "catalog"); vector<string> args; try { args = opts.parse(originalArgs); } catch(const IceUtilInternal::BadOptException& e) { cerr << appName << ": " << e.reason << endl; usage(appName); return EXIT_FAILURE; } // // Freeze creates a lock file by default to prevent multiple processes from opening // the same database environment simultaneously. In the case of a read-only program // such as dumpdb, however, we still want to be able to open the environment despite // the lock. This assumes of course that the other process has opened the environment // with DbPrivate=0. If DbPrivate=0 is also set for dumpdb, we disable the lock. // if(!args.empty()) { // // If an argument is present, we assume it is the name of the database environment. // Ice::PropertiesPtr props = communicator->getProperties(); string prefix = "Freeze.DbEnv." + args[0]; if(props->getPropertyAsIntWithDefault(prefix + ".DbPrivate", 1) <= 0) { props->setProperty(prefix + ".LockFile", "0"); } } if(opts.isSet("h")) { usage(appName); return EXIT_SUCCESS; } if(opts.isSet("version")) { cout << ICE_STRING_VERSION << endl; return EXIT_SUCCESS; } if(opts.isSet("c")) { if(args.empty()) { cerr << appName << ": no database environment specified." << endl; usage(appName); return EXIT_FAILURE; } else if(args.size() > 2) { usage(appName); return EXIT_FAILURE; } try { FreezeScript::CatalogDataMap catalog = FreezeScript::readCatalog(communicator, args[0]); if(args.size() == 1) { if(catalog.empty()) { cout << "Catalog is empty." << endl; } else { cout << "Catalog contents:" << endl; for(FreezeScript::CatalogDataMap::const_iterator p = catalog.begin(); p != catalog.end(); ++p) { cout << endl; printCatalogData(p->first, p->second); } } } else { FreezeScript::CatalogDataMap::const_iterator p = catalog.find(args[1]); if(p == catalog.end()) { cerr << appName << ": database `" << args[1] << "' not found in environment `" << args[0] << "'." << endl; return EXIT_FAILURE; } else { printCatalogData(p->first, p->second); } } return EXIT_SUCCESS; } catch(const FreezeScript::FailureException& ex) { cerr << appName << ": " << ex.reason() << endl; return EXIT_FAILURE; } } if(opts.isSet("D")) { vector<string> optargs = opts.argVec("D"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-D" + *i); } } if(opts.isSet("U")) { vector<string> optargs = opts.argVec("U"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-U" + *i); } } if(opts.isSet("I")) { vector<string> optargs = opts.argVec("I"); for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i) { cppArgs.push_back("-I" + *i); } } debug = opts.isSet("debug"); // No need to set --ice option here -- it is always true. underscore = opts.isSet("underscore"); if(opts.isSet("o")) { outputFile = opts.optArg("o"); } if(opts.isSet("f")) { inputFile = opts.optArg("f"); } if(opts.isSet("load")) { vector<string> optArgs = opts.argVec("load"); for(vector<string>::const_iterator i = optArgs.begin(); i != optArgs.end(); ++i) { slice.push_back(*i); } } evictor = opts.isSet("e"); if(opts.isSet("key")) { keyTypeName = opts.optArg("key"); } if(opts.isSet("value")) { valueTypeName = opts.optArg("value"); } if(opts.isSet("select")) { selectExpr = opts.optArg("select"); } if(outputFile.empty() && args.size() != 2) { usage(appName); return EXIT_FAILURE; } if(!args.empty()) { dbEnvName = args[0]; } if(args.size() == 2) { dbName = args[1]; } else { usage(appName); return EXIT_FAILURE; } if(!inputFile.empty() && !selectExpr.empty()) { cerr << appName << ": an input file cannot be specified with --select" << endl; return EXIT_FAILURE; } Slice::UnitPtr unit = Slice::Unit::createUnit(true, true, ice, underscore); FreezeScript::Destroyer<Slice::UnitPtr> unitD(unit); if(!FreezeScript::parseSlice(appName, unit, slice, cppArgs, debug, "-D__DUMPDB__")) { return EXIT_FAILURE; } FreezeScript::createEvictorSliceTypes(unit); FreezeScript::collectCompactIds(unit, resolver); // // If no input file was provided, then we need to generate default descriptors. // string descriptors; if(inputFile.empty()) { const string evictorKeyTypeName = "::Ice::Identity"; const string oldEvictorValueTypeName = "::Freeze::ObjectRecord"; const string newEvictorValueTypeName = "Object"; if((!keyTypeName.empty() && valueTypeName.empty()) || (keyTypeName.empty() && !valueTypeName.empty() && !evictor)) { cerr << appName << ": a key type and a value type must be specified" << endl; usage(appName); return EXIT_FAILURE; } else if(valueTypeName.empty()) { try { FreezeScript::CatalogDataMap catalog = FreezeScript::readCatalog(communicator, dbEnvName); FreezeScript::CatalogDataMap::iterator p = catalog.find(dbName); if(p == catalog.end()) { cerr << appName << ": database `" << dbName << "' not found in catalog." << endl; cerr << "Current catalog databases:" << endl; for(p = catalog.begin(); p != catalog.end(); ++p) { cerr << " " << p->first << endl; } return EXIT_FAILURE; } else { if(p->second.evictor) { evictor = true; } keyTypeName = p->second.key; valueTypeName = p->second.value; if(evictor && valueTypeName.empty()) { valueTypeName = oldEvictorValueTypeName; } } } catch(const FreezeScript::FailureException& ex) { cerr << appName << ": " << ex.reason() << endl; return EXIT_FAILURE; } } if(evictor) { if(keyTypeName.empty()) { keyTypeName = evictorKeyTypeName; } if(valueTypeName.empty()) { valueTypeName = newEvictorValueTypeName; } } Slice::TypePtr keyType, valueType; Slice::TypeList l; l = unit->lookupType(keyTypeName, false); if(l.empty()) { cerr << appName << ": unknown key type `" << keyTypeName << "'" << endl; return EXIT_FAILURE; } keyType = l.front(); l = unit->lookupType(valueTypeName, false); if(l.empty()) { cerr << appName << ": unknown value type `" << valueTypeName << "'" << endl; return EXIT_FAILURE; } valueType = l.front(); ostringstream os; IceUtilInternal::XMLOutput out(os); out << se("dumpdb"); FreezeScript::SliceVisitor visitor(out, keyType, valueType, selectExpr); unit->visit(&visitor, false); out << ee; descriptors = os.str(); if(!outputFile.empty()) { IceUtilInternal::ofstream of(outputFile); if(!of.good()) { cerr << appName << ": unable to open file `" << outputFile << "'" << endl; return EXIT_FAILURE; } of << descriptors << endl; of.close(); return EXIT_SUCCESS; } } else { IceUtilInternal::ifstream in(inputFile); char buff[1024]; while(true) { in.read(buff, 1024); descriptors.append(buff, static_cast<size_t>(in.gcount())); if(in.gcount() < 1024) { break; } } in.close(); } FreezeScript::ValueFactoryPtr valueFactory = new FreezeScript::ValueFactory; communicator->getValueFactoryManager()->add(valueFactory, ""); DbEnv dbEnv(0); DbTxn* txn = 0; Freeze::ConnectionPtr connection; int status = EXIT_SUCCESS; try { #ifdef _WIN32 // // Berkeley DB may use a different C++ runtime. // dbEnv.set_alloc(::malloc, ::realloc, ::free); #endif // // Open the database environment and start a transaction. // { u_int32_t flags = DB_THREAD | DB_CREATE | DB_INIT_TXN | DB_INIT_MPOOL; dbEnv.open(dbEnvName.c_str(), flags, FREEZE_SCRIPT_DB_MODE); } // // We're creating a connection just to make sure the database environment // isn't locked. // connection = Freeze::createConnection(communicator, dbEnvName, dbEnv); dbEnv.txn_begin(0, &txn, 0); FreezeScript::ErrorReporterPtr errorReporter = new FreezeScript::ErrorReporter(cerr, false); try { FreezeScript::DataFactoryPtr factory = new FreezeScript::DataFactory(communicator, unit, errorReporter); FreezeScript::DescriptorHandler dh(factory, unit, errorReporter, valueFactory); istringstream istr(descriptors); IceXML::Parser::parse(istr, dh); FreezeScript::DumpDBDescriptorPtr descriptor = dh.descriptor(); descriptor->validate(); if(evictor) { // // The evictor database file contains multiple databases. We must first // determine the names of those databases, ignoring any whose names // begin with "$index:". Each database represents a separate facet, with // the facet name used as the database name. The database named "$default" // represents the main object. // vector<string> dbNames; { Db db(&dbEnv, 0); db.open(txn, dbName.c_str(), 0, DB_UNKNOWN, DB_RDONLY, 0); Dbt dbKey, dbValue; dbKey.set_flags(DB_DBT_MALLOC); dbValue.set_flags(DB_DBT_USERMEM | DB_DBT_PARTIAL); Dbc* dbc = 0; db.cursor(txn, &dbc, 0); while(dbc->get(&dbKey, &dbValue, DB_NEXT) == 0) { string s(static_cast<char*>(dbKey.get_data()), dbKey.get_size()); if(s.find("$index:") != 0) { dbNames.push_back(s); } free(dbKey.get_data()); } dbc->close(); db.close(0); } // // Dump each database. // for(vector<string>::iterator p = dbNames.begin(); p != dbNames.end(); ++p) { string name = *p; string facet = (name == "$default" ? string("") : name); Db db(&dbEnv, 0); db.open(txn, dbName.c_str(), name.c_str(), DB_BTREE, DB_RDONLY, FREEZE_SCRIPT_DB_MODE); descriptor->dump(communicator, &db, txn, facet); db.close(0); } } else { // // Dump a map database. // Db db(&dbEnv, 0); db.open(txn, dbName.c_str(), 0, DB_BTREE, DB_RDONLY, FREEZE_SCRIPT_DB_MODE); descriptor->dump(communicator, &db, txn, ""); db.close(0); } } catch(const IceXML::ParserException& ex) { errorReporter->error(ex.reason()); } } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; status = EXIT_FAILURE; } catch(...) { try { if(txn) { txn->abort(); } dbEnv.close(0); } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; } if(connection) { connection->close(); connection = 0; } throw; } try { if(txn) { txn->abort(); } if(connection) { connection->close(); } dbEnv.close(0); } catch(const DbException& ex) { cerr << appName << ": database error: " << ex.what() << endl; status = EXIT_FAILURE; } return status; }
bool FreezeScript::invokeGlobalFunction(const Ice::CommunicatorPtr& communicator, const string& name, const DataList& args, DataPtr& result, const DataFactoryPtr& factory, const ErrorReporterPtr& errorReporter) { // // Global function. // if(name == "typeOf") { if(args.size() != 1) { errorReporter->error("typeOf() requires one argument"); } result = factory->createString(typeToString(args.front()->getType()), false); return true; } else if(name == "generateUUID") { if(args.size() != 0) { errorReporter->error("generateUUID() accepts no arguments"); } result = factory->createString(IceUtil::generateUUID(), false); return true; } else if(name == "stringToIdentity") { StringDataPtr str; if(args.size() > 0) { str = StringDataPtr::dynamicCast(args.front()); } if(args.size() != 1 || !str) { errorReporter->error("stringToIdentity() requires a string argument"); } // // Parse the identity string. // string idstr = str->stringValue(); Ice::Identity id; try { id = communicator->stringToIdentity(idstr); } catch(const Ice::IdentityParseException& ex) { errorReporter->error("error in stringToIdentity():\n" + ex.str); } // // Create a data representation of Ice::Identity. // Slice::UnitPtr unit = str->getType()->unit(); Slice::TypeList l = unit->lookupType("::Ice::Identity", false); assert(!l.empty()); DataPtr identity = factory->create(l.front(), false); StringDataPtr member; member = StringDataPtr::dynamicCast(identity->getMember("name")); assert(member); member->setValue(id.name); member = StringDataPtr::dynamicCast(identity->getMember("category")); assert(member); member->setValue(id.category); result = identity; return true; } else if(name == "identityToString") { StructDataPtr identity; if(args.size() > 0) { identity = StructDataPtr::dynamicCast(args.front()); } if(identity) { Slice::TypePtr argType = identity->getType(); Slice::StructPtr st = Slice::StructPtr::dynamicCast(argType); if(!st || st->scoped() != "::Ice::Identity") { identity = 0; } } if(args.size() != 1 || !identity) { errorReporter->error("identityToString() requires a argument of type ::Ice::Identity"); } // // Compose the identity. // Ice::Identity id; StringDataPtr member; member = StringDataPtr::dynamicCast(identity->getMember("name")); assert(member); id.name = member->stringValue(); member = StringDataPtr::dynamicCast(identity->getMember("category")); assert(member); id.category = member->stringValue(); result = factory->createString(communicator->identityToString(id), false); return true; } else if(name == "stringToProxy") { StringDataPtr str; if(args.size() > 0) { str = StringDataPtr::dynamicCast(args.front()); } if(args.size() != 1 || !str) { errorReporter->error("stringToProxy() requires a string argument"); } // // Parse the proxy; // string sprx = str->stringValue(); Ice::ObjectPrx prx; try { prx = factory->getCommunicator()->stringToProxy(sprx); } catch(const Ice::ProxyParseException& ex) { errorReporter->error("error in stringToProxy():\n" + ex.str); } Slice::UnitPtr unit = str->getType()->unit(); ProxyDataPtr p = ProxyDataPtr::dynamicCast(factory->create(unit->builtin(Slice::Builtin::KindObjectProxy), false)); p->setValue(prx); result = p; return true; } else if(name == "proxyToString") { ProxyDataPtr prx; if(args.size() > 0) { prx = ProxyDataPtr::dynamicCast(args.front()); } if(args.size() != 1 || !prx) { errorReporter->error("proxyToString() requires a proxy argument"); } result = factory->createString(prx->toString(), false); return true; } else if(name == "lowercase") { StringDataPtr str; if(args.size() > 0) { str = StringDataPtr::dynamicCast(args.front()); } if(args.size() != 1 || !str) { errorReporter->error("lowercase() requires a string argument"); } string val = IceUtilInternal::toLower(str->stringValue()); result = factory->createString(val, false); return true; } return false; }
void FreezeScript::createEvictorSliceTypes(const Slice::UnitPtr& u) { Slice::TypeList l; Slice::ContainedList c; // // Create the Ice module if necessary. // c = u->lookupContained("Ice", false); Slice::ModulePtr ice; if(c.empty()) { ice = u->createModule("Ice"); } else { ice = Slice::ModulePtr::dynamicCast(c.front()); if(!ice) { throw FailureException(__FILE__, __LINE__, "the symbol `::Ice' is defined in Slice but is not a module"); } } // // Create the Slice definition for Ice::Identity if it doesn't exist. // string scoped = "::Ice::Identity"; l = u->lookupTypeNoBuiltin(scoped, false); Slice::StructPtr identity; if(l.empty()) { identity = ice->createStruct("Identity", false); Slice::TypePtr str = u->builtin(Slice::Builtin::KindString); identity->createDataMember("name", str, false, 0, 0, "", ""); identity->createDataMember("category", str, false, 0, 0, "", ""); } else { identity = Slice::StructPtr::dynamicCast(l.front()); if(!identity) { throw FailureException(__FILE__, __LINE__, "the symbol `::Ice::Identity' is defined in Slice but is not a struct"); } } // // Create the Freeze module if necessary. // c = u->lookupContained("Freeze", false); Slice::ModulePtr freeze; if(c.empty()) { freeze = u->createModule("Freeze"); } else { freeze = Slice::ModulePtr::dynamicCast(c.front()); if(!freeze) { throw FailureException(__FILE__, __LINE__, "the symbol `::Freeze' is defined in Slice but is not a module"); } } // // Create the Slice definition for Freeze::Statistics if it doesn't exist. // scoped = "::Freeze::Statistics"; l = u->lookupTypeNoBuiltin(scoped, false); Slice::StructPtr stats; if(l.empty()) { stats = freeze->createStruct("Statistics", false); Slice::TypePtr tl = u->builtin(Slice::Builtin::KindLong); stats->createDataMember("creationTime", tl, false, 0, 0, "", ""); stats->createDataMember("lastSaveTime", tl, false, 0, 0, "", ""); stats->createDataMember("avgSaveTime", tl, false, 0, 0, "", ""); } else { stats = Slice::StructPtr::dynamicCast(l.front()); if(!stats) { throw FailureException(__FILE__, __LINE__, "the symbol `::Freeze::Statistics' is defined in " "Slice but is not a struct"); } } // // Create the Slice definition for Freeze::ObjectRecord if it doesn't exist. // scoped = "::Freeze::ObjectRecord"; l = u->lookupTypeNoBuiltin(scoped, false); if(l.empty()) { Slice::StructPtr rec = freeze->createStruct("ObjectRecord", false); Slice::TypePtr obj = u->builtin(Slice::Builtin::KindObject); rec->createDataMember("servant", obj, false, 0, 0, "", ""); rec->createDataMember("stats", stats, false, 0, 0, "", ""); } else { if(!Slice::StructPtr::dynamicCast(l.front())) { throw FailureException(__FILE__, __LINE__, "the symbol `::Freeze::ObjectRecord' is defined in " "Slice but is not a struct"); } } }