int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "array");
opts.addOpt("", "async");
vector<string> args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cout << argv[0] << ": " << e.reason << endl;
return false;
}
bool array = opts.isSet("array");
bool async = opts.isSet("async");
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorI, array, async), "");
adapter->activate();
TEST_READY
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
static int
run(const Ice::StringSeq& originalArgs, const Ice::CommunicatorPtr& communicator)
{
vector<string> oldCppArgs;
vector<string> newCppArgs;
bool debug;
bool ice = true; // Needs to be true in order to create default definitions.
bool underscore;
string outputFile;
bool ignoreTypeChanges;
bool purgeObjects;
bool catastrophicRecover;
bool suppress;
string inputFile;
vector<string> oldSlice;
vector<string> newSlice;
bool evictor;
string keyTypeNames;
string valueTypeNames;
string dbEnvName, dbName, dbEnvNameNew;
bool allDb = false;
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("d", "debug");
opts.addOpt("", "underscore");
opts.addOpt("o", "", IceUtilInternal::Options::NeedArg);
opts.addOpt("i");
opts.addOpt("p");
opts.addOpt("c");
opts.addOpt("w");
opts.addOpt("f", "", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "include-old", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("", "include-new", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("", "old", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("", "new", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("a");
opts.addOpt("e");
opts.addOpt("", "key", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "value", IceUtilInternal::Options::NeedArg);
const string appName = originalArgs[0];
vector<string> args;
try
{
args = opts.parse(originalArgs);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << appName << ": " << e.reason << endl;
usage(appName);
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(appName);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
if(opts.isSet("D"))
{
vector<string> optargs = opts.argVec("D");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
oldCppArgs.push_back("-D" + *i);
newCppArgs.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)
{
oldCppArgs.push_back("-U" + *i);
newCppArgs.push_back("-U" + *i);
}
}
debug = opts.isSet("debug");
underscore = opts.isSet("underscore");
if(opts.isSet("o"))
{
outputFile = opts.optArg("o");
}
ignoreTypeChanges = opts.isSet("i");
purgeObjects = opts.isSet("p");
catastrophicRecover = opts.isSet("c");
suppress = opts.isSet("w");
if(opts.isSet("f"))
{
inputFile = opts.optArg("f");
}
if(opts.isSet("include-old"))
{
vector<string> optargs = opts.argVec("include-old");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
oldCppArgs.push_back("-I" + *i);
}
}
if(opts.isSet("include-new"))
{
vector<string> optargs = opts.argVec("include-new");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
newCppArgs.push_back("-I" + *i);
}
}
if(opts.isSet("old"))
{
vector<string> optargs = opts.argVec("old");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
oldSlice.push_back(*i);
}
}
if(opts.isSet("new"))
{
vector<string> optargs = opts.argVec("new");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
newSlice.push_back(*i);
}
}
evictor = opts.isSet("e");
if(opts.isSet("key"))
{
keyTypeNames = opts.optArg("key");
}
if(opts.isSet("value"))
{
valueTypeNames = opts.optArg("value");
}
if(outputFile.empty())
{
if(args.size() == 2)
{
allDb = true;
}
else if(args.size() != 3)
{
usage(appName);
return EXIT_FAILURE;
}
}
else
{
if(args.size() == 1)
{
allDb = true;
}
else if(args.size() != 0)
{
usage(appName);
return EXIT_FAILURE;
}
}
if(allDb && (!keyTypeNames.empty() || !valueTypeNames.empty()))
{
usage(appName);
return EXIT_FAILURE;
}
if(inputFile.empty() && !allDb && !evictor && (keyTypeNames.empty() || valueTypeNames.empty()))
{
usage(appName);
return EXIT_FAILURE;
}
if(args.size() > 0)
{
dbEnvName = args[0];
}
if(args.size() > 1)
{
if(allDb)
{
dbEnvNameNew = args[1];
}
else
{
dbName = args[1];
}
}
if(args.size() > 2)
{
dbEnvNameNew = args[2];
}
if(args.size() > 3)
{
cerr << appName << ": too many arguments" << 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 transformdb, 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(!catastrophicRecover && outputFile.empty())
{
Ice::PropertiesPtr props = communicator->getProperties();
string prefix = "Freeze.DbEnv." + args[0];
if(props->getPropertyAsIntWithDefault(prefix + ".DbPrivate", 1) == 0)
{
props->setProperty(prefix + ".LockFile", "0");
}
}
Slice::UnitPtr oldUnit = Slice::Unit::createUnit(true, true, ice, underscore);
FreezeScript::Destroyer<Slice::UnitPtr> oldD(oldUnit);
if(!FreezeScript::parseSlice(appName, oldUnit, oldSlice, oldCppArgs, debug,
"-D__TRANSFORMDB__"))
{
return EXIT_FAILURE;
}
Slice::UnitPtr newUnit = Slice::Unit::createUnit(true, true, ice, underscore);
FreezeScript::Destroyer<Slice::UnitPtr> newD(newUnit);
if(!FreezeScript::parseSlice(appName, newUnit, newSlice, newCppArgs, debug,
"-D__TRANSFORMDB__"))
{
return EXIT_FAILURE;
}
//
// Install the evictor types in the Slice units.
//
FreezeScript::createEvictorSliceTypes(oldUnit);
FreezeScript::createEvictorSliceTypes(newUnit);
//
// Read the catalog if necessary.
//
FreezeScript::CatalogDataMap catalog;
if(allDb)
{
try
{
catalog = FreezeScript::readCatalog(communicator, dbEnvName);
}
catch(const FreezeScript::FailureException& ex)
{
cerr << appName << ": " << ex.reason() << endl;
return EXIT_FAILURE;
}
if(catalog.empty())
{
cerr << appName << ": no databases in environment `" << dbEnvName << "'" << endl;
return EXIT_FAILURE;
}
}
//
// If no input file was provided, then we need to analyze the Slice types.
//
string descriptors;
if(inputFile.empty())
{
ostringstream out;
vector<string> missingTypes;
vector<string> analyzeErrors;
FreezeScript::TransformAnalyzer analyzer(oldUnit, newUnit, ignoreTypeChanges, out, missingTypes, analyzeErrors);
const string evictorKeyName = "::Ice::Identity";
const string oldEvictorValueName = "::Freeze::ObjectRecord";
const string newEvictorValueName = "Object";
if(allDb)
{
//
// Add a <database> element for each database in the catalog.
//
for(FreezeScript::CatalogDataMap::iterator p = catalog.begin(); p != catalog.end(); ++p)
{
string keyName, valueName;
if(p->second.evictor)
{
keyName = p->second.key;
valueName = p->second.value;
if(keyName.empty())
{
keyName = evictorKeyName;
}
if(valueName.empty())
{
valueName = oldEvictorValueName;
}
}
else
{
keyName = p->second.key;
valueName = p->second.value;
}
//
// Look up the key and value types in the old and new Slice definitions.
//
Slice::TypePtr oldKeyType = findType(oldUnit, keyName);
if(!oldKeyType)
{
cerr << appName << ": type `" << keyName << "' from database `" << p->first
<< "' not found in old Slice definitions" << endl;
}
Slice::TypePtr newKeyType = findType(newUnit, keyName);
if(!newKeyType)
{
cerr << appName << ": type `" << keyName << "' from database `" << p->first
<< "' not found in new Slice definitions" << endl;
}
Slice::TypePtr oldValueType = findType(oldUnit, valueName);
if(!oldValueType)
{
cerr << appName << ": type `" << valueName << "' from database `" << p->first
<< "' not found in old Slice definitions" << endl;
}
Slice::TypePtr newValueType;
if(p->second.evictor)
{
//
// The new evictor does not keep stats
//
newValueType = findType(newUnit, newEvictorValueName);
}
else
{
newValueType = findType(newUnit, valueName);
}
if(!newValueType)
{
cerr << appName << ": type `" << valueName << "' from database `" << p->first
<< "' not found in new Slice definitions" << endl;
}
//
// If we are generating an output file, we do not consider a missing type to be
// an error. Since the type information comes from the catalog of the old
// environment, it's possible that the key or value types are not present in
// the new Slice definitions. Rather than abort at this point, we simply emit
// a partially-defined <database> element that must be edited by the user.
//
// If we are not generating an output file, we have to stop now.
//
if(outputFile.empty() && (!oldKeyType || !newKeyType || !oldValueType || !newValueType))
{
return EXIT_FAILURE;
}
analyzer.addDatabase(p->first, oldKeyType, newKeyType, oldValueType, newValueType);
}
}
else
{
string oldKeyName, newKeyName, oldValueName, newValueName;
string::size_type pos;
if(!evictor && (keyTypeNames.empty() || valueTypeNames.empty()))
{
usage(appName);
return EXIT_FAILURE;
}
if(!keyTypeNames.empty())
{
pos = keyTypeNames.find(',');
if(pos == 0 || pos == keyTypeNames.size())
{
usage(appName);
return EXIT_FAILURE;
}
if(pos == string::npos)
{
oldKeyName = keyTypeNames;
newKeyName = keyTypeNames;
}
else
{
oldKeyName = keyTypeNames.substr(0, pos);
newKeyName = keyTypeNames.substr(pos + 1);
}
}
if(!valueTypeNames.empty())
{
pos = valueTypeNames.find(',');
if(pos == 0 || pos == valueTypeNames.size())
{
usage(appName);
return EXIT_FAILURE;
}
if(pos == string::npos)
{
oldValueName = valueTypeNames;
newValueName = valueTypeNames;
}
else
{
oldValueName = valueTypeNames.substr(0, pos);
newValueName = valueTypeNames.substr(pos + 1);
}
}
if(evictor)
{
if(oldKeyName.empty())
{
oldKeyName = evictorKeyName;
}
if(newKeyName.empty())
{
newKeyName = evictorKeyName;
}
if(oldValueName.empty())
{
oldValueName = newEvictorValueName;
}
if(newValueName.empty())
{
newValueName = newEvictorValueName;
}
}
//
// Look up the key and value types in the old and new Slice definitions.
//
Slice::TypePtr oldKeyType = findType(oldUnit, oldKeyName);
if(!oldKeyType)
{
cerr << appName << ": type `" << oldKeyName << "' not found in old Slice definitions" << endl;
}
Slice::TypePtr newKeyType = findType(newUnit, newKeyName);
if(!newKeyType)
{
cerr << appName << ": type `" << newKeyName << "' not found in new Slice definitions" << endl;
}
Slice::TypePtr oldValueType = findType(oldUnit, oldValueName);
if(!oldValueType)
{
cerr << appName << ": type `" << oldValueName << "' not found in old Slice definitions" << endl;
}
Slice::TypePtr newValueType = findType(newUnit, newValueName);
if(!newValueType)
{
cerr << appName << ": type `" << newValueName << "' not found in new Slice definitions" << endl;
}
//
// Stop now if any of the types could not be found.
//
if(!oldKeyType || !newKeyType || !oldValueType || !newValueType)
{
return EXIT_FAILURE;
}
analyzer.addDatabase("", oldKeyType, newKeyType, oldValueType, newValueType);
}
analyzer.finish();
if(!analyzeErrors.empty())
{
for(vector<string>::const_iterator p = analyzeErrors.begin(); p != analyzeErrors.end(); ++p)
{
cerr << appName << ": " << *p << endl;
}
}
if(!missingTypes.empty())
{
sort(missingTypes.begin(), missingTypes.end());
unique(missingTypes.begin(), missingTypes.end());
if(!analyzeErrors.empty())
{
cerr << endl;
}
cerr << "The following types had no matching definitions in the new Slice:" << endl;
for(vector<string>::const_iterator p = missingTypes.begin(); p != missingTypes.end(); ++p)
{
cerr << " " << *p << endl;
}
}
if(!analyzeErrors.empty())
{
return EXIT_FAILURE;
}
descriptors = out.str();
if(!outputFile.empty())
{
//
// No nativeToUTF8 conversion necessary here, no string converter is installed
// by wmain() on Windows and args are assumbed to be UTF8 on Unix platforms.
//
IceUtilInternal::ofstream of(outputFile);
if(!of.good())
{
cerr << appName << ": unable to open file `" << outputFile << "'" << endl;
return EXIT_FAILURE;
}
of << descriptors;
of.close();
return EXIT_SUCCESS;
}
}
else
{
//
// Read the input file.
//
// No nativeToUTF8 conversion necessary here, no string converter is installed
// by wmain() on Windows and args are assumbed to be UTF8 on Unix platforms.
//
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();
}
if(dbEnvName == dbEnvNameNew)
{
cerr << appName << ": database environment names must be different" << endl;
return EXIT_FAILURE;
}
FreezeScript::ObjectFactoryPtr objectFactory = new FreezeScript::ObjectFactory;
communicator->addObjectFactory(objectFactory, "");
//
// Transform the database.
//
DbEnv dbEnv(0);
DbEnv dbEnvNew(0);
Freeze::TransactionPtr txNew;
Freeze::ConnectionPtr connection;
Freeze::ConnectionPtr connectionNew;
vector<Db*> dbs;
int status = EXIT_SUCCESS;
try
{
#ifdef _WIN32
//
// Berkeley DB may use a different C++ runtime.
//
dbEnv.set_alloc(::malloc, ::realloc, ::free);
dbEnvNew.set_alloc(::malloc, ::realloc, ::free);
#endif
//
// Open the old database environment. Use DB_RECOVER_FATAL if -c is specified.
// No transaction is created for the old environment.
//
// DB_THREAD is for compatibility with Freeze (the catalog)
//
{
u_int32_t flags = DB_THREAD | DB_CREATE | DB_INIT_TXN | DB_INIT_MPOOL;
if(catastrophicRecover)
{
flags |= DB_INIT_LOG | DB_RECOVER_FATAL;
}
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);
//
// Open the new database environment and start a transaction.
//
//
// DB_THREAD is for compatibility with Freeze (the catalog)
//
{
u_int32_t flags = DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_TXN | DB_RECOVER | DB_CREATE | DB_THREAD;
dbEnvNew.open(dbEnvNameNew.c_str(), flags, FREEZE_SCRIPT_DB_MODE);
}
//
// TODO: handle properly DbHome config (currently it will break if it's set for the new env)
//
//
// Open the catalog of the new environment, and start a transaction.
//
connectionNew = Freeze::createConnection(communicator, dbEnvNameNew, dbEnvNew);
txNew = connectionNew->beginTransaction();
DbTxn* txnNew = Freeze::getTxn(txNew);
if(allDb)
{
//
// Transform all databases in the old catalog.
//
for(FreezeScript::CatalogDataMap::iterator p = catalog.begin(); p != catalog.end(); ++p)
{
transformDb(p->second.evictor, communicator, objectFactory, dbEnv, dbEnvNew, p->first, connectionNew,
dbs, oldUnit, newUnit, txnNew, purgeObjects, suppress, descriptors);
}
}
else
{
transformDb(evictor, communicator, objectFactory, dbEnv, dbEnvNew, dbName, connectionNew, dbs,
oldUnit, newUnit, txnNew, purgeObjects, suppress, descriptors);
}
}
catch(const DbException& ex)
{
cerr << appName << ": database error: " << ex.what() << endl;
status = EXIT_FAILURE;
}
catch(const IceUtil::FileLockException&)
{
cerr << appName << ": error: database environment is locked" << endl;
status = EXIT_FAILURE;
}
catch(...)
{
try
{
if(txNew != 0)
{
txNew->rollback();
txNew = 0;
}
if(connectionNew)
{
connectionNew->close();
connectionNew = 0;
}
if(connection)
{
connection->close();
connection = 0;
}
for(vector<Db*>::iterator p = dbs.begin(); p != dbs.end(); ++p)
{
Db* db = *p;
db->close(0);
delete db;
}
try
{
dbEnv.close(0);
}
catch(const DbException&)
{
}
try
{
dbEnvNew.close(0);
}
catch(const DbException&)
{
}
}
catch(const DbException& ex)
{
cerr << appName << ": database error: " << ex.what() << endl;
}
throw;
}
if(txNew != 0)
{
try
{
if(status == EXIT_FAILURE)
{
txNew->rollback();
}
else
{
txNew->commit();
//
// Checkpoint to migrate changes from the log to the database(s).
//
dbEnvNew.txn_checkpoint(0, 0, DB_FORCE);
}
for(vector<Db*>::iterator p = dbs.begin(); p != dbs.end(); ++p)
{
Db* db = *p;
db->close(0);
delete db;
}
}
catch(const DbException& ex)
{
cerr << appName << ": database error: " << ex.what() << endl;
status = EXIT_FAILURE;
}
}
// Clear the transaction before closing the database environment.
txNew = 0;
if(connectionNew)
{
connectionNew->close();
connectionNew = 0;
}
if(connection)
{
connection->close();
connection = 0;
}
try
{
dbEnv.close(0);
}
catch(const DbException&)
{
}
try
{
dbEnvNew.close(0);
}
catch(const DbException&)
{
}
return status;
}
bool SyncService::start(int argc, char* argv[])
{
_myLogger = (MyLoggerI*)communicator()->getLogger()._ptr;
Ice::PropertiesPtr properties = communicator()->getProperties();
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
vector<string> args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
error(e.reason);
usage(argv[0]);
return false;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return false;
}
if(opts.isSet("version"))
{
print(SYNC_STRING_VERSION);
return false;
}
string connString = properties->getProperty("DB.ConnectionString");
_db = new Database(connString, communicator(), communicator()->getLogger());
std::map<std::string, OrderQueuePtr> queueMap;
_accounts = _db->getAccounts();
for (AccountInfoSeq::iterator p = _accounts.begin(); p != _accounts.end(); ++p)
{
TraderPtr recvTrader = new Trader(*p, communicator()->getLogger());
ReportSyncThreadPtr thread = new ReportSyncThread(p->account, recvTrader, communicator(), _db);
thread->start();
_rsThreads[p->account] = thread;
int workerCount = _db->getPropertyAsInt(p->account + "_wrokerCount");
if (workerCount <= 0)
{
_db->setLongProperty(p->account + "_wrokerCount", 1);
workerCount = 1;
}
OrderQueuePtr queue = new OrderQueue(*p, recvTrader, communicator()->getLogger());
queue->start(workerCount);
queueMap[p->account] = queue;
}
_syncThread = new SyncThread(queueMap, communicator(), _db);
_syncThread->start();
_timer = new IceUtil::Timer();
_timer->scheduleRepeated(new RefreshScreenTask(this), IceUtil::Time::seconds(2));
return true;
}
PyObject*
IcePy_loadSlice(PyObject* /*self*/, PyObject* args)
{
char* cmd;
PyObject* list = 0;
if(!PyArg_ParseTuple(args, STRCAST("s|O!"), &cmd, &PyList_Type, &list))
{
return 0;
}
vector<string> argSeq;
try
{
argSeq = IceUtilInternal::Options::split(cmd);
}
catch(const IceUtilInternal::BadOptException& ex)
{
PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str());
return 0;
}
catch(const IceUtilInternal::APIException& ex)
{
PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str());
return 0;
}
if(list)
{
if(!listToStringSeq(list, argSeq))
{
return 0;
}
}
IceUtilInternal::Options opts;
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("", "checksum");
opts.addOpt("", "all");
vector<string> files;
try
{
argSeq.insert(argSeq.begin(), ""); // dummy argv[0]
files = opts.parse(argSeq);
if(files.empty())
{
PyErr_Format(PyExc_RuntimeError, "no Slice files specified in `%s'", cmd);
return 0;
}
}
catch(const IceUtilInternal::BadOptException& ex)
{
PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str());
return 0;
}
catch(const IceUtilInternal::APIException& ex)
{
PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str());
return 0;
}
vector<string> cppArgs;
Ice::StringSeq includePaths;
bool debug = false;
bool ice = true; // This must be true so that we can create Ice::Identity when necessary.
bool underscore = opts.isSet("underscore");
bool all = false;
bool checksum = false;
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"))
{
includePaths = opts.argVec("I");
for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + *i);
}
}
debug = opts.isSet("d") || opts.isSet("debug");
all = opts.isSet("all");
checksum = opts.isSet("checksum");
bool ignoreRedefs = false;
bool keepComments = true;
for(vector<string>::const_iterator p = files.begin(); p != files.end(); ++p)
{
string file = *p;
Slice::PreprocessorPtr icecpp = Slice::Preprocessor::create("icecpp", file, cppArgs);
FILE* cppHandle = icecpp->preprocess(keepComments, "-D__SLICE2PY__");
if(cppHandle == 0)
{
PyErr_Format(PyExc_RuntimeError, "Slice preprocessing failed for `%s'", cmd);
return 0;
}
UnitPtr u = Slice::Unit::createUnit(ignoreRedefs, all, ice, underscore);
int parseStatus = u->parse(file, cppHandle, debug);
if(!icecpp->close() || parseStatus == EXIT_FAILURE)
{
PyErr_Format(PyExc_RuntimeError, "Slice parsing failed for `%s'", cmd);
u->destroy();
return 0;
}
//
// Generate the Python code into a string stream.
//
ostringstream codeStream;
IceUtilInternal::Output out(codeStream);
out.setUseTab(false);
//
// Emit a Python magic comment to set the file encoding.
// It must be the first or second line.
//
out << "# -*- coding: utf-8 -*-\n";
generate(u, all, checksum, includePaths, out);
u->destroy();
string code = codeStream.str();
//
// We need to invoke Ice.updateModules() so that all of the types we've just generated
// are made "public".
//
code += "\nIce.updateModules()\n";
PyObjectHandle src = Py_CompileString(const_cast<char*>(code.c_str()), const_cast<char*>(file.c_str()),
Py_file_input);
if(!src.get())
{
return 0;
}
PyObjectHandle globals = PyDict_New();
if(!globals.get())
{
return 0;
}
PyDict_SetItemString(globals.get(), "__builtins__", PyEval_GetBuiltins());
#if PY_VERSION_HEX >= 0x03000000
PyObjectHandle val = PyEval_EvalCode(src.get(), globals.get(), 0);
#else
PyObjectHandle val = PyEval_EvalCode(reinterpret_cast<PyCodeObject*>(src.get()), globals.get(), 0);
#endif
if(!val.get())
{
return 0;
}
}
Py_INCREF(Py_None);
return Py_None;
}
int
Client::run(int argc, char* argv[])
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("d", "debug");
opts.addOpt("", "import", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "export", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "dbhome", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "dbpath", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "mapsize", IceUtilInternal::Options::NeedArg);
vector<string> args;
try
{
args = opts.parse(argc, const_cast<const char**>(argv));
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
usage();
return EXIT_FAILURE;
}
if(!args.empty())
{
cerr << argv[0] << ": too many arguments" << endl;
usage();
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage();
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
if(!(opts.isSet("import") ^ opts.isSet("export")))
{
cerr << argv[0] << ": either --import or --export must be set" << endl;
usage();
return EXIT_FAILURE;
}
if(!(opts.isSet("dbhome") ^ opts.isSet("dbpath")))
{
cerr << argv[0] << ": set the database environment directory with either --dbhome or --dbpath" << endl;
usage();
return EXIT_FAILURE;
}
bool debug = opts.isSet("debug");
bool import = opts.isSet("import");
string dbFile = opts.optArg(import ? "import" : "export");
string dbPath;
if(opts.isSet("dbhome"))
{
dbPath = opts.optArg("dbhome");
}
else
{
dbPath = opts.optArg("dbpath");
}
string mapSizeStr = opts.optArg("mapsize");
size_t mapSize = IceDB::getMapSize(atoi(mapSizeStr.c_str()));
try
{
IceStorm::AllData data;
IceDB::IceContext dbContext;
dbContext.communicator = communicator();
dbContext.encoding.major = 1;
dbContext.encoding.minor = 1;
if(import)
{
cout << "Importing database to directory " << dbPath << " from file " << dbFile << endl;
if(!IceUtilInternal::directoryExists(dbPath))
{
cerr << argv[0] << ": output directory does not exist: " << dbPath << endl;
return EXIT_FAILURE;
}
if(!IceUtilInternal::isEmptyDirectory(dbPath))
{
cerr << argv[0] << ": output directory is not empty: " << dbPath << endl;
return EXIT_FAILURE;
}
ifstream fs(dbFile.c_str(), ios::binary);
if(fs.fail())
{
cerr << argv[0] << ": could not open input file: " << strerror(errno) << endl;
return EXIT_FAILURE;
}
fs.unsetf(ios::skipws);
fs.seekg(0, ios::end);
streampos fileSize = fs.tellg();
if(!fileSize)
{
fs.close();
cerr << argv[0] << ": empty input file" << endl;
return EXIT_FAILURE;
}
fs.seekg(0, ios::beg);
vector<Ice::Byte> buf;
buf.reserve(static_cast<size_t>(fileSize));
buf.insert(buf.begin(), istream_iterator<Ice::Byte>(fs), istream_iterator<Ice::Byte>());
fs.close();
string type;
int version;
Ice::InputStream stream(communicator(), dbContext.encoding, buf);
stream.read(type);
if(type != "IceStorm")
{
cerr << argv[0] << ": incorrect input file type: " << type << endl;
return EXIT_FAILURE;
}
stream.read(version);
stream.read(data);
{
IceDB::Env env(dbPath, 2, mapSize);
IceDB::ReadWriteTxn txn(env);
if(debug)
{
cout << "Writing LLU Map:" << endl;
}
IceDB::Dbi<string, LogUpdate, IceDB::IceContext, Ice::OutputStream>
lluMap(txn, "llu", dbContext, MDB_CREATE);
for(StringLogUpdateDict::const_iterator p = data.llus.begin(); p != data.llus.end(); ++p)
{
if(debug)
{
cout << " KEY = " << p->first << endl;
}
lluMap.put(txn, p->first, p->second);
}
if(debug)
{
cout << "Writing Subscriber Map:" << endl;
}
IceDB::Dbi<SubscriberRecordKey, SubscriberRecord, IceDB::IceContext, Ice::OutputStream>
subscriberMap(txn, "subscribers", dbContext, MDB_CREATE);
for(SubscriberRecordDict::const_iterator q = data.subscribers.begin(); q != data.subscribers.end(); ++q)
{
if(debug)
{
cout << " KEY = TOPIC(" << communicator()->identityToString(q->first.topic)
<< ") ID(" << communicator()->identityToString(q->first.id) << ")" <<endl;
}
subscriberMap.put(txn, q->first, q->second);
}
txn.commit();
env.close();
}
}
else
{
cout << "Exporting database from directory " << dbPath << " to file " << dbFile << endl;
{
IceDB::Env env(dbPath, 2);
IceDB::ReadOnlyTxn txn(env);
if(debug)
{
cout << "Reading LLU Map:" << endl;
}
IceDB::Dbi<string, LogUpdate, IceDB::IceContext, Ice::OutputStream>
lluMap(txn, "llu", dbContext, 0);
string s;
LogUpdate llu;
IceDB::ReadOnlyCursor<string, LogUpdate, IceDB::IceContext, Ice::OutputStream> lluCursor(lluMap, txn);
while(lluCursor.get(s, llu, MDB_NEXT))
{
if(debug)
{
cout << " KEY = " << s << endl;
}
data.llus.insert(std::make_pair(s, llu));
}
lluCursor.close();
if(debug)
{
cout << "Reading Subscriber Map:" << endl;
}
IceDB::Dbi<SubscriberRecordKey, SubscriberRecord, IceDB::IceContext, Ice::OutputStream>
subscriberMap(txn, "subscribers", dbContext, 0);
SubscriberRecordKey key;
SubscriberRecord record;
IceDB::ReadOnlyCursor<SubscriberRecordKey, SubscriberRecord, IceDB::IceContext, Ice::OutputStream>
subCursor(subscriberMap, txn);
while(subCursor.get(key, record, MDB_NEXT))
{
if(debug)
{
cout << " KEY = TOPIC(" << communicator()->identityToString(key.topic)
<< ") ID(" << communicator()->identityToString(key.id) << ")" <<endl;
}
data.subscribers.insert(std::make_pair(key, record));
}
subCursor.close();
txn.rollback();
env.close();
}
Ice::OutputStream stream(communicator(), dbContext.encoding);
stream.write("IceStorm");
stream.write(ICE_INT_VERSION);
stream.write(data);
ofstream fs(dbFile.c_str(), ios::binary);
if(fs.fail())
{
cerr << argv[0] << ": could not open output file: " << strerror(errno) << endl;
return EXIT_FAILURE;
}
fs.write(reinterpret_cast<const char*>(stream.b.begin()), stream.b.size());
fs.close();
}
}
catch(const IceUtil::Exception& ex)
{
cerr << argv[0] << ": " << (import ? "import" : "export") << " failed:\n" << ex << endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int
compile(const vector<string>& argv)
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "validate");
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("E");
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg, ".");
opts.addOpt("", "hdr", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "ftr", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "indexhdr", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "indexftr", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "index", IceUtilInternal::Options::NeedArg, "1");
opts.addOpt("", "image-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "logo-url", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "search", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "summary", IceUtilInternal::Options::NeedArg, "0");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "underscore");
bool validate = find(argv.begin(), argv.end(), "--validate") != argv.end();
vector<string> args;
try
{
args = opts.parse(argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
consoleErr << argv[0] << ": error: " << e.reason << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
consoleErr << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
optargs = opts.argVec("I");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
bool preprocess = opts.isSet("E");
string output = opts.optArg("output-dir");
string header = opts.optArg("hdr");
string footer = opts.optArg("ftr");
string indexHeader = opts.optArg("indexhdr");
string indexFooter = opts.optArg("indexftr");
string ind = opts.optArg("index");
unsigned indexCount = 0;
if(!ind.empty())
{
istringstream s(ind);
s >> indexCount;
if(!s)
{
consoleErr << argv[0] << ": error: the --index operation requires a positive integer argument"
<< endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
}
int
compile(int argc, char* argv[])
{
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("E");
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "tie");
opts.addOpt("", "impl");
opts.addOpt("", "impl-tie");
opts.addOpt("", "depend");
opts.addOpt("", "depend-xml");
opts.addOpt("", "list-generated");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "underscore");
opts.addOpt("", "checksum", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "stream");
opts.addOpt("", "meta", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
vector<string>args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
getErrorStream() << argv[0] << ": error: " << e.reason << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
getErrorStream() << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
vector<string>::const_iterator i;
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
vector<string> includePaths = opts.argVec("I");
for(i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
bool preprocess = opts.isSet("E");
string output = opts.optArg("output-dir");
bool tie = opts.isSet("tie");
bool impl = opts.isSet("impl");
bool implTie = opts.isSet("impl-tie");
bool depend = opts.isSet("depend");
bool dependxml = opts.isSet("depend-xml");
bool debug = opts.isSet("debug");
bool ice = opts.isSet("ice");
bool underscore = opts.isSet("underscore");
string checksumClass = opts.optArg("checksum");
bool stream = opts.isSet("stream");
bool listGenerated = opts.isSet("list-generated");
StringList globalMetadata;
vector<string> v = opts.argVec("meta");
copy(v.begin(), v.end(), back_inserter(globalMetadata));
if(args.empty())
{
getErrorStream() << argv[0] << ": error: no input file" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if(impl && implTie)
{
getErrorStream() << argv[0] << ": error: cannot specify both --impl and --impl-tie" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
int status = EXIT_SUCCESS;
ChecksumMap checksums;
IceUtil::CtrlCHandler ctrlCHandler;
ctrlCHandler.setCallback(interruptedCallback);
if(dependxml)
{
cout << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<dependencies>" << endl;
}
for(i = args.begin(); i != args.end(); ++i)
{
//
// Ignore duplicates.
//
vector<string>::iterator p = find(args.begin(), args.end(), *i);
if(p != i)
{
continue;
}
if(depend || dependxml)
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(false);
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
UnitPtr u = Unit::createUnit(false, false, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
u->destroy();
if(parseStatus == EXIT_FAILURE)
{
return EXIT_FAILURE;
}
if(!icecpp->printMakefileDependencies(depend ? Preprocessor::Java : Preprocessor::JavaXML, includePaths))
{
return EXIT_FAILURE;
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
ostringstream os;
if(listGenerated)
{
Slice::setErrorStream(os);
}
FileTracker::instance()->setSource(*i);
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(true);
if(cppHandle == 0)
{
if(listGenerated)
{
FileTracker::instance()->setOutput(os.str(), true);
}
status = EXIT_FAILURE;
break;
}
if(preprocess)
{
char buf[4096];
while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
{
if(fputs(buf, stdout) == EOF)
{
return EXIT_FAILURE;
}
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
UnitPtr p = Unit::createUnit(false, false, ice, underscore, globalMetadata);
int parseStatus = p->parse(*i, cppHandle, debug, Ice);
if(!icecpp->close())
{
p->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
p->destroy();
if(listGenerated)
{
FileTracker::instance()->setOutput(os.str(), true);
}
status = EXIT_FAILURE;
}
else
{
try
{
Gen gen(argv[0], icecpp->getBaseName(), includePaths, output);
gen.generate(p, stream);
if(tie)
{
gen.generateTie(p);
}
if(impl)
{
gen.generateImpl(p);
}
if(implTie)
{
gen.generateImplTie(p);
}
if(!checksumClass.empty())
{
//
// Calculate checksums for the Slice definitions in the unit.
//
ChecksumMap m = createChecksums(p);
copy(m.begin(), m.end(), inserter(checksums, checksums.begin()));
}
if(listGenerated)
{
FileTracker::instance()->setOutput(os.str(), false);
}
}
catch(const Slice::FileException& ex)
{
//
// If a file could not be created then cleanup any files we've already created.
//
FileTracker::instance()->cleanup();
p->destroy();
getErrorStream() << argv[0] << ": error: " << ex.reason() << endl;
if(listGenerated)
{
FileTracker::instance()->setOutput(os.str(), true);
}
status = EXIT_FAILURE;
break;
}
}
p->destroy();
}
}
{
IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(mutex);
if(interrupted)
{
//
// If the translator was interrupted then cleanup any files we've already created.
//
FileTracker::instance()->cleanup();
return EXIT_FAILURE;
}
}
}
if(dependxml)
{
cout << "</dependencies>\n";
}
if(status == EXIT_SUCCESS && !checksumClass.empty())
{
try
{
Gen::writeChecksumClass(checksumClass, output, checksums);
}
catch(const Slice::FileException& ex)
{
// If a file could not be created, then
// cleanup any created files.
FileTracker::instance()->cleanup();
getErrorStream() << argv[0] << ": error: " << ex.reason() << endl;
return EXIT_FAILURE;
}
}
if(listGenerated)
{
FileTracker::instance()->dumpxml();
}
return status;
}
bool
IceBox::IceBoxService::start(int argc, char* argv[], int& status)
{
// Run through the command line arguments removing all the service
// properties.
vector<string> args = Ice::argsToStringSeq(argc, argv);
PropertiesPtr properties = communicator()->getProperties();
const string prefix = "IceBox.Service.";
PropertyDict services = properties->getPropertiesForPrefix(prefix);
for(PropertyDict::const_iterator p = services.begin(); p != services.end(); ++p)
{
string name = p->first.substr(prefix.size());
StringSeq::iterator q = args.begin();
while(q != args.end())
{
if(q->find("--" + name + ".") == 0)
{
q = args.erase(q);
continue;
}
++q;
}
}
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
try
{
args = opts.parse(args);
}
catch(const IceUtilInternal::BadOptException& e)
{
error(e.reason);
usage(argv[0]);
return false;
}
if(opts.isSet("help"))
{
usage(argv[0]);
status = EXIT_SUCCESS;
return false;
}
if(opts.isSet("version"))
{
print(ICE_STRING_VERSION);
status = EXIT_SUCCESS;
return false;
}
if(!args.empty())
{
usage(argv[0]);
return false;
}
_serviceManager = new ServiceManagerI(communicator(), argc, argv);
return _serviceManager->start();
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "id", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "unsub");
try
{
opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
PropertiesPtr properties = communicator->getProperties();
const char* managerProxyProperty = "IceStormAdmin.TopicManager.Default";
string managerProxy = properties->getProperty(managerProxyProperty);
if(managerProxy.empty())
{
cerr << argv[0] << ": property `" << managerProxyProperty << "' is not set" << endl;
return EXIT_FAILURE;
}
ObjectPrx base = communicator->stringToProxy(managerProxy);
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(base);
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SingleAdapter", "default");
TopicPrx topic;
try
{
topic = manager->retrieve("single");
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
Ice::ObjectPrx prx = adapter->add(new SingleI(), communicator->stringToIdentity(opts.optArg("id")));
if(opts.isSet("unsub"))
{
topic->unsubscribe(prx);
}
else
{
IceStorm::QoS qos;
qos["persistent"] = "true";
topic->subscribeAndGetPublisher(qos, prx);
}
return EXIT_SUCCESS;
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "events", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "qos", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("", "slow");
opts.addOpt("", "erratic", IceUtilInternal::Options::NeedArg);
try
{
opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
int events = 1000;
string s = opts.optArg("events");
if(!s.empty())
{
events = atoi(s.c_str());
}
if(events <= 0)
{
cerr << argv[0] << ": events must be > 0." << endl;
return EXIT_FAILURE;
}
IceStorm::QoS cmdLineQos;
vector<string> sqos = opts.argVec("qos");
for(vector<string>::const_iterator q = sqos.begin(); q != sqos.end(); ++q)
{
string::size_type off = q->find(",");
if(off == string::npos)
{
cerr << argv[0] << ": parse error: no , in QoS" << endl;
return EXIT_FAILURE;
}
cmdLineQos[q->substr(0, off)] = q->substr(off+1);
}
bool slow = opts.isSet("slow");
bool erratic = false;
int erraticNum = 0;
s = opts.optArg("erratic");
if(!s.empty())
{
erratic = true;
erraticNum = atoi(s.c_str());
}
if(events <= 0)
{
cerr << argv[0] << ": events must be > 0." << endl;
return EXIT_FAILURE;
}
PropertiesPtr properties = communicator->getProperties();
const char* managerProxyProperty = "IceStormAdmin.TopicManager.Default";
string managerProxy = properties->getProperty(managerProxyProperty);
if(managerProxy.empty())
{
cerr << argv[0] << ": property `" << managerProxyProperty << "' is not set" << endl;
return EXIT_FAILURE;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator->stringToProxy(managerProxy));
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
vector<Subscription> subs;
if(erratic)
{
for(int i = 0 ; i < erraticNum; ++i)
{
ostringstream os;
os << "SubscriberAdapter" << i;
Subscription item;
item.adapter = communicator->createObjectAdapterWithEndpoints(os.str(), "default");
item.servant = new ErraticEventI(communicator, events);
item.qos["reliability"] = "twoway";
subs.push_back(item);
}
}
else if(slow)
{
Subscription item;
item.adapter = communicator->createObjectAdapterWithEndpoints("SubscriberAdapter", "default");
item.servant = new SlowEventI(communicator, events);
item.qos = cmdLineQos;
subs.push_back(item);
}
else
{
Subscription item;
item.adapter = communicator->createObjectAdapterWithEndpoints("SubscriberAdapter", "default");
item.qos = cmdLineQos;
map<string, string>::const_iterator p = item.qos.find("reliability");
if(p != item.qos.end() && p->second == "ordered")
{
item.servant = new OrderEventI(communicator, events);
}
else
{
item.servant = new CountEventI(communicator, events);
}
subs.push_back(item);
}
TopicPrx topic;
try
{
topic = manager->retrieve("fed1");
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
{
for(vector<Subscription>::iterator p = subs.begin(); p != subs.end(); ++p)
{
p->obj = p->adapter->addWithUUID(p->servant);
IceStorm::QoS qos;
string reliability = "";
IceStorm::QoS::const_iterator q = p->qos.find("reliability");
if(q != p->qos.end())
{
reliability = q->second;
}
if(reliability == "twoway")
{
// Do nothing.
}
else if(reliability == "ordered")
{
qos["reliability"] = "ordered";
}
else if(reliability == "batch")
{
p->obj = p->obj->ice_batchOneway();
}
else //if(reliability == "oneway")
{
p->obj = p->obj->ice_oneway();
}
topic->subscribeAndGetPublisher(qos, p->obj);
}
}
{
for(vector<Subscription>::iterator p = subs.begin(); p != subs.end(); ++p)
{
p->adapter->activate();
}
}
communicator->waitForShutdown();
{
for(vector<Subscription>::const_iterator p = subs.begin(); p != subs.end(); ++p)
{
topic->unsubscribe(p->obj);
if(p->servant->count() != events)
{
cerr << "expected " << events << " events but got " << p->servant->count() << " events." << endl;
return EXIT_FAILURE;
}
}
}
return EXIT_SUCCESS;
}
int
compile(int argc, char* argv[])
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "header-ext", IceUtilInternal::Options::NeedArg, "h");
opts.addOpt("", "source-ext", IceUtilInternal::Options::NeedArg, "cpp");
opts.addOpt("", "add-header", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
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("E");
opts.addOpt("", "include-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "dll-export", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "impl");
opts.addOpt("", "depend");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "underscore");
opts.addOpt("", "checksum");
opts.addOpt("", "stream");
vector<string> args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
getErrorStream() << argv[0] << ": " << e.reason << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
getErrorStream() << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
string headerExtension = opts.optArg("header-ext");
string sourceExtension = opts.optArg("source-ext");
vector<string> extraHeaders = opts.argVec("add-header");
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
vector<string>::const_iterator i;
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
vector<string> includePaths;
includePaths = opts.argVec("I");
for(i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
bool preprocess = opts.isSet("E");
string include = opts.optArg("include-dir");
string output = opts.optArg("output-dir");
string dllExport = opts.optArg("dll-export");
bool impl = opts.isSet("impl");
bool depend = opts.isSet("depend");
bool debug = opts.isSet("debug");
bool ice = opts.isSet("ice");
bool underscore = opts.isSet("underscore");
bool checksum = opts.isSet("checksum");
bool stream = opts.isSet("stream");
if(args.empty())
{
getErrorStream() << argv[0] << ": error: no input file" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
int status = EXIT_SUCCESS;
IceUtil::CtrlCHandler ctrlCHandler;
ctrlCHandler.setCallback(interruptedCallback);
for(i = args.begin(); i != args.end(); ++i)
{
//
// Ignore duplicates.
//
vector<string>::iterator p = find(args.begin(), args.end(), *i);
if(p != i)
{
continue;
}
if(depend)
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(false);
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
UnitPtr u = Unit::createUnit(false, false, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
u->destroy();
if(parseStatus == EXIT_FAILURE)
{
return EXIT_FAILURE;
}
if(!icecpp->printMakefileDependencies(Preprocessor::CPlusPlus, includePaths, sourceExtension))
{
return EXIT_FAILURE;
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(false);
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
if(preprocess)
{
char buf[4096];
while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
{
if(fputs(buf, stdout) == EOF)
{
return EXIT_FAILURE;
}
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
UnitPtr u = Unit::createUnit(false, false, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
if(!icecpp->close())
{
u->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
status = EXIT_FAILURE;
}
else
{
try
{
Gen gen(icecpp->getBaseName(), headerExtension, sourceExtension, extraHeaders, include,
includePaths, dllExport, output, impl, checksum, stream, ice);
gen.generate(u);
}
catch(const Slice::FileException& ex)
{
// If a file could not be created, then
// cleanup any created files.
FileTracker::instance()->cleanup();
u->destroy();
getErrorStream() << argv[0] << ": error: " << ex.reason() << endl;
return EXIT_FAILURE;
}
}
u->destroy();
}
}
{
IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(mutex);
if(interrupted)
{
FileTracker::instance()->cleanup();
return EXIT_FAILURE;
}
}
}
return status;
}
int
compile(const vector<string>& argv)
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "validate");
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("E");
opts.addOpt("", "stdout");
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "depend");
opts.addOpt("", "depend-json");
opts.addOpt("", "depend-xml");
opts.addOpt("", "depend-file", IceUtilInternal::Options::NeedArg, "");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "underscore");
bool validate = find(argv.begin(), argv.end(), "--validate") != argv.end();
vector<string> args;
try
{
args = opts.parse(argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
consoleErr << argv[0] << ": error: " << e.reason << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
consoleErr << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
vector<string> includePaths = opts.argVec("I");
for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
bool preprocess = opts.isSet("E");
bool useStdout = opts.isSet("stdout");
string output = opts.optArg("output-dir");
bool depend = opts.isSet("depend");
bool dependJSON = opts.isSet("depend-json");
bool dependxml = opts.isSet("depend-xml");
string dependFile = opts.optArg("depend-file");
bool debug = opts.isSet("debug");
bool ice = opts.isSet("ice");
bool underscore = opts.isSet("underscore");
if(args.empty())
{
consoleErr << argv[0] << ": error: no input file" << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(depend && dependJSON)
{
consoleErr << argv[0] << ": error: cannot specify both --depend and --depend-json" << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(depend && dependxml)
{
consoleErr << argv[0] << ": error: cannot specify both --depend and --depend-xml" << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(dependxml && dependJSON)
{
consoleErr << argv[0] << ": error: cannot specify both --depend-xml and --depend-json" << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(validate)
{
return EXIT_SUCCESS;
}
int status = EXIT_SUCCESS;
IceUtil::CtrlCHandler ctrlCHandler;
ctrlCHandler.setCallback(interruptedCallback);
ostringstream os;
if(dependJSON)
{
os << "{" << endl;
}
else if(dependxml)
{
os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<dependencies>" << endl;
}
//
// Create a copy of args without the duplicates.
//
vector<string> sources;
for(vector<string>::const_iterator i = args.begin(); i != args.end(); ++i)
{
vector<string>::iterator p = find(sources.begin(), sources.end(), *i);
if(p == sources.end())
{
sources.push_back(*i);
}
}
for(vector<string>::const_iterator i = sources.begin(); i != sources.end();)
{
if(depend || dependJSON || dependxml)
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(false, "-D__SLICE2JS__");
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
UnitPtr u = Unit::createUnit(false, false, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
u->destroy();
if(parseStatus == EXIT_FAILURE)
{
return EXIT_FAILURE;
}
bool last = (++i == sources.end());
if(!icecpp->printMakefileDependencies(os,
depend ? Preprocessor::JavaScript : (dependJSON ? Preprocessor::JavaScriptJSON : Preprocessor::SliceXML),
includePaths,
"-D__SLICE2JS__"))
{
return EXIT_FAILURE;
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
if(dependJSON)
{
if(!last)
{
os << ",";
}
os << "\n";
}
}
else
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(true, "-D__SLICE2JS__");
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
if(preprocess)
{
char buf[4096];
while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != ICE_NULLPTR)
{
if(fputs(buf, stdout) == EOF)
{
return EXIT_FAILURE;
}
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
UnitPtr p = Unit::createUnit(false, false, ice, underscore);
int parseStatus = p->parse(*i, cppHandle, debug);
if(!icecpp->close())
{
p->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
status = EXIT_FAILURE;
}
else
{
try
{
if(useStdout)
{
Gen gen(icecpp->getBaseName(), includePaths, output, cout);
gen.generate(p);
}
else
{
Gen gen(icecpp->getBaseName(), includePaths, output);
gen.generate(p);
}
}
catch(const Slice::FileException& ex)
{
//
// If a file could not be created, then clean up any created files.
//
FileTracker::instance()->cleanup();
p->destroy();
consoleErr << argv[0] << ": error: " << ex.reason() << endl;
return EXIT_FAILURE;
}
}
p->destroy();
}
++i;
}
{
IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(globalMutex);
if(interrupted)
{
FileTracker::instance()->cleanup();
return EXIT_FAILURE;
}
}
}
if(dependJSON)
{
os << "}\n";
}
else if(dependxml)
{
os << "</dependencies>\n";
}
if(depend || dependJSON || dependxml)
{
writeDependencies(os.str(), dependFile);
}
return status;
}
int
main(int argc, char* argv[])
#endif
{
Ice::StringSeq originalArgs = Ice::argsToStringSeq(argc, argv);
assert(originalArgs.size() > 0);
const string appName = originalArgs[0];
string dataDir;
StringSeq fileSeq;
int compress = 1;
bool verbose;
bool caseInsensitive;
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("z", "compress");
opts.addOpt("Z", "no-compress");
opts.addOpt("V", "verbose");
opts.addOpt("i", "case-insensitive");
vector<string> args;
try
{
args = opts.parse(originalArgs);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << e.reason << endl;
usage(appName);
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(appName);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
bool doCompress = opts.isSet("compress");
bool dontCompress = opts.isSet("no-compress");
if(doCompress && dontCompress)
{
cerr << appName << ": only one of -z and -Z are mutually exclusive" << endl;
usage(appName);
return EXIT_FAILURE;
}
if(doCompress)
{
compress = 2;
}
else if(dontCompress)
{
compress = 0;
}
verbose = opts.isSet("verbose");
caseInsensitive = opts.isSet("case-insensitive");
if(args.empty())
{
cerr << appName << ": no data directory specified" << endl;
usage(appName);
return EXIT_FAILURE;
}
dataDir = simplify(args[0]);
for(vector<string>::size_type i = 1; i < args.size(); ++i)
{
fileSeq.push_back(simplify(args[i]));
}
try
{
string absDataDir = dataDir;
string cwd;
if(IceUtilInternal::getcwd(cwd) != 0)
{
throw "cannot get the current directory:\n" + IceUtilInternal::lastErrorToString();
}
if(!IceUtilInternal::isAbsolutePath(absDataDir))
{
absDataDir = simplify(cwd + '/' + absDataDir);
}
for(StringSeq::iterator p = fileSeq.begin(); p != fileSeq.end(); ++p)
{
if(!IceUtilInternal::isAbsolutePath(*p))
{
*p = cwd + '/' + *p;
}
}
//
// We must call simplify() here: under Cygwin, any path starting with
// a double slash simply doesn't work. But, if dataDir is "/", we end
// up with paths that start with "//" unless we call simplify().
//
string absDataDirWithSlash = simplify(absDataDir + '/');
for(StringSeq::iterator p = fileSeq.begin(); p != fileSeq.end(); ++p)
{
if(p->compare(0, absDataDirWithSlash.size(), absDataDirWithSlash) != 0)
{
throw "`" + *p + "' is not a path in `" + dataDir + "'";
}
p->erase(0, absDataDirWithSlash.size());
}
LargeFileInfoSeq infoSeq;
if(fileSeq.empty())
{
CalcCB calcCB;
if(!getFileInfoSeq(absDataDir, compress, verbose ? &calcCB : 0, infoSeq))
{
return EXIT_FAILURE;
}
}
else
{
loadFileInfoSeq(absDataDir, infoSeq);
for(StringSeq::iterator p = fileSeq.begin(); p != fileSeq.end(); ++p)
{
LargeFileInfoSeq partialInfoSeq;
CalcCB calcCB;
if(!getFileInfoSeqSubDir(absDataDir, *p, compress, verbose ? &calcCB : 0, partialInfoSeq))
{
return EXIT_FAILURE;
}
LargeFileInfoSeq newInfoSeq;
newInfoSeq.reserve(infoSeq.size());
set_difference(infoSeq.begin(),
infoSeq.end(),
partialInfoSeq.begin(),
partialInfoSeq.end(),
back_inserter(newInfoSeq),
FileInfoPathLess());
infoSeq.swap(newInfoSeq);
newInfoSeq.clear();
newInfoSeq.reserve(infoSeq.size() + partialInfoSeq.size());
set_union(infoSeq.begin(),
infoSeq.end(),
partialInfoSeq.begin(),
partialInfoSeq.end(),
back_inserter(newInfoSeq),
FileInfoPathLess());
infoSeq.swap(newInfoSeq);
}
}
if(caseInsensitive)
{
LargeFileInfoSeq newInfoSeq = infoSeq;
sort(newInfoSeq.begin(), newInfoSeq.end(), IFileInfoPathLess());
string ex;
LargeFileInfoSeq::iterator p = newInfoSeq.begin();
while((p = adjacent_find(p, newInfoSeq.end(), IFileInfoPathEqual())) != newInfoSeq.end())
{
do
{
ex += '\n' + dataDir + '/' + p->path;
++p;
}
while(p < newInfoSeq.end() && IFileInfoPathEqual()(*(p - 1), *p));
}
if(!ex.empty())
{
ex = "duplicate files:" + ex;
throw ex;
}
}
saveFileInfoSeq(absDataDir, infoSeq);
}
catch(const string& ex)
{
cerr << appName << ": " << ex << endl;
return EXIT_FAILURE;
}
catch(const char* ex)
{
cerr << appName << ": " << ex << endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int
main(int argc, char* argv[])
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "header-ext", IceUtilInternal::Options::NeedArg, "h");
opts.addOpt("", "source-ext", IceUtilInternal::Options::NeedArg, "cpp");
opts.addOpt("", "add-header", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
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("E");
opts.addOpt("", "include-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "dll-export", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "impl");
opts.addOpt("", "depend");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "checksum");
opts.addOpt("", "stream");
opts.addOpt("", "case-sensitive");
// alexm: our custom options
opts.addOpt("", "module", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "util");
opts.addOpt("", "log");
vector<string> args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
string headerExtension = opts.optArg("header-ext");
string sourceExtension = opts.optArg("source-ext");
vector<string> extraHeaders = opts.argVec("add-header");
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
vector<string>::const_iterator i;
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
vector<string> includePaths;
includePaths = opts.argVec("I");
for(i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
// bool preprocess = opts.isSet("E");
string include = opts.optArg("include-dir");
string output = opts.optArg("output-dir");
string dllExport = opts.optArg("dll-export");
bool impl = opts.isSet("impl");
bool depend = opts.isSet("depend");
bool debug = opts.isSet("debug");
bool ice = opts.isSet("ice");
bool checksum = opts.isSet("checksum");
bool stream = opts.isSet("stream");
bool caseSensitive = opts.isSet("case-sensitive");
// alexm: custom options
string module = opts.optArg("module");
bool genUtil = opts.isSet("util");
bool genLog = opts.isSet("log");
if ( !depend && !genUtil && !genLog )
{
cerr << argv[0] << ": no output type specified" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if ( genUtil && genLog )
{
cerr << argv[0] << ": more than one output type specified" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
// alexm: end custom options
if(args.empty())
{
cerr << argv[0] << ": no input file" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
int status = EXIT_SUCCESS;
for(i = args.begin(); i != args.end(); ++i)
{
if(depend)
{
Preprocessor icecpp(argv[0], *i, cppArgs);
icecpp.printMakefileDependencies(Preprocessor::CPlusPlus, includePaths);
}
else
{
Preprocessor icecpp(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp.preprocess(false);
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
UnitPtr u = Unit::createUnit(false, false, ice, caseSensitive);
int parseStatus = u->parse(*i, cppHandle, debug);
if(!icecpp.close())
{
u->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
status = EXIT_FAILURE;
}
else
{
slice2orca::Gen gen(argv[0], icecpp.getBaseName(), headerExtension, sourceExtension, extraHeaders, include,
includePaths, dllExport, output, impl, checksum, stream, ice,
module, genUtil, genLog );
if(!gen)
{
u->destroy();
return EXIT_FAILURE;
}
gen.generate(u);
}
u->destroy();
}
}
return status;
}
int
Client::run(int argc, char* argv[])
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
vector<string> commands;
try
{
commands = opts.parse(argc, const_cast<const char**>(argv));
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << e.reason << endl;
usage();
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage();
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
if(commands.empty())
{
usage();
return EXIT_FAILURE;
}
ObjectPrxPtr base = communicator()->propertyToProxy("IceBoxAdmin.ServiceManager.Proxy");
if(base == 0)
{
//
// The old deprecated way to retrieve the service manager proxy
//
PropertiesPtr properties = communicator()->getProperties();
Identity managerIdentity;
managerIdentity.category = properties->getPropertyWithDefault("IceBox.InstanceName", "IceBox");
managerIdentity.name = "ServiceManager";
string managerProxy;
if(properties->getProperty("Ice.Default.Locator").empty())
{
string managerEndpoints = properties->getProperty("IceBox.ServiceManager.Endpoints");
if(managerEndpoints.empty())
{
cerr << appName() << ": property `IceBoxAdmin.ServiceManager.Proxy' is not set" << endl;
return EXIT_FAILURE;
}
managerProxy = "\"" + communicator()->identityToString(managerIdentity) + "\" :" + managerEndpoints;
}
else
{
string managerAdapterId = properties->getProperty("IceBox.ServiceManager.AdapterId");
if(managerAdapterId.empty())
{
cerr << appName() << ": property `IceBoxAdmin.ServiceManager.Proxy' is not set" << endl;
return EXIT_FAILURE;
}
managerProxy = "\"" + communicator()->identityToString(managerIdentity) + "\" @" + managerAdapterId;
}
base = communicator()->stringToProxy(managerProxy);
}
IceBox::ServiceManagerPrxPtr manager = ICE_CHECKED_CAST(IceBox::ServiceManagerPrx, base);
if(!manager)
{
cerr << appName() << ": `" << base << "' is not an IceBox::ServiceManager" << endl;
return EXIT_FAILURE;
}
Ice::SliceChecksumDict serverChecksums = manager->getSliceChecksums();
Ice::SliceChecksumDict localChecksums = Ice::sliceChecksums();
for(Ice::SliceChecksumDict::const_iterator p = localChecksums.begin(); p != localChecksums.end(); ++p)
{
Ice::SliceChecksumDict::const_iterator q = serverChecksums.find(p->first);
if(q == serverChecksums.end())
{
cerr << appName() << ": server is using unknown Slice type `" << q->first << "'" << endl;
}
else if(p->second != q->second)
{
cerr << appName() << ": server is using a different Slice definition of `" << q->first << "'" << endl;
}
}
for(vector<string>::const_iterator r = commands.begin(); r != commands.end(); ++r)
{
if((*r) == "shutdown")
{
manager->shutdown();
}
else if((*r) == "start")
{
if(++r == commands.end())
{
cerr << appName() << ": no service name specified." << endl;
return EXIT_FAILURE;
}
try
{
manager->startService(*r);
}
catch(const IceBox::NoSuchServiceException&)
{
cerr << appName() << ": unknown service `" << *r << "'" << endl;
return EXIT_FAILURE;
}
catch(const IceBox::AlreadyStartedException&)
{
cerr << appName() << ": service already started." << endl;
}
}
else if((*r) == "stop")
{
if(++r == commands.end())
{
cerr << appName() << ": no service name specified." << endl;
return EXIT_FAILURE;
}
try
{
manager->stopService(*r);
}
catch(const IceBox::NoSuchServiceException&)
{
cerr << appName() << ": unknown service `" << *r << "'" << endl;
return EXIT_FAILURE;
}
catch(const IceBox::AlreadyStoppedException&)
{
cerr << appName() << ": service already stopped." << endl;
}
}
else
{
cerr << appName() << ": unknown command `" << *r << "'" << endl;
usage();
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
bool
RouterService::start(int argc, char* argv[], int& status)
{
bool nowarn;
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "nowarn");
vector<string> args;
try
{
args = opts.parse(argc, const_cast<const char**>(argv));
}
catch(const IceUtilInternal::BadOptException& e)
{
error(e.reason);
usage(argv[0]);
return false;
}
if(opts.isSet("help"))
{
usage(argv[0]);
status = EXIT_SUCCESS;
return false;
}
if(opts.isSet("version"))
{
print(ICE_STRING_VERSION);
status = EXIT_SUCCESS;
return false;
}
nowarn = opts.isSet("nowarn");
if(!args.empty())
{
consoleErr << argv[0] << ": too many arguments" << endl;
usage(argv[0]);
return false;
}
PropertiesPtr properties = communicator()->getProperties();
//
// Initialize the client object adapter.
//
const string clientEndpointsProperty = "Glacier2.Client.Endpoints";
if(properties->getProperty(clientEndpointsProperty).empty())
{
error("property `" + clientEndpointsProperty + "' is not set");
return false;
}
if(properties->getPropertyAsInt("Glacier2.SessionTimeout") > 0 &&
properties->getProperty("Glacier2.Client.ACM.Timeout").empty())
{
ostringstream os;
os << properties->getPropertyAsInt("Glacier2.SessionTimeout");
properties->setProperty("Glacier2.Client.ACM.Timeout", os.str());
}
if(properties->getProperty("Glacier2.Client.ACM.Close").empty())
{
properties->setProperty("Glacier2.Client.ACM.Close", "4"); // Forcefull close on invocation and idle.
}
ObjectAdapterPtr clientAdapter = communicator()->createObjectAdapter("Glacier2.Client");
//
// Initialize the server object adapter only if server endpoints
// are defined.
//
const string serverEndpointsProperty = "Glacier2.Server.Endpoints";
ObjectAdapterPtr serverAdapter;
if(!properties->getProperty(serverEndpointsProperty).empty())
{
serverAdapter = communicator()->createObjectAdapter("Glacier2.Server");
}
string instanceName = communicator()->getProperties()->getPropertyWithDefault("Glacier2.InstanceName", "Glacier2");
vector<string> verifierProperties;
verifierProperties.push_back("Glacier2.PermissionsVerifier");
verifierProperties.push_back("Glacier2.SSLPermissionsVerifier");
Glacier2Internal::setupNullPermissionsVerifier(communicator(), instanceName, verifierProperties);
string verifierProperty = verifierProperties[0];
PermissionsVerifierPrx verifier;
ObjectPrx obj;
try
{
//
// We use propertyToProxy instead of stringToProxy because the property
// can provide proxy attributes
//
obj = communicator()->propertyToProxy(verifierProperty);
}
catch(const std::exception& ex)
{
ServiceError err(this);
err << "permissions verifier `" << communicator()->getProperties()->getProperty(verifierProperty)
<< "' is invalid:\n" << ex;
return false;
}
if(obj)
{
try
{
verifier = PermissionsVerifierPrx::checkedCast(obj);
if(!verifier)
{
ServiceError err(this);
err << "permissions verifier `" << communicator()->getProperties()->getProperty(verifierProperty)
<< "' is invalid";
return false;
}
}
catch(const Ice::Exception& ex)
{
if(!nowarn)
{
ServiceWarning warn(this);
warn << "unable to contact permissions verifier `"
<< communicator()->getProperties()->getProperty(verifierProperty) << "'\n" << ex;
}
verifier = PermissionsVerifierPrx::uncheckedCast(obj);
}
}
//
// Get the session manager if specified.
//
string sessionManagerProperty = "Glacier2.SessionManager";
string sessionManagerPropertyValue = properties->getProperty(sessionManagerProperty);
SessionManagerPrx sessionManager;
if(!sessionManagerPropertyValue.empty())
{
try
{
obj = communicator()->propertyToProxy(sessionManagerProperty);
}
catch(const std::exception& ex)
{
ServiceError err(this);
err << "session manager `" << sessionManagerPropertyValue << "' is invalid\n:" << ex;
return false;
}
try
{
sessionManager = SessionManagerPrx::checkedCast(obj);
if(!sessionManager)
{
error("session manager `" + sessionManagerPropertyValue + "' is invalid");
return false;
}
}
catch(const std::exception& ex)
{
if(!nowarn)
{
ServiceWarning warn(this);
warn << "unable to contact session manager `" << sessionManagerPropertyValue << "'\n" << ex;
}
sessionManager = SessionManagerPrx::uncheckedCast(obj);
}
sessionManager =
SessionManagerPrx::uncheckedCast(sessionManager->ice_connectionCached(false)->ice_locatorCacheTimeout(
properties->getPropertyAsIntWithDefault("Glacier2.SessionManager.LocatorCacheTimeout", 600)));
}
//
// Check for an SSL permissions verifier.
//
string sslVerifierProperty = verifierProperties[1];
SSLPermissionsVerifierPrx sslVerifier;
try
{
obj = communicator()->propertyToProxy(sslVerifierProperty);
}
catch(const std::exception& ex)
{
ServiceError err(this);
err << "ssl permissions verifier `" << communicator()->getProperties()->getProperty(sslVerifierProperty)
<< "' is invalid:\n" << ex;
return false;
}
if(obj)
{
try
{
sslVerifier = SSLPermissionsVerifierPrx::checkedCast(obj);
if(!sslVerifier)
{
ServiceError err(this);
err << "ssl permissions verifier `"
<< communicator()->getProperties()->getProperty(sslVerifierProperty)
<< "' is invalid";
}
}
catch(const Ice::Exception& ex)
{
if(!nowarn)
{
ServiceWarning warn(this);
warn << "unable to contact ssl permissions verifier `"
<< communicator()->getProperties()->getProperty(sslVerifierProperty) << "'\n"
<< ex;
}
sslVerifier = SSLPermissionsVerifierPrx::uncheckedCast(obj);
}
}
//
// Get the SSL session manager if specified.
//
string sslSessionManagerProperty = "Glacier2.SSLSessionManager";
string sslSessionManagerPropertyValue = properties->getProperty(sslSessionManagerProperty);
SSLSessionManagerPrx sslSessionManager;
if(!sslSessionManagerPropertyValue.empty())
{
try
{
obj = communicator()->propertyToProxy(sslSessionManagerProperty);
}
catch(const std::exception& ex)
{
ServiceError err(this);
err << "ssl session manager `" << sslSessionManagerPropertyValue << "' is invalid:\n" << ex;
return false;
}
try
{
sslSessionManager = SSLSessionManagerPrx::checkedCast(obj);
if(!sslSessionManager)
{
error("ssl session manager `" + sslSessionManagerPropertyValue + "' is invalid");
return false;
}
}
catch(const Ice::Exception& ex)
{
if(!nowarn)
{
ServiceWarning warn(this);
warn << "unable to contact ssl session manager `" << sslSessionManagerPropertyValue
<< "'\n" << ex;
}
sslSessionManager = SSLSessionManagerPrx::uncheckedCast(obj);
}
sslSessionManager =
SSLSessionManagerPrx::uncheckedCast(sslSessionManager->ice_connectionCached(false)->ice_locatorCacheTimeout(
properties->getPropertyAsIntWithDefault("Glacier2.SSLSessionManager.LocatorCacheTimeout", 600)));
}
if(!verifier && !sslVerifier)
{
error("Glacier2 requires a permissions verifier or password file");
return false;
}
//
// Create the instance object.
//
try
{
_instance = new Glacier2::Instance(communicator(), clientAdapter, serverAdapter);
}
catch(const Ice::InitializationException& ex)
{
error("Glacier2 initialization failed:\n" + ex.reason);
return false;
}
//
// Create the session router. The session router registers itself
// and all required servant locators, so no registration has to be
// done here.
//
_sessionRouter = new SessionRouterI(_instance, verifier, sessionManager, sslVerifier, sslSessionManager);
//
// Th session router is used directly as servant for the main
// Glacier2 router Ice object.
//
Identity routerId;
routerId.category = instanceName;
routerId.name = "router";
Glacier2::RouterPrx routerPrx = Glacier2::RouterPrx::uncheckedCast(clientAdapter->add(_sessionRouter, routerId));
//
// Add the Ice router finder object to allow retrieving the router
// proxy with just the endpoint information of the router.
//
Identity finderId;
finderId.category = "Ice";
finderId.name = "RouterFinder";
clientAdapter->add(new FinderI(routerPrx), finderId);
if(_instance->getObserver())
{
_instance->getObserver()->setObserverUpdater(_sessionRouter);
}
//
// Everything ok, let's go.
//
try
{
clientAdapter->activate();
if(serverAdapter)
{
serverAdapter->activate();
}
}
catch(const std::exception& ex)
{
{
ServiceError err(this);
err << "caught exception activating object adapters\n" << ex;
}
stop();
return false;
}
return true;
}
int
main(int argc, char* argv[])
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "header-ext", IceUtilInternal::Options::NeedArg, "h");
opts.addOpt("", "source-ext", IceUtilInternal::Options::NeedArg, "cpp");
opts.addOpt("", "add-header", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
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("E");
opts.addOpt("", "include-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "dll-export", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "impl");
opts.addOpt("", "depend");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "case-sensitive");
vector<string> args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICEE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
string headerExtension = opts.optArg("header-ext");
string sourceExtension = opts.optArg("source-ext");
vector<string>extraHeaders = opts.argVec("add-header");
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
vector<string>::const_iterator i;
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
vector<string> includePaths = opts.argVec("I");
for(i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
bool preprocess = opts.isSet("E");
string include = opts.optArg("include-dir");
string output = opts.optArg("output-dir");
string dllExport = opts.optArg("dll-export");
bool impl = opts.isSet("impl");
bool depend = opts.isSet("depend");
bool debug = opts.isSet("debug");
bool ice = opts.isSet("ice");
bool caseSensitive = opts.isSet("case-sensitive");
if(args.empty())
{
cerr << argv[0] << ": no input file" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
int status = EXIT_SUCCESS;
IceUtil::CtrlCHandler ctrlCHandler;
ctrlCHandler.setCallback(interruptedCallback);
for(i = args.begin(); i != args.end(); ++i)
{
if(depend)
{
Preprocessor icecpp(argv[0], *i, cppArgs);
icecpp.printMakefileDependencies(Preprocessor::CPlusPlus, includePaths);
}
else
{
Preprocessor icecpp(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp.preprocess(false);
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
if(preprocess)
{
char buf[4096];
while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
{
if(fputs(buf, stdout) == EOF)
{
return EXIT_FAILURE;
}
}
if(!icecpp.close())
{
return EXIT_FAILURE;
}
}
else
{
UnitPtr u = Unit::createUnit(false, false, ice, caseSensitive);
int parseStatus = u->parse(*i, cppHandle, debug, Slice::IceE);
if(!icecpp.close())
{
u->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
status = EXIT_FAILURE;
}
else
{
Gen gen(argv[0], icecpp.getBaseName(), headerExtension, sourceExtension, extraHeaders, include,
includePaths, dllExport, output, impl, ice);
if(!gen)
{
u->destroy();
return EXIT_FAILURE;
}
gen.generate(u);
}
u->destroy();
}
}
{
IceUtil::StaticMutex::Lock lock(_mutex);
if(_interrupted)
{
return EXIT_FAILURE;
}
}
}
return status;
}
int
Client::run(int argc, char* argv[])
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("d", "debug");
opts.addOpt("", "import", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "export", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "dbhome", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "dbpath", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "mapsize", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "server-version", IceUtilInternal::Options::NeedArg);
vector<string> args;
try
{
args = opts.parse(argc, const_cast<const char**>(argv));
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << e.reason << endl;
usage();
return EXIT_FAILURE;
}
if(!args.empty())
{
cerr << argv[0] << ": too many arguments" << endl;
usage();
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage();
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
if(!(opts.isSet("import") ^ opts.isSet("export")))
{
cerr << "Either --import or --export must be set" << endl;
usage();
return EXIT_FAILURE;
}
if(!(opts.isSet("dbhome") ^ opts.isSet("dbpath")))
{
cerr << "Set the database environment directory with either --dbhome or --dbpath" << endl;
usage();
return EXIT_FAILURE;
}
bool debug = opts.isSet("debug");
bool import = opts.isSet("import");
string dbFile = opts.optArg(import ? "import" : "export");
string dbPath;
if(opts.isSet("dbhome"))
{
dbPath = opts.optArg("dbhome");
}
else
{
dbPath = opts.optArg("dbpath");
}
string mapSizeStr = opts.optArg("mapsize");
size_t mapSize = IceDB::getMapSize(atoi(mapSizeStr.c_str()));
string serverVersion = opts.optArg("server-version");
try
{
IceGrid::AllData data;
IceDB::IceContext dbContext;
dbContext.communicator = communicator();
dbContext.encoding.major = 1;
dbContext.encoding.minor = 1;
if(import)
{
cout << "Importing database to directory `" << dbPath << "' from file `" << dbFile << "'" << endl;
if(!IceUtilInternal::directoryExists(dbPath))
{
cerr << "Output directory does not exist: " << dbPath << endl;
return EXIT_FAILURE;
}
StringSeq files = IcePatch2Internal::readDirectory(dbPath);
if(!files.empty())
{
cerr << "Output directory is not empty: " << dbPath << endl;
return EXIT_FAILURE;
}
ifstream fs(dbFile.c_str(), ios::binary);
if(fs.fail())
{
cerr << "Could not open input file: " << strerror(errno) << endl;
return EXIT_FAILURE;
}
fs.unsetf(ios::skipws);
fs.seekg(0, ios::end);
streampos fileSize = fs.tellg();
fs.seekg(0, ios::beg);
vector<Ice::Byte> buf;
buf.reserve(static_cast<size_t>(fileSize));
buf.insert(buf.begin(), istream_iterator<Ice::Byte>(fs), istream_iterator<Ice::Byte>());
fs.close();
if(!serverVersion.empty())
{
ValueFactoryPtr factory = new ValueFactoryI(serverVersion);
communicator()->addValueFactory(factory, "::IceGrid::ServerDescriptor");
communicator()->addValueFactory(factory, "::IceGrid::IceBoxDescriptor");
}
Ice::InputStreamPtr stream = Ice::wrapInputStream(communicator(), buf, dbContext.encoding);
string type;
int version;
stream->read(type);
if(type != "IceGrid")
{
cerr << "Incorrect input file type: " << type << endl;
return EXIT_FAILURE;
}
stream->read(version);
if(version / 100 == 305)
{
if(debug)
{
cout << "Reading Ice 3.5.x data" << endl;
}
skipFilter = true;
}
stream->read(data);
{
IceDB::Env env(dbPath, 5, mapSize);
IceDB::ReadWriteTxn txn(env);
if(debug)
{
cout << "Writing Applications Map:" << endl;
}
IceDB::Dbi<string, ApplicationInfo, IceDB::IceContext, Ice::OutputStreamPtr>
apps(txn, "applications", dbContext, MDB_CREATE);
for(ApplicationInfoSeq::const_iterator p = data.applications.begin(); p != data.applications.end(); ++p)
{
if(debug)
{
cout << " NAME = " << p->descriptor.name << endl;
}
apps.put(txn, p->descriptor.name, *p);
}
if(debug)
{
cout << "Writing Adapters Map:" << endl;
}
IceDB::Dbi<string, AdapterInfo, IceDB::IceContext, Ice::OutputStreamPtr>
adpts(txn, "adapters", dbContext, MDB_CREATE);
for(AdapterInfoSeq::const_iterator p = data.adapters.begin(); p != data.adapters.end(); ++p)
{
if(debug)
{
cout << " NAME = " << p->id << endl;
}
adpts.put(txn, p->id, *p);
}
if(debug)
{
cout << "Writing Objects Map:" << endl;
}
IceDB::Dbi<Identity, ObjectInfo, IceDB::IceContext, Ice::OutputStreamPtr>
objs(txn, "objects", dbContext, MDB_CREATE);
for(ObjectInfoSeq::const_iterator p = data.objects.begin(); p != data.objects.end(); ++p)
{
if(debug)
{
cout << " NAME = " << communicator()->identityToString(p->proxy->ice_getIdentity()) << endl;
}
objs.put(txn, p->proxy->ice_getIdentity(), *p);
}
if(debug)
{
cout << "Writing Internal Objects Map:" << endl;
}
IceDB::Dbi<Identity, ObjectInfo, IceDB::IceContext, Ice::OutputStreamPtr>
internalObjs(txn, "internal-objects", dbContext, MDB_CREATE);
for(ObjectInfoSeq::const_iterator p = data.internalObjects.begin(); p != data.internalObjects.end(); ++p)
{
if(debug)
{
cout << " NAME = " << communicator()->identityToString(p->proxy->ice_getIdentity()) << endl;
}
internalObjs.put(txn, p->proxy->ice_getIdentity(), *p);
}
if(debug)
{
cout << "Writing Serials Map:" << endl;
}
IceDB::Dbi<string, Long, IceDB::IceContext, Ice::OutputStreamPtr>
srls(txn, "serials", dbContext, MDB_CREATE);
for(StringLongDict::const_iterator p = data.serials.begin(); p != data.serials.end(); ++p)
{
if(debug)
{
cout << " NAME = " << p->first << endl;
}
srls.put(txn, p->first, p->second);
}
txn.commit();
env.close();
}
}
else
{
cout << "Exporting database from directory `" << dbPath << "' to file `" << dbFile << "'" << endl;
{
IceDB::Env env(dbPath, 5);
IceDB::ReadOnlyTxn txn(env);
if(debug)
{
cout << "Reading Application Map:" << endl;
}
IceDB::Dbi<string, IceGrid::ApplicationInfo, IceDB::IceContext, Ice::OutputStreamPtr>
applications(txn, "applications", dbContext, 0);
string name;
ApplicationInfo application;
IceDB::ReadOnlyCursor<string, IceGrid::ApplicationInfo, IceDB::IceContext, Ice::OutputStreamPtr>
appCursor(applications, txn);
while(appCursor.get(name, application, MDB_NEXT))
{
if(debug)
{
cout << " APPLICATION = " << name << endl;
}
data.applications.push_back(application);
}
appCursor.close();
if(debug)
{
cout << "Reading Adapter Map:" << endl;
}
IceDB::Dbi<string, IceGrid::AdapterInfo, IceDB::IceContext, Ice::OutputStreamPtr>
adapters(txn, "adapters", dbContext, 0);
AdapterInfo adapter;
IceDB::ReadOnlyCursor<string, IceGrid::AdapterInfo, IceDB::IceContext, Ice::OutputStreamPtr>
adapterCursor(adapters, txn);
while(adapterCursor.get(name, adapter, MDB_NEXT))
{
if(debug)
{
cout << " ADAPTER = " << name << endl;
}
data.adapters.push_back(adapter);
}
adapterCursor.close();
if(debug)
{
cout << "Reading Object Map:" << endl;
}
IceDB::Dbi<Identity, IceGrid::ObjectInfo, IceDB::IceContext, Ice::OutputStreamPtr>
objects(txn, "objects", dbContext, 0);
Identity id;
ObjectInfo object;
IceDB::ReadOnlyCursor<Identity, IceGrid::ObjectInfo, IceDB::IceContext, Ice::OutputStreamPtr>
objCursor(objects, txn);
while(objCursor.get(id, object, MDB_NEXT))
{
if(debug)
{
cout << " IDENTITY = " << communicator()->identityToString(id) << endl;
}
data.objects.push_back(object);
}
objCursor.close();
if(debug)
{
cout << "Reading Internal Object Map:" << endl;
}
IceDB::Dbi<Identity, IceGrid::ObjectInfo, IceDB::IceContext, Ice::OutputStreamPtr>
internalObjects(txn, "internal-objects", dbContext, 0);
IceDB::ReadOnlyCursor<Identity, IceGrid::ObjectInfo, IceDB::IceContext, Ice::OutputStreamPtr>
iobjCursor(internalObjects, txn);
while(iobjCursor.get(id, object, MDB_NEXT))
{
if(debug)
{
cout << " IDENTITY = " << communicator()->identityToString(id) << endl;
}
data.internalObjects.push_back(object);
}
iobjCursor.close();
if(debug)
{
cout << "Reading Serials Map:" << endl;
}
IceDB::Dbi<string, Long, IceDB::IceContext, Ice::OutputStreamPtr>
serials(txn, "serials", dbContext, 0);
Long serial;
IceDB::ReadOnlyCursor<string, Long, IceDB::IceContext, Ice::OutputStreamPtr>
serialCursor(serials, txn);
while(serialCursor.get(name, serial, MDB_NEXT))
{
if(debug)
{
cout << " NAME = " << name << endl;
}
data.serials.insert(std::make_pair(name, serial));
}
serialCursor.close();
txn.rollback();
env.close();
}
Ice::OutputStreamPtr stream = Ice::createOutputStream(communicator(), dbContext.encoding);
stream->write("IceGrid");
stream->write(ICE_INT_VERSION);
stream->write(data);
pair<const Ice::Byte*, const Ice::Byte*> buf = stream->finished();
ofstream fs(dbFile.c_str(), ios::binary);
if(fs.fail())
{
cerr << "Could not open output file: " << strerror(errno) << endl;
return EXIT_FAILURE;
}
fs.write(reinterpret_cast<const char*>(buf.first), buf.second - buf.first);
fs.close();
}
}
catch(const IceUtil::Exception& ex)
{
cerr << (import ? "Import" : "Export") << " failed:\n" << ex << endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "cycle");
try
{
opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
PropertiesPtr properties = communicator->getProperties();
const char* managerProxyProperty = "IceStormAdmin.TopicManager.Default";
string managerProxy = properties->getProperty(managerProxyProperty);
if(managerProxy.empty())
{
cerr << argv[0] << ": property `" << managerProxyProperty << "' is not set" << endl;
return EXIT_FAILURE;
}
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(
communicator->stringToProxy(managerProxy));
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
TopicPrx topic;
while(true)
{
try
{
topic = manager->retrieve("single");
break;
}
// This can happen if the replica group loses the majority
// during retrieve. In this case we retry.
catch(const Ice::UnknownException&)
{
continue;
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
}
assert(topic);
//
// Get a publisher object, create a twoway proxy and then cast to
// a Single object.
//
if(opts.isSet("cycle"))
{
Ice::ObjectPrx prx = topic->getPublisher()->ice_twoway();
vector<SinglePrx> single;
Ice::EndpointSeq endpoints = prx->ice_getEndpoints();
for(Ice::EndpointSeq::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
if((*p)->toString().substr(0, 3) != "udp")
{
Ice::EndpointSeq e;
e.push_back(*p);
single.push_back(SinglePrx::uncheckedCast(prx->ice_endpoints(e)));
}
}
if(single.size() <= 1)
{
cerr << argv[0] << ": Not enough endpoints in publisher proxy" << endl;
return EXIT_FAILURE;
}
int which = 0;
for(int i = 0; i < 1000; ++i)
{
single[which]->event(i);
which = (which + 1) % static_cast<int>(single.size());
}
}
else
{
SinglePrx single = SinglePrx::uncheckedCast(topic->getPublisher()->ice_twoway());
for(int i = 0; i < 1000; ++i)
{
single->event(i);
}
}
return EXIT_SUCCESS;
}
int
run(int argc, char* argv[], const CommunicatorPtr& communicator)
{
IceUtilInternal::Options opts;
opts.addOpt("", "ordered");
opts.addOpt("", "twoway");
opts.addOpt("", "events", IceUtilInternal::Options::NeedArg);
try
{
opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
return EXIT_FAILURE;
}
PropertiesPtr properties = communicator->getProperties();
const char* managerProxyProperty = "IceStormAdmin.TopicManager.Default";
string managerProxy = properties->getProperty(managerProxyProperty);
if(managerProxy.empty())
{
cerr << argv[0] << ": property `" << managerProxyProperty << "' is not set" << endl;
return EXIT_FAILURE;
}
ObjectPrx base = communicator->stringToProxy(managerProxy);
IceStorm::TopicManagerPrx manager = IceStorm::TopicManagerPrx::checkedCast(base);
if(!manager)
{
cerr << argv[0] << ": `" << managerProxy << "' is not running" << endl;
return EXIT_FAILURE;
}
ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("SingleAdapter", "default");
TopicPrx topic;
while(true)
{
try
{
topic = manager->retrieve("single");
break;
}
// This can happen if the replica group loses the majority
// during retrieve. In this case we retry.
catch(const Ice::UnknownException&)
{
continue;
}
catch(const IceStorm::NoSuchTopic& e)
{
cerr << argv[0] << ": NoSuchTopic: " << e.name << endl;
return EXIT_FAILURE;
}
}
int events = 1000;
if(opts.isSet("events"))
{
events = atoi(opts.optArg("events").c_str());
}
//
// Create subscribers with different QoS.
//
SingleIPtr sub;
IceStorm::QoS qos;
if(opts.isSet("ordered"))
{
sub = new SingleI(communicator, "twoway ordered", events);
qos["reliability"] = "ordered";
}
else
{
sub = new SingleI(communicator, "twoway", events);
}
Ice::ObjectPrx prx = adapter->addWithUUID(sub);
while(true)
{
try
{
topic->subscribeAndGetPublisher(qos, prx);
break;
}
// If we're already subscribed then we're done (previously we
// got an UnknownException which succeeded).
catch(const IceStorm::AlreadySubscribed&)
{
break;
}
// This can happen if the replica group loses the majority
// during subscription. In this case we retry.
catch(const Ice::UnknownException&)
{
}
}
adapter->activate();
sub->waitForEvents();
topic->unsubscribe(prx);
return EXIT_SUCCESS;
}
int
Client::run(StringSeq& originalArgs)
{
string commands;
bool debug;
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("e", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("i", "instanceName", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("H", "host", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("P", "port", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("u", "username", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("p", "password", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
opts.addOpt("S", "ssl");
opts.addOpt("d", "debug");
opts.addOpt("s", "server");
opts.addOpt("r", "replica", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::NoRepeat);
vector<string> args;
try
{
args = opts.parse(originalArgs);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << e.reason << endl;
usage();
return EXIT_FAILURE;
}
if(!args.empty())
{
cerr << _appName << ": too many arguments" << endl;
usage();
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage();
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
cout << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
if(opts.isSet("server"))
{
ObjectAdapterPtr adapter =
communicator()->createObjectAdapterWithEndpoints("FileParser", "tcp -h localhost");
adapter->activate();
ObjectPrx proxy = adapter->add(new FileParserI, communicator()->stringToIdentity("FileParser"));
cout << proxy << endl;
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
if(opts.isSet("e"))
{
vector<string> optargs = opts.argVec("e");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
commands += *i + ";";
}
}
debug = opts.isSet("debug");
bool ssl = communicator()->getProperties()->getPropertyAsInt("IceGridAdmin.AuthenticateUsingSSL");
if(opts.isSet("ssl"))
{
ssl = true;
}
string id = communicator()->getProperties()->getProperty("IceGridAdmin.Username");
if(!opts.optArg("username").empty())
{
id = opts.optArg("username");
}
string password = communicator()->getProperties()->getProperty("IceGridAdmin.Password");
if(!opts.optArg("password").empty())
{
password = opts.optArg("password");
}
string host = communicator()->getProperties()->getProperty("IceGridAdmin.Host");
if(!opts.optArg("host").empty())
{
host = opts.optArg("host");
}
string instanceName = communicator()->getProperties()->getProperty("IceGridAdmin.InstanceName");
if(!opts.optArg("instanceName").empty())
{
instanceName = opts.optArg("instanceName");
}
int port = communicator()->getProperties()->getPropertyAsInt("IceGridAdmin.Port");
if(!opts.optArg("port").empty())
{
istringstream is(opts.optArg("port"));
if(!(is >> port))
{
cerr << _appName << ": given port number is not a numeric value" << endl;
return EXIT_FAILURE;
}
}
bool
RegistryService::start(int argc, char* argv[], int& status)
{
bool nowarn;
bool readonly;
std::string initFromReplica;
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "nowarn");
opts.addOpt("", "readonly");
opts.addOpt("", "initdb-from-replica", IceUtilInternal::Options::NeedArg);
vector<string> args;
try
{
args = opts.parse(argc, const_cast<const char**>(argv));
}
catch(const IceUtilInternal::BadOptException& e)
{
error(e.reason);
usage(argv[0]);
return false;
}
if(opts.isSet("help"))
{
usage(argv[0]);
status = EXIT_SUCCESS;
return false;
}
if(opts.isSet("version"))
{
print(ICE_STRING_VERSION);
status = EXIT_SUCCESS;
return false;
}
nowarn = opts.isSet("nowarn");
readonly = opts.isSet("readonly");
if(opts.isSet("initdb-from-replica"))
{
initFromReplica = opts.optArg("initdb-from-replica");
}
if(!args.empty())
{
cerr << argv[0] << ": too many arguments" << endl;
usage(argv[0]);
return false;
}
Ice::PropertiesPtr properties = communicator()->getProperties();
//
// Warn the user that setting Ice.ThreadPool.Server isn't useful.
//
if(!nowarn && properties->getPropertyAsIntWithDefault("Ice.ThreadPool.Server.Size", 0) > 0)
{
Warning out(communicator()->getLogger());
out << "setting `Ice.ThreadPool.Server.Size' is not useful, ";
out << "you should set individual adapter thread pools instead.";
}
TraceLevelsPtr traceLevels = new TraceLevels(communicator(), "IceGrid.Registry");
_registry = new RegistryI(communicator(), traceLevels, nowarn, readonly, initFromReplica, "");
if(!_registry->start())
{
return false;
}
return true;
}
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;
}
int
run(const Ice::StringSeq& args)
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
vector<string> commands;
try
{
commands = opts.parse(args);
}
catch(const IceUtilInternal::BadOptException& e)
{
consoleErr << e.reason << endl;
usage(args[0]);
return 1;
}
if(opts.isSet("help"))
{
usage(args[0]);
return 0;
}
if(opts.isSet("version"))
{
consoleOut << ICE_STRING_VERSION << endl;
return 0;
}
if(commands.empty())
{
usage(args[0]);
return 1;
}
Ice::ObjectPrxPtr base = communicator->propertyToProxy("IceBoxAdmin.ServiceManager.Proxy");
if(base == 0)
{
//
// The old deprecated way to retrieve the service manager proxy
//
Ice::PropertiesPtr properties = communicator->getProperties();
Ice::Identity managerIdentity;
managerIdentity.category = properties->getPropertyWithDefault("IceBox.InstanceName", "IceBox");
managerIdentity.name = "ServiceManager";
string managerProxy;
if(properties->getProperty("Ice.Default.Locator").empty())
{
string managerEndpoints = properties->getProperty("IceBox.ServiceManager.Endpoints");
if(managerEndpoints.empty())
{
consoleErr << args[0] << ": property `IceBoxAdmin.ServiceManager.Proxy' is not set" << endl;
return 1;
}
managerProxy = "\"" + communicator->identityToString(managerIdentity) + "\" :" + managerEndpoints;
}
else
{
string managerAdapterId = properties->getProperty("IceBox.ServiceManager.AdapterId");
if(managerAdapterId.empty())
{
consoleErr << args[0] << ": property `IceBoxAdmin.ServiceManager.Proxy' is not set" << endl;
return 1;
}
managerProxy = "\"" + communicator->identityToString(managerIdentity) + "\" @" + managerAdapterId;
}
base = communicator->stringToProxy(managerProxy);
}
IceBox::ServiceManagerPrxPtr manager = ICE_CHECKED_CAST(IceBox::ServiceManagerPrx, base);
if(!manager)
{
consoleErr << args[0] << ": `" << base << "' is not an IceBox::ServiceManager" << endl;
return 1;
}
for(vector<string>::const_iterator r = commands.begin(); r != commands.end(); ++r)
{
if((*r) == "shutdown")
{
manager->shutdown();
}
else if((*r) == "start")
{
if(++r == commands.end())
{
consoleErr << args[0] << ": no service name specified." << endl;
return 1;
}
try
{
manager->startService(*r);
}
catch(const IceBox::NoSuchServiceException&)
{
consoleErr << args[0] << ": unknown service `" << *r << "'" << endl;
return 1;
}
catch(const IceBox::AlreadyStartedException&)
{
consoleErr << args[0] << ": service already started." << endl;
}
}
else if((*r) == "stop")
{
if(++r == commands.end())
{
consoleErr << args[0] << ": no service name specified." << endl;
return 1;
}
try
{
manager->stopService(*r);
}
catch(const IceBox::NoSuchServiceException&)
{
consoleErr << args[0] << ": unknown service `" << *r << "'" << endl;
return 1;
}
catch(const IceBox::AlreadyStoppedException&)
{
consoleErr << args[0] << ": service already stopped." << endl;
}
}
else
{
consoleErr << args[0] << ": unknown command `" << *r << "'" << endl;
usage(args[0]);
return 1;
}
}
return 0;
}
int
compile(int argc, char* argv[])
{
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("E");
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "depend");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "underscore");
opts.addOpt("", "all");
opts.addOpt("", "checksum");
opts.addOpt("n", "namespace");
vector<string> args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
getErrorStream() << argv[0] << ": error: " << e.reason << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
getErrorStream() << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
vector<string>::const_iterator i;
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
vector<string> includePaths = opts.argVec("I");
for(i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
bool preprocess = opts.isSet("E");
string output = opts.optArg("output-dir");
bool depend = opts.isSet("depend");
bool debug = opts.isSet("debug");
bool ice = opts.isSet("ice");
bool underscore = opts.isSet("underscore");
bool all = opts.isSet("all");
bool checksum = opts.isSet("checksum");
bool ns = opts.isSet("namespace");
if(args.empty())
{
getErrorStream() << argv[0] << ": error: no input file" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
int status = EXIT_SUCCESS;
IceUtil::CtrlCHandler ctrlCHandler;
ctrlCHandler.setCallback(interruptedCallback);
for(i = args.begin(); i != args.end(); ++i)
{
//
// Ignore duplicates.
//
vector<string>::iterator p = find(args.begin(), args.end(), *i);
if(p != i)
{
continue;
}
if(depend)
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(false);
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
UnitPtr u = Unit::createUnit(false, false, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
u->destroy();
if(parseStatus == EXIT_FAILURE)
{
return EXIT_FAILURE;
}
if(!icecpp->printMakefileDependencies(Preprocessor::PHP, includePaths))
{
return EXIT_FAILURE;
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(false);
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
if(preprocess)
{
char buf[4096];
while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
{
if(fputs(buf, stdout) == EOF)
{
return EXIT_FAILURE;
}
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
UnitPtr u = Unit::createUnit(false, all, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
if(!icecpp->close())
{
u->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
status = EXIT_FAILURE;
}
else
{
string base = icecpp->getBaseName();
string::size_type pos = base.find_last_of("/\\");
if(pos != string::npos)
{
base.erase(0, pos + 1);
}
string file = base + ".php";
if(!output.empty())
{
file = output + '/' + file;
}
try
{
IceUtilInternal::Output out;
out.open(file.c_str());
if(!out)
{
ostringstream os;
os << "cannot open`" << file << "': " << strerror(errno);
throw FileException(__FILE__, __LINE__, os.str());
}
FileTracker::instance()->addFile(file);
out << "<?php\n";
printHeader(out);
printGeneratedHeader(out, base + ".ice");
//
// Generate the PHP mapping.
//
generate(u, all, checksum, ns, includePaths, out);
out << "?>\n";
out.close();
}
catch(const Slice::FileException& ex)
{
// If a file could not be created, then cleanup any
// created files.
FileTracker::instance()->cleanup();
u->destroy();
getErrorStream() << argv[0] << ": error: " << ex.reason() << endl;
return EXIT_FAILURE;
}
catch(const string& err)
{
FileTracker::instance()->cleanup();
getErrorStream() << argv[0] << ": error: " << err << endl;
status = EXIT_FAILURE;
}
}
u->destroy();
}
}
{
IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(mutex);
if(interrupted)
{
FileTracker::instance()->cleanup();
return EXIT_FAILURE;
}
}
}
return status;
}
int
compile(int argc, char* argv[])
{
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("E");
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "depend");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "underscore");
opts.addOpt("", "all");
opts.addOpt("", "no-package");
opts.addOpt("", "checksum");
opts.addOpt("", "prefix", IceUtilInternal::Options::NeedArg);
vector<string> args;
try
{
args = opts.parse(argc, (const char**)argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
getErrorStream() << argv[0] << ": error: " << e.reason << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
getErrorStream() << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
vector<string> includePaths = opts.argVec("I");
for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
bool preprocess = opts.isSet("E");
string output = opts.optArg("output-dir");
bool depend = opts.isSet("depend");
bool debug = opts.isSet("debug");
bool ice = opts.isSet("ice");
bool underscore = opts.isSet("underscore");
bool all = opts.isSet("all");
bool noPackage = opts.isSet("no-package");
bool checksum = opts.isSet("checksum");
string prefix = opts.optArg("prefix");
if(args.empty())
{
getErrorStream() << argv[0] << ": error: no input file" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
int status = EXIT_SUCCESS;
IceUtil::CtrlCHandler ctrlCHandler;
ctrlCHandler.setCallback(interruptedCallback);
bool keepComments = true;
for(vector<string>::const_iterator i = args.begin(); i != args.end(); ++i)
{
//
// Ignore duplicates.
//
vector<string>::iterator p = find(args.begin(), args.end(), *i);
if(p != i)
{
continue;
}
if(depend)
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(false, "-D__SLICE2PY__");
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
UnitPtr u = Unit::createUnit(false, false, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
u->destroy();
if(parseStatus == EXIT_FAILURE)
{
return EXIT_FAILURE;
}
if(!icecpp->printMakefileDependencies(Preprocessor::Python, includePaths,
"-D__SLICE2PY__", "", prefix))
{
return EXIT_FAILURE;
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(keepComments, "-D__SLICE2PY__");
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
if(preprocess)
{
char buf[4096];
while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
{
if(fputs(buf, stdout) == EOF)
{
return EXIT_FAILURE;
}
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
UnitPtr u = Unit::createUnit(false, all, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
if(!icecpp->close())
{
u->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
status = EXIT_FAILURE;
}
else
{
string base = icecpp->getBaseName();
string::size_type pos = base.find_last_of("/\\");
if(pos != string::npos)
{
base.erase(0, pos + 1);
}
//
// Append the suffix "_ice" to the filename in order to avoid any conflicts
// with Slice module names. For example, if the file Test.ice defines a
// Slice module named "Test", then we couldn't create a Python package named
// "Test" and also call the generated file "Test.py".
//
string file = prefix + base + "_ice.py";
if(!output.empty())
{
file = output + '/' + file;
}
try
{
IceUtilInternal::Output out;
out.open(file.c_str());
if(!out)
{
ostringstream os;
os << "cannot open`" << file << "': " << strerror(errno);
throw FileException(__FILE__, __LINE__, os.str());
}
FileTracker::instance()->addFile(file);
printHeader(out);
printGeneratedHeader(out, base + ".ice", "#");
//
// Generate the Python mapping.
//
generate(u, all, checksum, includePaths, out);
out.close();
//
// Create or update the Python package hierarchy.
//
if(!noPackage)
{
PackageVisitor::createModules(u, prefix + base + "_ice", output);
}
}
catch(const Slice::FileException& ex)
{
// If a file could not be created, then cleanup any
// created files.
FileTracker::instance()->cleanup();
u->destroy();
getErrorStream() << argv[0] << ": error: " << ex.reason() << endl;
return EXIT_FAILURE;
}
catch(const string& err)
{
FileTracker::instance()->cleanup();
getErrorStream() << argv[0] << ": error: " << err << endl;
status = EXIT_FAILURE;
}
}
u->destroy();
}
}
{
IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(globalMutex);
if(interrupted)
{
FileTracker::instance()->cleanup();
return EXIT_FAILURE;
}
}
}
return status;
}
int
main(int argc, char* argv[])
{
vector<string> cppArgs;
//bool preprocess;
//string include;
//string output;
//string dllExport;
//bool impl;
//bool depend;
//bool debug;
//bool ice;
//bool checksum;
//bool stream;
//bool caseSensitive;
string inputFilename;
#ifdef false
po::variables_map vm;
//try
//{
po::options_description hidden("Hidden options");
hidden.add_options()
("input-file", po::value< vector<string> >(), "input file")
;
po::options_description allowed("Allowed options");
allowed.add_options()
("help", "produce help message")
("output", po::value<std::string>(), "output file name")
;
po::options_description cmdline("Command line options");
cmdline.add(allowed).add(hidden);
po::positional_options_description p;
p.add("input-file", -1);
po::store(po::command_line_parser(argc, argv).
options(cmdline).positional(p).run(), vm);
po::notify(vm);
if (vm.count("help"))
{
cout << allowed << "\n";
return 1;
}
if ( vm.count("input-file"))
{
vector<string> sv = vm["input-file"].as<vector<string> >();
//for (vector<string>::iterator i=sv.begin(); i!=sv.end(); i++)
//{
//cout << *i << "\n";
//}
inputFilename = sv[0];
}
if (vm.count("output"))
{
cout << "Output filename is " << vm["output"].as<std::string>() << "\n";
}
//}
//catch(...)
//{
//cout << "CRAP!\n";
//}
cout << "Input file is \"" << inputFilename << "\"\n";
#endif
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "",
IceUtilInternal::Options::Repeat);
vector<string> args;
try
{
args = opts.parse(argc, argv);
}
catch(const IceUtilInternal::BadOptException& e)
{
cerr << argv[0] << ": " << e.reason << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
if(opts.isSet("h") || opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
vector<string> includePaths;
includePaths = opts.argVec("I");
for (vector<string>::const_iterator i=includePaths.begin(); i!=includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
if(args.empty())
{
cerr << argv[0] << ": no input file" << endl;
usage(argv[0]);
return EXIT_FAILURE;
}
int status = EXIT_SUCCESS;
vector<string>::const_iterator i = args.begin();
std::string filename = *i;
#if ICE_INT_VERSION / 100 < 304
Preprocessor* icecpp = new Preprocessor(argv[0], *i, cppArgs);
#else
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
#endif
FILE* cppHandle = icecpp->preprocess(true);
if (cppHandle == 0)
{
return EXIT_FAILURE;
}
//#if ICE_INT_VERSION / 100 < 304
bool ignRedefs = false;
bool all = false;
bool allowIcePrefix = false;
bool caseSensitive = true;
//StringList defaultGlobalMetadata;
UnitPtr u = Unit::createUnit(ignRedefs, all, allowIcePrefix, caseSensitive);
//#else
// UnitPtr u = Unit::createUnit(false, false, false);
//#endif
int parseStatus = u->parse(*i, cppHandle, false);
if ( parseStatus == EXIT_FAILURE )
{
cerr << "Parsing failed";
exit(0);
}
if(!icecpp->close())
{
u->destroy();
return EXIT_FAILURE;
}
BasicClassLinkHandler linker;
RstGen rstGen(linker);
u->visit(&rstGen, true);
u->destroy();
return status;
}
int
compile(int argc, char* argv[])
{
IceUtilInternal::Options opts;
opts.addOpt("h", "help");
opts.addOpt("v", "version");
opts.addOpt("", "validate");
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("E");
opts.addOpt("", "output-dir", IceUtilInternal::Options::NeedArg);
opts.addOpt("", "tie");
opts.addOpt("", "impl");
opts.addOpt("", "impl-tie");
opts.addOpt("", "depend");
opts.addOpt("", "depend-xml");
opts.addOpt("", "depend-file", IceUtilInternal::Options::NeedArg, "");
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "underscore");
opts.addOpt("", "checksum");
bool validate = false;
for(int i = 0; i < argc; ++i)
{
if(string(argv[i]) == "--validate")
{
validate = true;
break;
}
}
vector<string> args;
try
{
args = opts.parse(argc, const_cast<const char**>(argv));
}
catch(const IceUtilInternal::BadOptException& e)
{
getErrorStream() << argv[0] << ": error: " << e.reason << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(opts.isSet("help"))
{
usage(argv[0]);
return EXIT_SUCCESS;
}
if(opts.isSet("version"))
{
getErrorStream() << ICE_STRING_VERSION << endl;
return EXIT_SUCCESS;
}
vector<string> cppArgs;
vector<string> optargs = opts.argVec("D");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
optargs = opts.argVec("U");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
vector<string> includePaths = opts.argVec("I");
for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + Preprocessor::normalizeIncludePath(*i));
}
bool preprocess = opts.isSet("E");
string output = opts.optArg("output-dir");
bool tie = opts.isSet("tie");
bool impl = opts.isSet("impl");
bool implTie = opts.isSet("impl-tie");
bool depend = opts.isSet("depend");
bool dependxml = opts.isSet("depend-xml");
string dependFile = opts.optArg("depend-file");
bool debug = opts.isSet("debug");
bool ice = opts.isSet("ice");
bool underscore = opts.isSet("underscore");
bool checksum = opts.isSet("checksum");
if(args.empty())
{
getErrorStream() << argv[0] << ": error: no input file" << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(impl && implTie)
{
getErrorStream() << argv[0] << ": error: cannot specify both --impl and --impl-tie" << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(depend && dependxml)
{
getErrorStream() << argv[0] << ": error: cannot specify both --depend and --depend-xml" << endl;
if(!validate)
{
usage(argv[0]);
}
return EXIT_FAILURE;
}
if(validate)
{
return EXIT_SUCCESS;
}
int status = EXIT_SUCCESS;
IceUtil::CtrlCHandler ctrlCHandler;
ctrlCHandler.setCallback(interruptedCallback);
DependOutputUtil out(dependFile);
if(dependxml)
{
out.os() << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<dependencies>" << endl;
}
for(vector<string>::const_iterator i = args.begin(); i != args.end(); ++i)
{
//
// Ignore duplicates.
//
vector<string>::iterator p = find(args.begin(), args.end(), *i);
if(p != i)
{
continue;
}
if(depend || dependxml)
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(false, "-D__SLICE2CS__");
if(cppHandle == 0)
{
out.cleanup();
return EXIT_FAILURE;
}
UnitPtr u = Unit::createUnit(false, false, ice, underscore);
int parseStatus = u->parse(*i, cppHandle, debug);
u->destroy();
if(parseStatus == EXIT_FAILURE)
{
out.cleanup();
return EXIT_FAILURE;
}
if(!icecpp->printMakefileDependencies(out.os(), depend ? Preprocessor::CSharp : Preprocessor::SliceXML, includePaths,
"-D__SLICE2CS__"))
{
out.cleanup();
return EXIT_FAILURE;
}
if(!icecpp->close())
{
out.cleanup();
return EXIT_FAILURE;
}
}
else
{
PreprocessorPtr icecpp = Preprocessor::create(argv[0], *i, cppArgs);
FILE* cppHandle = icecpp->preprocess(true, "-D__SLICE2CS__");
if(cppHandle == 0)
{
return EXIT_FAILURE;
}
if(preprocess)
{
char buf[4096];
while(fgets(buf, static_cast<int>(sizeof(buf)), cppHandle) != NULL)
{
if(fputs(buf, stdout) == EOF)
{
return EXIT_FAILURE;
}
}
if(!icecpp->close())
{
return EXIT_FAILURE;
}
}
else
{
UnitPtr p = Unit::createUnit(false, false, ice, underscore);
int parseStatus = p->parse(*i, cppHandle, debug);
if(!icecpp->close())
{
p->destroy();
return EXIT_FAILURE;
}
if(parseStatus == EXIT_FAILURE)
{
status = EXIT_FAILURE;
}
else
{
try
{
Gen gen(icecpp->getBaseName(), includePaths, output, impl, implTie);
gen.generate(p);
if(tie)
{
gen.generateTie(p);
}
if(impl)
{
gen.generateImpl(p);
}
if(implTie)
{
gen.generateImplTie(p);
}
if(checksum)
{
gen.generateChecksums(p);
}
}
catch(const Slice::FileException& ex)
{
// If a file could not be created, then
// cleanup any created files.
FileTracker::instance()->cleanup();
p->destroy();
getErrorStream() << argv[0] << ": error: " << ex.reason() << endl;
return EXIT_FAILURE;
}
}
p->destroy();
}
}
{
IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(globalMutex);
if(interrupted)
{
out.cleanup();
FileTracker::instance()->cleanup();
return EXIT_FAILURE;
}
}
}
if(dependxml)
{
out.os() << "</dependencies>\n";
}
return status;
}