void
Server::run(int argc, char** argv)
{
#ifdef ICE_STATIC_LIBS
Ice::registerIceDiscovery();
#endif
Ice::CommunicatorHolder communicator = initialize(argc, argv);
Ice::PropertiesPtr properties = communicator->getProperties();
int num = argc == 2 ? atoi(argv[1]) : 0;
properties->setProperty("ControlAdapter.Endpoints", getTestEndpoint(num));
{
ostringstream os;
os << "control" << num;
properties->setProperty("ControlAdapter.AdapterId", os.str());
}
properties->setProperty("ControlAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ControlAdapter");
{
ostringstream os;
os << "controller" << num;
adapter->add(ICE_MAKE_SHARED(ControllerI), Ice::stringToIdentity(os.str()));
}
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
setProcessStringConverter(ICE_MAKE_SHARED(Test::StringConverterI));
setProcessWstringConverter(ICE_MAKE_SHARED(Test::WstringConverterI));
Ice::CommunicatorHolder communicator = initialize(argc, argv);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TestIntfI), Ice::stringToIdentity("TEST"));
adapter->add(ICE_MAKE_SHARED(Test1::WstringClassI), Ice::stringToIdentity("WSTRING1"));
adapter->add(ICE_MAKE_SHARED(Test2::WstringClassI), Ice::stringToIdentity("WSTRING2"));
adapter->activate();
serverReady();
communicator->waitForShutdown();
}
void
Server::run(int argc, char** argv)
{
Ice::PropertiesPtr properties = createTestProperties(argc, argv);
#if TARGET_OS_IPHONE != 0
//
// COMPILERFIX: Disable connect timeout introduced for
// workaround to iOS device hangs when using SSL
//
properties->setProperty("Ice.Override.ConnectTimeout", "");
#endif
//
// This test kills connections, so we don't want warnings.
//
properties->setProperty("Ice.Warn.Connections", "0");
//
// The client sends large messages to cause the transport
// buffers to fill up.
//
properties->setProperty("Ice.MessageSizeMax", "20000");
//
// Limit the recv buffer size, this test relies on the socket
// send() blocking after sending a given amount of data.
//
properties->setProperty("Ice.TCP.RcvSize", "50000");
Ice::CommunicatorHolder communicator = initialize(argc, argv, properties);
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint());
communicator->getProperties()->setProperty("ControllerAdapter.Endpoints", getTestEndpoint(1));
communicator->getProperties()->setProperty("ControllerAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TimeoutI), Ice::stringToIdentity("timeout"));
adapter->activate();
Ice::ObjectAdapterPtr controllerAdapter = communicator->createObjectAdapter("ControllerAdapter");
controllerAdapter->add(ICE_MAKE_SHARED(ControllerI, adapter), Ice::stringToIdentity("controller"));
controllerAdapter->activate();
serverReady();
communicator->waitForShutdown();
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(TestIntfI,communicator), Ice::stringToIdentity("TEST"));
adapter->add(ICE_MAKE_SHARED(Test1::WstringClassI), Ice::stringToIdentity("WSTRING1"));
adapter->add(ICE_MAKE_SHARED(Test2::WstringClassI), Ice::stringToIdentity("WSTRING2"));
adapter->activate();
TEST_READY
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
void
RegistryI::setupNullPermissionsVerifier(const Ice::ObjectAdapterPtr& registryAdapter)
{
Identity nullPermVerifId;
nullPermVerifId.category = _instanceName;
nullPermVerifId.name = "NullPermissionsVerifier";
_nullPermissionsVerifier = Glacier2::PermissionsVerifierPrx::uncheckedCast(
registryAdapter->add(new NullPermissionsVerifierI(), nullPermVerifId)->ice_collocationOptimized(true));
Identity nullSSLPermVerifId;
nullSSLPermVerifId.category = _instanceName;
nullSSLPermVerifId.name = "NullSSLPermissionsVerifier";
_nullSSLPermissionsVerifier = Glacier2::SSLPermissionsVerifierPrx::uncheckedCast(
registryAdapter->add(new NullSSLPermissionsVerifierI(), nullSSLPermVerifId)->ice_collocationOptimized(true));
}
int YKTServer::run( int argc, char* argv[] )
{
Ice::PropertiesPtr properties = communicator()->getProperties();
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter( "YKT" );
Ice::Identity id = communicator()->stringToIdentity( properties->getProperty("Identity") );
transfer::CallServerPtr callserver = new Server(_currentCtx);
//adapter->add( new Server( _currentCtx ), );
adapter->add( callserver, id );
adapter->activate();
//Ice::PropertiesPtr prop = communicator()->getProperties();
string port = properties->getPropertyWithDefault( "queue.port", "10010" );
string maxcount = properties->getPropertyWithDefault( "queue.processcount", "5" );
std::size_t iport = atoi( port.c_str() );
std::size_t imax = atoi( maxcount.c_str() );
queue_manager_inst::get()->update_properties( properties );
LOG(INFO,"start signal handler");
signal(SIGINT,signal_handler);
signal(SIGTERM,signal_handler);//kill 命令的捕获
if( queue_manager_inst::get()->start( iport ) )
{
return -1;
}
communicator()->waitForShutdown();
queue_manager_inst::get()->stop();
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
int status = 0;
Ice::CommunicatorPtr ic;
try
{
ic = Ice::initialize(argc, argv);
Ice::ObjectAdapterPtr adapter = ic->createObjectAdapterWithEndpoints(
"SimplePrinterAdapter", "default -p 10000");
Ice::ObjectPtr object = new PrinterI;
adapter->add(object, ic->stringToIdentity("SimplePrinter"));
adapter->activate();
ic->waitForShutdown();
}
catch (const Ice::Exception& e)
{
std::cerr << e << std::endl;
status = 1;
}
if (ic)
{
try
{
ic->destroy();
}
catch (const Ice::Exception& e)
{
std::cerr << e << std::endl;
status = 1;
}
}
return status;
}
virtual int
run(int argc, char* argv[])
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties();
initData.properties->setProperty("TestAdapter.Endpoints", "default -p 12010 -t 10000");
loadConfig(initData.properties);
initData.logger = getLogger();
setCommunicator(Ice::initialize(argc, argv, initData));
Ice::ObjectFactoryPtr factory = new MyObjectFactory;
communicator()->addObjectFactory(factory, "::Test::I");
communicator()->addObjectFactory(factory, "::Test::J");
communicator()->addObjectFactory(factory, "::Test::H");
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("TestAdapter");
InitialPtr initial = new InitialI(adapter);
adapter->add(initial, communicator()->stringToIdentity("initial"));
adapter->activate();
#ifndef _WIN32_WCE
communicator()->waitForShutdown();
#endif
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
int status = 0;
Ice::CommunicatorPtr ic;
try {
ic = Ice::initialize(argc, argv);
Ice::ObjectAdapterPtr adapter
= ic->createObjectAdapterWithEndpoints("lcdshow", "default -p 10000");
ram::tortuga::SensorBoardI* board = new ram::tortuga::SensorBoardI();
// Check if the board initialized correctly
if (board->isInitialized()) {
Ice::ObjectPtr object = board;
adapter->add(object, ic->stringToIdentity("SensorBoard"));
adapter->activate();
ic->waitForShutdown();
}
delete board;
} catch (const Ice::Exception& e) {
std::cerr << e << std::endl;
status = 1;
} catch (const char* msg) {
std::cerr << msg << std::endl;
status = 1;
}
if (ic) {
try {
ic->destroy();
} catch (const Ice::Exception& e) {
std::cerr << e << std::endl;
status = 1;
}
}
return status;
}
void
ServiceI::start(const string& name, const CommunicatorPtr& communicator, const StringSeq& args)
{
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter(name + "OA");
adapter->add(new TestI(args), communicator->stringToIdentity("test"));
adapter->activate();
}
DetectorPrx initIceConnection(const std::string& detectorNameStr,
Ice::Identity& det_cb,
DetectorCallbackHandlerPtr cr)
{
initIce(detectorNameStr);
Ice::PropertiesPtr props = iceComm->getProperties();
std::string proxStr = detectorNameStr + ".Proxy";
DetectorPrx detector = NULL;
try
{
detector = DetectorPrx::checkedCast(
iceComm->propertyToProxy(proxStr)->ice_twoway());
}
catch (const IceUtil::NullHandleException& e)
{
localAndClientMsg( VLogger::ERROR, NULL, "Invalid proxy: '%s'. %s\n",
detectorNameStr.c_str(), e.what());
return NULL;
}
Ice::ObjectAdapterPtr adapter = iceComm->createObjectAdapter("");
det_cb.name = IceUtil::generateUUID();
det_cb.category = "";
adapter->add(cr, det_cb);
adapter->activate();
detector->ice_getConnection()->setAdapter(adapter);
// note that we need an ObjectAdapter to permit bidirectional communication
// if we want to get past firewalls without Glacier2
return detector; // Success
}
int
main(int argc, char* argv[])
{
int status = 0;
Ice::InitializationData id;
id.properties = Ice::createProperties(argc, argv);
id.properties->setProperty("Ice.ThreadPool.Server.Size", "50");
id.properties->setProperty("Ice.ThreadPool.Server.SizeMax", "5000");
// _communicator = Ice::initialize(id);
Ice::CommunicatorPtr ic;
try {
ic = Ice::initialize(id);
Ice::ObjectAdapterPtr adapter
= ic->createObjectAdapterWithEndpoints(
"SimplePrinterAdapter", "default -p 10000"); //默认建立的是tcp 连接
Ice::ObjectPtr object = new PrinterI;
PrinterPrx spPrx = PrinterPrx::uncheckedCast(adapter->add(object, ic->stringToIdentity("SimplePrinter")));
cout << "PrinterPrx:" <<spPrx <<endl;
adapter->activate();
ic->waitForShutdown();
} catch (const Ice::Exception & e) {
cerr << e << endl;
status = 1;
} catch (const char * msg) {
cerr << msg << endl;
status = 1;
}
if (ic)
ic->destroy();
return status;
}
int
CallbackServer::run(int argc, char* argv[])
{
if(argc > 1)
{
cerr << appName() << ": too many arguments" << endl;
return EXIT_FAILURE;
}
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Callback.Server");
CallbackSenderIPtr sender = new CallbackSenderI(communicator());
adapter->add(sender, communicator()->stringToIdentity("sender"));
adapter->activate();
sender->start();
try
{
communicator()->waitForShutdown();
}
catch(...)
{
sender->destroy();
throw;
}
sender->destroy();
return EXIT_SUCCESS;
}
virtual int
run(int argc, char* argv[])
{
Ice::InitializationData initData;
initData.properties = Ice::createProperties();
initData.properties->setProperty("TestAdapter.Endpoints", "default -p 12010 -t 10000");
loadConfig(initData.properties);
initData.logger = getLogger();
setCommunicator(Ice::initialize(argc, argv, initData));
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("TestAdapter");
Ice::ObjectPtr d = new DI;
adapter->add(d, communicator()->stringToIdentity("d"));
adapter->addFacet(d, communicator()->stringToIdentity("d"), "facetABCD");
Ice::ObjectPtr f = new FI;
adapter->addFacet(f, communicator()->stringToIdentity("d"), "facetEF");
Ice::ObjectPtr h = new HI(communicator());
adapter->addFacet(h, communicator()->stringToIdentity("d"), "facetGH");
adapter->activate();
#ifndef _WIN32_WCE
communicator()->waitForShutdown();
#endif
return EXIT_SUCCESS;
}
/**
* Главная процедура
**/
virtual int run(int, char* [])
{
// Получаем адаптер
Ice::ObjectAdapterPtr adapter =
communicator()->createObjectAdapterWithEndpoints("MaximaWorkerAdapter", "default -p 31337");
//И регистриуем наш объект
Ice::ObjectPtr object = new MaximaWorkerImpl();
Ice::ObjectPrx objPrx = adapter->add(object, communicator()->stringToIdentity("MaximaWorker"));
adapter->activate();
//Получаем объект диспетчера
//TODO: приделать сюда указание хоста.
Ice::ObjectPrx obj =
communicator()->stringToProxy("MaximaDispatcher:default -p 31338");
MaximaLib::MaximaDispatcherPrx disp = MaximaLib::MaximaDispatcherPrx::checkedCast(obj);
if(!disp)
throw "Wrong disp";
// Регистриуемся в диспетчере
MaximaLib::MaximaWorkerPrx wrkPrx = MaximaLib::MaximaWorkerPrx::uncheckedCast(objPrx);
disp->registerWorker(wrkPrx);
// Продожаем работать, пока нас не прервут.
communicator()->waitForShutdown();
}
int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
{
Ice::PropertiesPtr properties = communicator->getProperties();
int num = argc == 2 ? atoi(argv[1]) : 0;
{
ostringstream os;
os << "default -p " << (12010 + num);
properties->setProperty("ControlAdapter.Endpoints", os.str());
}
{
ostringstream os;
os << "control" << num;
properties->setProperty("ControlAdapter.AdapterId", os.str());
}
properties->setProperty("ControlAdapter.ThreadPool.Size", "1");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ControlAdapter");
{
ostringstream os;
os << "controller" << num;
adapter->add(ICE_MAKE_SHARED(ControllerI), communicator->stringToIdentity(os.str()));
}
adapter->activate();
TEST_READY
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
bool
RegistryI::setupUserAccountMapper(const Ice::ObjectAdapterPtr& registryAdapter)
{
Ice::PropertiesPtr properties = _communicator->getProperties();
//
// Setup file user account mapper object if the property is set.
//
string userAccountFileProperty = properties->getProperty("IceGrid.Registry.UserAccounts");
if(!userAccountFileProperty.empty())
{
try
{
Identity mapperId;
mapperId.category = _instanceName;
mapperId.name = "RegistryUserAccountMapper";
if(!_master)
{
mapperId.name += "-" + _replicaName;
}
registryAdapter->add(new FileUserAccountMapperI(userAccountFileProperty), mapperId);
_wellKnownObjects->add(registryAdapter->createProxy(mapperId), UserAccountMapper::ice_staticId());
}
catch(const std::string& msg)
{
Error out(_communicator->getLogger());
out << msg;
return false;
}
}
return true;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0) + ":udp");
communicator->getProperties()->setProperty("Ice.Warn.Dispatch", "0");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorAMDI, ""), "");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorAMDI, "category"), "category");
adapter->add(ICE_MAKE_SHARED(TestAMDI), communicator->stringToIdentity("asm"));
adapter->add(ICE_MAKE_SHARED(TestActivationI), communicator->stringToIdentity("test/activation"));
adapter->activate();
TEST_READY
adapter->waitForDeactivate();
return EXIT_SUCCESS;
}
void
setupObjectAdapter(const Ice::CommunicatorPtr& communicator)
{
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("");
Ice::ObjectPtr object = new RetryI;
adapter->add(object, communicator->stringToIdentity("retry"));
//adapter->activate(); // Don't activate OA to ensure collocation is used.
}
bool MyService::start(int argc, char* argv[]) {
_adapter = communicator()->createObjectAdapterWithEndpoints(SVRADAPTER,URL);
Ice::ObjectPtr object = new UserI;
plogger = communicator()->getLogger();
_adapter->add(object, communicator()->stringToIdentity(SVRID));
_adapter->activate();
return true;
}
QueryPrx
RegistryI::setupQuery(const Ice::ObjectAdapterPtr& clientAdapter)
{
Identity queryId;
queryId.category = _instanceName;
queryId.name = "Query";
return QueryPrx::uncheckedCast(clientAdapter->add(new QueryI(_communicator, _database), queryId));
}
virtual int run(int, char*[])
{
Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("PermissionsVerifier");
adapter->add(new PermissionsVerifierI, communicator()->stringToIdentity("PermissionsVerifier"));
adapter->activate();
communicator()->waitForShutdown();
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", "default -p 12010:udp");
communicator->getProperties()->setProperty("Ice.Warn.Dispatch", "0");
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->addServantLocator(new ServantLocatorAMDI(""), "");
adapter->addServantLocator(new ServantLocatorAMDI("category"), "category");
adapter->add(new TestAMDI, communicator->stringToIdentity("asm"));
adapter->add(new TestActivationI, communicator->stringToIdentity("test/activation"));
adapter->activate();
TEST_READY
adapter->waitForDeactivate();
return EXIT_SUCCESS;
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator)
{
communicator->getProperties()->setProperty("Ice.Warn.Dispatch", "0");
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorI, ""), "");
adapter->addServantLocator(ICE_MAKE_SHARED(ServantLocatorI, "category"), "category");
adapter->add(ICE_MAKE_SHARED(TestI), communicator->stringToIdentity("asm"));
adapter->add(ICE_MAKE_SHARED(TestActivationI), communicator->stringToIdentity("test/activation"));
Test::TestIntfPrxPtr allTests(const CommunicatorPtr&);
allTests(communicator);
return EXIT_SUCCESS;
}
int main(int argc, char* argv[])
{
int status = 0;
Ice::CommunicatorPtr ic;
try {
ic = Ice::initialize(argc, argv);
if (argc != 4) {
cerr << "Usage: " << argv[0] << " servername NameService-host local-port\n";
goto clean_up;
}
// Look up the name service.
ostringstream ns_formatter;
ns_formatter << "NameService:tcp -h " << argv[2] << " -p 9010";
Ice::ObjectPrx base =
ic->stringToProxy(ns_formatter.str().c_str());
NameServicePrx ns = NameServicePrx::checkedCast(base);
if (!ns)
throw "Invalid NameService";
// Create local chat display object and support infrastructure.
ostringstream server_formatter;
server_formatter << "tcp -p " << argv[3];
Ice::ObjectAdapterPtr adapter = ic->createObjectAdapterWithEndpoints(
"ChatterAdapter", server_formatter.str().c_str());
Ice::ObjectPtr object = new RoomManager_impl(adapter);
Ice::ObjectPrx server =
adapter->add(object, ic->stringToIdentity("RoomManager"));
adapter->activate();
// Register object.
// ns->registerName(argv[1], server);
ic->waitForShutdown();
}
catch (const Ice::Exception& e) {
cerr << e << endl;
status = 1;
}
catch (const char* msg) {
cerr << msg << endl;
status = 1;
}
clean_up:
// We must call ic->destroy() even if an exception is throw above.
if (ic) {
try {
ic->destroy();
}
catch (const Ice::Exception& e) {
cerr << e << endl;
status = 1;
}
}
return status;
}
int
run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
{
Ice::PropertiesPtr properties = communicator->getProperties();
int num = argc == 2 ? atoi(argv[1]) : 0;
ostringstream os;
os << "tcp -p " << (12010 + num);
properties->setProperty("ControlAdapter.Endpoints", os.str());
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("ControlAdapter");
adapter->add(new TestIntfI, communicator->stringToIdentity("control"));
adapter->activate();
if(num == 0)
{
properties->setProperty("TestAdapter.Endpoints", "udp -p 12010");
Ice::ObjectAdapterPtr adapter2 = communicator->createObjectAdapter("TestAdapter");
adapter2->add(new TestIntfI, communicator->stringToIdentity("test"));
adapter2->activate();
}
string endpoint;
if(properties->getProperty("Ice.IPv6") == "1")
{
#if defined(__APPLE__)
endpoint = "udp -h \"ff02::1:1\" -p 12020 --interface \"lo0\"";
#else
endpoint = "udp -h \"ff01::1:1\" -p 12020";
#endif
}
else
{
endpoint = "udp -h 239.255.1.1 -p 12020";
}
properties->setProperty("McastTestAdapter.Endpoints", endpoint);
Ice::ObjectAdapterPtr mcastAdapter = communicator->createObjectAdapter("McastTestAdapter");
mcastAdapter->add(new TestIntfI, communicator->stringToIdentity("test"));
mcastAdapter->activate();
TEST_READY
communicator->waitForShutdown();
return EXIT_SUCCESS;
}
void
RegistryI::setupAdminSessionFactory(const Ice::ObjectAdapterPtr& registryAdapter,
const Ice::ObjectAdapterPtr& sessionManagerAdapter,
const IceGrid::LocatorPrx& locator,
bool nowarn)
{
assert(_reaper);
_adminSessionFactory = new AdminSessionFactory(sessionManagerAdapter, _database, _reaper, this);
if(sessionManagerAdapter)
{
Identity adminSessionMgrId;
adminSessionMgrId.category = _instanceName;
adminSessionMgrId.name = "AdminSessionManager";
Identity sslAdmSessionMgrId;
sslAdmSessionMgrId.category = _instanceName;
sslAdmSessionMgrId.name = "AdminSSLSessionManager";
if(!_master)
{
adminSessionMgrId.name += "-" + _replicaName;
sslAdmSessionMgrId.name += "-" + _replicaName;
}
sessionManagerAdapter->add(new AdminSessionManagerI(_adminSessionFactory), adminSessionMgrId);
sessionManagerAdapter->add(new AdminSSLSessionManagerI(_adminSessionFactory), sslAdmSessionMgrId);
_wellKnownObjects->add(sessionManagerAdapter->createProxy(adminSessionMgrId),
Glacier2::SessionManager::ice_staticId());
_wellKnownObjects->add(sessionManagerAdapter->createProxy(sslAdmSessionMgrId),
Glacier2::SSLSessionManager::ice_staticId());
}
Ice::PropertiesPtr properties = _communicator->getProperties();
_adminVerifier = getPermissionsVerifier(registryAdapter,
locator,
"IceGrid.Registry.AdminPermissionsVerifier",
properties->getProperty("IceGrid.Registry.AdminCryptPasswords"),
nowarn);
_sslAdminVerifier =
getSSLPermissionsVerifier(locator,
"IceGrid.Registry.AdminSSLPermissionsVerifier",
nowarn);
}
int
run(int, char**, const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPtr& observer)
{
communicator->getProperties()->setProperty("TestAdapter.Endpoints", getTestEndpoint(communicator, 0));
Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("TestAdapter");
adapter->add(ICE_MAKE_SHARED(MetricsI), Ice::stringToIdentity("metrics"));
//adapter->activate(); // Don't activate OA to ensure collocation is used.
communicator->getProperties()->setProperty("ControllerAdapter.Endpoints", getTestEndpoint(communicator, 1));
Ice::ObjectAdapterPtr controllerAdapter = communicator->createObjectAdapter("ControllerAdapter");
controllerAdapter->add(ICE_MAKE_SHARED(ControllerI, adapter), Ice::stringToIdentity("controller"));
//controllerAdapter->activate(); // Don't activate OA to ensure collocation is used.
MetricsPrxPtr allTests(const Ice::CommunicatorPtr&, const CommunicatorObserverIPtr&);
MetricsPrxPtr metrics = allTests(communicator, observer);
metrics->shutdown();
return EXIT_SUCCESS;
}
//-----------------------------------------------------------------------------
// Proxy Start-up
//-----------------------------------------------------------------------------
bool mtsManagerProxyClient::StartProxy(mtsManagerLocal * proxyOwner)
{
// Initialize Ice object
IceInitialize();
if (!InitSuccessFlag) {
LogError(mtsManagerProxyClient, "ICE proxy client initialization failed");
return false;
}
// Client configuration for bidirectional communication
Ice::ObjectAdapterPtr adapter = IceCommunicator->createObjectAdapter("");
Ice::Identity id;
id.name = GetIceGUID();
id.category = "";
mtsManagerProxy::ManagerClientPtr client =
new ManagerClientI(IceCommunicator, IceLogger, ManagerServerProxy, this);
adapter->add(client, id);
adapter->activate();
ManagerServerProxy->ice_getConnection()->setAdapter(adapter);
// Set an implicit context (per proxy context)
IceCommunicator->getImplicitContext()->put(
mtsManagerProxyServer::GetConnectionIDKey(), IceCommunicator->identityToString(id));
// Set proxy owner and name of this proxy object
SetProxyOwner(proxyOwner);
// Connect to server proxy through adding this ICE proxy to server proxy
if (!ManagerServerProxy->AddClient(GetProxyName(), id)) {
LogError(mtsManagerProxyClient, "AddClient() failed: duplicate proxy name or identity");
return false;
}
// Thread arguments for a worker thread
ThreadArgumentsInfo.Proxy = this;
ThreadArgumentsInfo.Runner = mtsManagerProxyClient::Runner;
// Set a short name of this thread as "MPC" (Manager Proxy Client) to meet
// the requirement that some of operating system have -- only a few characters
// can be used as a thread name (e.g. Linux RTAI)
std::stringstream ss;
ss << "MPC" << mtsManagerProxyClient::InstanceCounter++;
std::string threadName = ss.str();
// Create worker thread (will get started later)
WorkerThread.Create<ProxyWorker<mtsManagerLocal>, ThreadArguments<mtsManagerLocal>*>(
&ProxyWorkerInfo, &ProxyWorker<mtsManagerLocal>::Run, &ThreadArgumentsInfo, threadName.c_str());
#if IMPROVE_ICE_THREADING
// Wait for Ice thread to start
IceThreadInitEvent->Wait();
#endif
return true;
}
void
Filesystem::NodeI::activate(const Ice::ObjectAdapterPtr& a)
{
NodePrx thisNode = NodePrx::uncheckedCast(a->add(this, _id));
if(_parent)
{
_parent->addChild(thisNode);
}
}
