int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
Ice::ObjectFactoryPtr factory = new MyObjectFactory;
communicator->addObjectFactory(factory, "::Test::B");
communicator->addObjectFactory(factory, "::Test::C");
communicator->addObjectFactory(factory, "::Test::D");
communicator->addObjectFactory(factory, "::Test::E");
communicator->addObjectFactory(factory, "::Test::F");
communicator->addObjectFactory(factory, "::Test::I");
communicator->addObjectFactory(factory, "::Test::J");
communicator->addObjectFactory(factory, "::Test::H");
communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
InitialPtr initial = new InitialI(adapter);
adapter->add(initial, communicator->stringToIdentity("initial"));
UnexpectedObjectExceptionTestIPtr uoet = new UnexpectedObjectExceptionTestI;
adapter->add(uoet, communicator->stringToIdentity("uoet"));
InitialPrx allTests(const Ice::CommunicatorPtr&);
allTests(communicator);
// We must call shutdown even in the collocated case for cyclic dependency cleanup
initial->shutdown(Ice::Current());
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
#ifdef ICE_CPP11_MAPPING
communicator->getValueFactoryManager()->add(makeFactory<BI>(), "::Test::B");
communicator->getValueFactoryManager()->add(makeFactory<CI>(), "::Test::C");
communicator->getValueFactoryManager()->add(makeFactory<DI>(), "::Test::D");
communicator->getValueFactoryManager()->add(makeFactory<EI>(), "::Test::E");
communicator->getValueFactoryManager()->add(makeFactory<FI>(), "::Test::F");
communicator->getValueFactoryManager()->add(makeFactory<II>(), "::Test::I");
communicator->getValueFactoryManager()->add(makeFactory<JI>(), "::Test::J");
communicator->getValueFactoryManager()->add(makeFactory<HI>(), "::Test::H");
communicator->addObjectFactory(make_shared<MyObjectFactory>(), "TestOF");
#else
Ice::ValueFactoryPtr factory = new MyValueFactory;
communicator->getValueFactoryManager()->add(factory, "::Test::B");
communicator->getValueFactoryManager()->add(factory, "::Test::C");
communicator->getValueFactoryManager()->add(factory, "::Test::D");
communicator->getValueFactoryManager()->add(factory, "::Test::E");
communicator->getValueFactoryManager()->add(factory, "::Test::F");
communicator->getValueFactoryManager()->add(factory, "::Test::I");
communicator->getValueFactoryManager()->add(factory, "::Test::J");
communicator->getValueFactoryManager()->add(factory, "::Test::H");
communicator->addObjectFactory(new MyObjectFactory(), "TestOF");
#endif
InitialPrxPtr allTests(const Ice::CommunicatorPtr&);
InitialPrxPtr initial = allTests(communicator);
initial->shutdown();
return EXIT_SUCCESS;
}
int
run(const Ice::CommunicatorPtr& communicator, const string& envName, const string& dbName)
{
Ice::ObjectFactoryPtr factory = new Factory;
communicator->addObjectFactory(factory, "");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("");
Freeze::EvictorPtr evictor = Freeze::createEvictor(adapter, envName, dbName);
for(int i = 0; i < 10; ++i)
{
string facetName = "theFacet";
Ice::Identity id;
ostringstream ostr;
ostr << "mainObject" << i;
id.name = ostr.str();
if((i % 2) == 0)
{
MainObjectPtr obj = new MainObjectI;
obj->boolToString = true;
obj->byteToShort = 0;
obj->shortToByte = 255;
obj->intToShort = 32767;
obj->longToInt = 2147483647;
obj->floatToString = 4567.8f;
obj->doubleToFloat = 8765.4;
obj->stringToEnum = "E1";
obj->renamed = E2;
evictor->add(obj, id);
FacetObjectPtr facet = new FacetObjectI;
facet->doubleToString = 901234.5;
evictor->addFacet(facet, id, facetName);
}
else
{
DerivedMainObjectPtr obj = new DerivedMainObjectI;
obj->boolToString = false;
obj->byteToShort = 0;
obj->shortToByte = -1;
obj->intToShort = -32768;
obj->longToInt = -2147483647 - 1;
obj->floatToString = -4567.8f;
obj->doubleToFloat = -8765.4;
obj->stringToEnum = "E3";
obj->renamed = E1;
obj->name = id.name;
evictor->add(obj, id);
DerivedFacetObjectPtr facet = new DerivedFacetObjectI;
facet->doubleToString = -901234.5;
facet->count = i;
evictor->addFacet(facet, id, facetName);
}
}
evictor->deactivate("");
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
Ice::ObjectFactoryPtr factory = new MyObjectFactory;
communicator->addObjectFactory(factory, "::Test::B");
communicator->addObjectFactory(factory, "::Test::C");
communicator->addObjectFactory(factory, "::Test::D");
communicator->addObjectFactory(factory, "::Test::E");
communicator->addObjectFactory(factory, "::Test::F");
communicator->addObjectFactory(factory, "::Test::I");
communicator->addObjectFactory(factory, "::Test::J");
communicator->addObjectFactory(factory, "::Test::H");
InitialPrx allTests(const Ice::CommunicatorPtr&);
InitialPrx initial = allTests(communicator);
initial->shutdown();
return EXIT_SUCCESS;
}
int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator, const string& envName)
{
communicator->getProperties()->setProperty("Factory.Endpoints", "default -p 12010");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("Factory");
communicator->addObjectFactory(new ServantFactory, "::Test::Servant");
communicator->addObjectFactory(new FacetFactory, "::Test::Facet");
communicator->addObjectFactory(new AccountFactory, "::Test::Account");
Test::RemoteEvictorFactoryPtr factory = new Test::RemoteEvictorFactoryI(envName);
adapter->add(factory, communicator->stringToIdentity("factory"));
adapter->activate();
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
Ice::ObjectFactoryPtr factory = new MyObjectFactory;
communicator->addObjectFactory(factory, "::Test::I");
communicator->addObjectFactory(factory, "::Test::J");
communicator->addObjectFactory(factory, "::Test::H");
communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
InitialPtr initial = new InitialI(adapter);
adapter->add(initial, communicator->stringToIdentity("initial"));
UnexpectedObjectExceptionTestIPtr uoet = new UnexpectedObjectExceptionTestI;
adapter->add(uoet, communicator->stringToIdentity("uoet"));
adapter->activate();
TEST_READY
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
static int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator, Complex::ComplexDict& m)
{
//
// Register a factory for the node types.
//
Ice::ObjectFactoryPtr factory = new Complex::ObjectFactoryI;
communicator->addObjectFactory(factory, "::Complex::NumberNode");
communicator->addObjectFactory(factory, "::Complex::AddNode");
communicator->addObjectFactory(factory, "::Complex::MultiplyNode");
if(argc > 1 && strcmp(argv[1], "populate") == 0)
{
return populate(m);
}
if(argc > 1 && strcmp(argv[1], "validate") == 0)
{
return validate(m);
}
usage(argv[0]);
return EXIT_FAILURE;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
#ifdef ICE_CPP11_MAPPING
communicator->getValueFactoryManager()->add(makeFactory<BI>(), "::Test::B");
communicator->getValueFactoryManager()->add(makeFactory<CI>(), "::Test::C");
communicator->getValueFactoryManager()->add(makeFactory<DI>(), "::Test::D");
communicator->getValueFactoryManager()->add(makeFactory<EI>(), "::Test::E");
communicator->getValueFactoryManager()->add(makeFactory<FI>(), "::Test::F");
communicator->getValueFactoryManager()->add(makeFactory<II>(), "::Test::I");
communicator->getValueFactoryManager()->add(makeFactory<JI>(), "::Test::J");
communicator->getValueFactoryManager()->add(makeFactory<HI>(), "::Test::H");
communicator->addObjectFactory(make_shared<MyObjectFactory>(), "TestOF");
#else
Ice::ValueFactoryPtr factory = new MyValueFactory;
communicator->getValueFactoryManager()->add(factory, "::Test::B");
communicator->getValueFactoryManager()->add(factory, "::Test::C");
communicator->getValueFactoryManager()->add(factory, "::Test::D");
communicator->getValueFactoryManager()->add(factory, "::Test::E");
communicator->getValueFactoryManager()->add(factory, "::Test::F");
communicator->getValueFactoryManager()->add(factory, "::Test::I");
communicator->getValueFactoryManager()->add(factory, "::Test::J");
communicator->getValueFactoryManager()->add(factory, "::Test::H");
communicator->addObjectFactory(new MyObjectFactory(), "TestOF");
#endif
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(InitialI, adapter), communicator->stringToIdentity("initial"));
adapter->add(ICE_MAKE_SHARED(TestIntfI), communicator->stringToIdentity("test"));
adapter->add(ICE_MAKE_SHARED(UnexpectedObjectExceptionTestI), communicator->stringToIdentity("uoet"));
InitialPrxPtr allTests(const Ice::CommunicatorPtr&);
InitialPrxPtr initial = allTests(communicator);
// We must call shutdown even in the collocated case for cyclic dependency cleanup
initial->shutdown();
return EXIT_SUCCESS;
}
ThrowerPrx
allTests(const Ice::CommunicatorPtr& communicator)
{
cout << "testing ice_print()/what()... " << flush;
{
A a;
string aMsg = "Test::A";
Ice::UnknownLocalException ule("thisFile", 99);
string uleMsg = "thisFile:99: Ice::UnknownLocalException:\nunknown local exception";
//
// Test ice_print().
//
{
stringstream str;
a.ice_print(str);
test(str.str() == aMsg);
}
{
stringstream str;
ule.ice_print(str);
test(str.str() == uleMsg);
}
//
// Test operator<<().
//
{
stringstream str;
str << a;
test(str.str() == aMsg);
}
{
stringstream str;
str << ule;
test(str.str() == uleMsg);
}
//
// Test what(). (Called twice because of lazy initialization in what().)
//
test(aMsg == a.what());
test(aMsg == a.what());
test(uleMsg == ule.what());
test(uleMsg == ule.what());
{
E ex("E");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::E");
test(ex.data == "E");
}
//
// Test custom ice_print
//
{
F ex("F");
ostringstream os;
ex.ice_print(os);
test(os.str() == "Test::F data:'F'");
test(ex.data == "F");
}
{
G ex(__FILE__, __LINE__, "G");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::G"));
test(ex.data == "G");
}
{
H ex(__FILE__, __LINE__, "H");
ostringstream os;
ex.ice_print(os);
test(endsWith(os.str(), "Test::H data:'H'"));
test(ex.data == "H");
}
}
cout << "ok" << endl;
cout << "testing object adapter registration exceptions... " << flush;
{
Ice::ObjectAdapterPtr first;
try
{
first = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::InitializationException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter0.Endpoints", "default -h " + host);
first = communicator->createObjectAdapter("TestAdapter0");
try
{
Ice::ObjectAdapterPtr second = communicator->createObjectAdapter("TestAdapter0");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected
}
try
{
Ice::ObjectAdapterPtr second =
communicator->createObjectAdapterWithEndpoints("TestAdapter0", "ssl -h foo -p 12011");
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
// Expected.
}
first->deactivate();
}
cout << "ok" << endl;
cout << "testing servant registration exceptions... " << flush;
{
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter1.Endpoints", "default -h " + host);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter1");
Ice::ObjectPtr obj = new EmptyI;
adapter->add(obj, communicator->stringToIdentity("x"));
try
{
adapter->add(obj, communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::AlreadyRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(obj, communicator->stringToIdentity(""));
}
catch(const Ice::IllegalIdentityException& ex)
{
test(ex.id.name == "");
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
try
{
adapter->add(0, communicator->stringToIdentity("x"));
}
catch(const Ice::IllegalServantException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->remove(communicator->stringToIdentity("x"));
try
{
adapter->remove(communicator->stringToIdentity("x"));
test(false);
}
catch(const Ice::NotRegisteredException& ex)
{
if(printException)
{
Ice::Print printer(communicator->getLogger());
printer << ex;
}
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing servant locator registrations exceptions... " << flush;
{
string host = communicator->getProperties()->getPropertyAsIntWithDefault("Ice.IPv6", 0) == 0 ?
"127.0.0.1" : "\"0:0:0:0:0:0:0:1\"";
communicator->getProperties()->setProperty("TestAdapter2.Endpoints", "default -h " + host);
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter2");
Ice::ServantLocatorPtr loc = new ServantLocatorI;
adapter->addServantLocator(loc, "x");
try
{
adapter->addServantLocator(loc, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
adapter->deactivate();
}
cout << "ok" << endl;
cout << "testing object factory registration exception... " << flush;
{
Ice::ObjectFactoryPtr of = new ObjectFactoryI;
communicator->addObjectFactory(of, "x");
try
{
communicator->addObjectFactory(of, "x");
test(false);
}
catch(const Ice::AlreadyRegisteredException&)
{
}
}
cout << "ok" << endl;
cout << "testing stringToProxy... " << flush;
string ref = "thrower:default -p 12010";
Ice::ObjectPrx base = communicator->stringToProxy(ref);
test(base);
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
ThrowerPrx thrower = ThrowerPrx::checkedCast(base);
test(thrower);
test(thrower == base);
cout << "ok" << endl;
cout << "catching exact types... " << flush;
try
{
thrower->throwAasA(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(1);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwAorDasAorD(-1);
test(false);
}
catch(const D& ex)
{
test(ex.dMem == -1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const Mod::A& ex)
{
test(ex.aMem == 1);
test(ex.a2Mem == 2);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching base types... " << flush;
try
{
thrower->throwBasB(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasC(1, 2, 3);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwModA(1, 2);
test(false);
}
catch(const A& ex)
{
test(ex.aMem == 1);
}
catch(const Ice::OperationNotExistException&)
{
//
// This operation is not supported in Java.
//
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching derived types... " << flush;
try
{
thrower->throwBasA(1, 2);
test(false);
}
catch(const B& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasA(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
try
{
thrower->throwCasB(1, 2, 3);
test(false);
}
catch(const C& ex)
{
test(ex.aMem == 1);
test(ex.bMem == 2);
test(ex.cMem == 3);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception... " << flush;
try
{
thrower->throwUndeclaredA(1);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(const Ice::Exception& ex)
{
cout << ex << endl;
cout << ex.ice_stackTrace() << endl;
test(false);
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredB(1, 2);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwUndeclaredC(1, 2, 3);
test(false);
}
catch(const Ice::UnknownUserException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
}
if(thrower->ice_getConnection())
{
cout << "testing memory limit marshal exception..." << flush;
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq());
test(false);
}
catch(const Ice::MemoryLimitException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwMemoryLimitException(Ice::ByteSeq(20 * 1024)); // 20KB
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
catch(const Ice::LocalException& ex)
{
cerr << ex << endl;
test(false);
}
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(communicator->stringToProxy("thrower:default -p 12011"));
try
{
thrower2->throwMemoryLimitException(Ice::ByteSeq(2 * 1024 * 1024)); // 2MB (no limits)
}
catch(const Ice::MemoryLimitException&)
{
}
ThrowerPrx thrower3 = ThrowerPrx::uncheckedCast(communicator->stringToProxy("thrower:default -p 12012"));
try
{
thrower3->throwMemoryLimitException(Ice::ByteSeq(1024)); // 1KB limit
test(false);
}
catch(const Ice::ConnectionLostException&)
{
}
cout << "ok" << endl;
}
cout << "catching object not exist exception... " << flush;
Ice::Identity id = communicator->stringToIdentity("does not exist");
try
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower->ice_identity(id));
thrower2->throwAasA(1);
// thrower2->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException& ex)
{
test(ex.id == id);
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching facet not exist exception... " << flush;
try
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
try
{
thrower2->ice_ping();
test(false);
}
catch(const Ice::FacetNotExistException& ex)
{
test(ex.facet == "no such facet");
}
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching operation not exist exception... " << flush;
try
{
WrongOperationPrx thrower2 = WrongOperationPrx::uncheckedCast(thrower);
thrower2->noSuchOperation();
test(false);
}
catch(const Ice::OperationNotExistException& ex)
{
test(ex.operation == "noSuchOperation");
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown local exception... " << flush;
try
{
thrower->throwLocalException();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(...)
{
test(false);
}
try
{
thrower->throwLocalExceptionIdempotent();
test(false);
}
catch(const Ice::UnknownLocalException&)
{
}
catch(const Ice::OperationNotExistException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching unknown non-Ice exception... " << flush;
try
{
thrower->throwNonIceException();
test(false);
}
catch(const Ice::UnknownException&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "testing asynchronous exceptions... " << flush;
try
{
thrower->throwAfterResponse();
}
catch(...)
{
test(false);
}
try
{
thrower->throwAfterException();
}
catch(const A&)
{
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "catching exact types with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasA);
thrower->begin_throwAasA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwAorDasAorDPtr callback =
newCallback_Thrower_throwAorDasAorD(cb, &Callback::response, &Callback::exception_AorDasAorD);
thrower->begin_throwAorDasAorD(-1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasBPtr callback =
newCallback_Thrower_throwBasB(cb, &Callback::response, &Callback::exception_BasB);
thrower->begin_throwBasB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasCPtr callback =
newCallback_Thrower_throwCasC(cb, &Callback::response, &Callback::exception_CasC);
thrower->begin_throwCasC(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwModAPtr callback =
newCallback_Thrower_throwModA(cb, &Callback::response, &Callback::exception_ModA);
thrower->begin_throwModA(1, 2, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching derived types with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwBasAPtr callback =
newCallback_Thrower_throwBasA(cb, &Callback::response, &Callback::exception_BasA);
thrower->begin_throwBasA(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasAPtr callback =
newCallback_Thrower_throwCasA(cb, &Callback::response, &Callback::exception_CasA);
thrower->begin_throwCasA(1, 2, 3, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwCasBPtr callback =
newCallback_Thrower_throwCasB(cb, &Callback::response, &Callback::exception_CasB);
thrower->begin_throwCasB(1, 2, 3, callback);
cb->check();
}
cout << "ok" << endl;
if(thrower->supportsUndeclaredExceptions())
{
cout << "catching unknown user exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredAPtr callback =
newCallback_Thrower_throwUndeclaredA(cb, &Callback::response, &Callback::exception_UndeclaredA);
thrower->begin_throwUndeclaredA(1, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredBPtr callback =
newCallback_Thrower_throwUndeclaredB(cb, &Callback::response, &Callback::exception_UndeclaredB);
thrower->begin_throwUndeclaredB(1, 2, callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwUndeclaredCPtr callback =
newCallback_Thrower_throwUndeclaredC(cb, &Callback::response, &Callback::exception_UndeclaredC);
thrower->begin_throwUndeclaredC(1, 2, 3, callback);
cb->check();
}
cout << "ok" << endl;
}
cout << "catching object not exist exception with new AMI mapping... " << flush;
{
id = communicator->stringToIdentity("does not exist");
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower->ice_identity(id));
CallbackPtr cb = new Callback(communicator);
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAObjectNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching facet not exist exception with new AMI mapping... " << flush;
{
ThrowerPrx thrower2 = ThrowerPrx::uncheckedCast(thrower, "no such facet");
CallbackPtr cb = new Callback;
Callback_Thrower_throwAasAPtr callback =
newCallback_Thrower_throwAasA(cb, &Callback::response, &Callback::exception_AasAFacetNotExist);
thrower2->begin_throwAasA(1, callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching operation not exist exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_WrongOperation_noSuchOperationPtr callback =
newCallback_WrongOperation_noSuchOperation(cb, &Callback::response,
&Callback::exception_noSuchOperation);
WrongOperationPrx thrower4 = WrongOperationPrx::uncheckedCast(thrower);
thrower4->begin_noSuchOperation(callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching unknown local exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionPtr callback =
newCallback_Thrower_throwLocalException(cb, &Callback::response, &Callback::exception_LocalException);
thrower->begin_throwLocalException(callback);
cb->check();
}
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwLocalExceptionIdempotentPtr callback =
newCallback_Thrower_throwLocalExceptionIdempotent(cb, &Callback::response,
&Callback::exception_LocalException);
thrower->begin_throwLocalExceptionIdempotent(callback);
cb->check();
}
cout << "ok" << endl;
cout << "catching unknown non-Ice exception with new AMI mapping... " << flush;
{
CallbackPtr cb = new Callback;
Callback_Thrower_throwNonIceExceptionPtr callback =
newCallback_Thrower_throwNonIceException(cb, &Callback::response, &Callback::exception_NonIceException);
thrower->begin_throwNonIceException(callback);
cb->check();
}
cout << "ok" << endl;
return thrower;
}
void ObjectFactory::register_(const Ice::CommunicatorPtr& ic) {
ic->addObjectFactory(this, this->id);
}
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;
}
static int
run(const Ice::StringSeq& originalArgs, const Ice::CommunicatorPtr& communicator)
{
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))
{
return EXIT_FAILURE;
}
FreezeScript::createEvictorSliceTypes(unit);
//
// 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 evictorValueTypeName = "::Freeze::ObjectRecord";
if((!keyTypeName.empty() && valueTypeName.empty()) || (keyTypeName.empty() && !valueTypeName.empty()))
{
cerr << appName << ": a key type and a value type must be specified" << endl;
usage(appName);
return EXIT_FAILURE;
}
else if(!evictor && keyTypeName.empty() && 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;
}
else
{
keyTypeName = p->second.key;
valueTypeName = p->second.value;
}
}
}
catch(const FreezeScript::FailureException& ex)
{
cerr << appName << ": " << ex.reason() << endl;
return EXIT_FAILURE;
}
}
if(evictor)
{
keyTypeName = evictorKeyTypeName;
valueTypeName = evictorValueTypeName;
}
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())
{
//
// 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 << endl;
of.close();
return EXIT_SUCCESS;
}
}
else
{
//
// 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();
}
FreezeScript::ObjectFactoryPtr objectFactory = new FreezeScript::ObjectFactory;
communicator->addObjectFactory(objectFactory, "");
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, objectFactory);
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(0, &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;
}