bool NodeService::startImpl(int argc, char* argv[], int& status) { bool nowarn = false; bool readonly = false; string initFromReplica; string desc; vector<string> targets; for(int i = 1; i < argc; ++i) { if(strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0) { usage(argv[0]); status = EXIT_SUCCESS; return false; } else if(strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0) { print(ICE_STRING_VERSION); status = EXIT_SUCCESS; return false; } else if(strcmp(argv[i], "--nowarn") == 0) { nowarn = true; } else if(strcmp(argv[i], "--readonly") == 0) { readonly = true; } else if(strcmp(argv[i], "--initdb-from-replica") == 0) { if(i + 1 >= argc) { error("missing replica argument for option `" + string(argv[i]) + "'"); usage(argv[0]); return false; } initFromReplica = argv[++i]; } else if(strcmp(argv[i], "--deploy") == 0) { if(i + 1 >= argc) { error("missing descriptor argument for option `" + string(argv[i]) + "'"); usage(argv[0]); return false; } desc = argv[++i]; while(i + 1 < argc && argv[++i][0] != '-') { targets.push_back(argv[i]); } } else { error("invalid option: `" + string(argv[i]) + "'"); usage(argv[0]); return false; } } PropertiesPtr properties = communicator()->getProperties(); // // Disable server idle time. Otherwise, the adapter would be // shutdown prematurely and the deactivation would fail. // Deactivation of the node relies on the object adapter // to be active since it needs to terminate servers. // // TODO: implement Ice.ServerIdleTime in the activator // termination listener instead? // properties->setProperty("Ice.ServerIdleTime", "0"); // // 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."; } setupThreadPool(properties, "IceGrid.Node.ThreadPool", 1, 100); // // Create the activator. // TraceLevelsPtr traceLevels = new TraceLevels(communicator(), "IceGrid.Node"); _activator = new Activator(traceLevels); // // Collocate the IceGrid registry if we need to. // if(properties->getPropertyAsInt("IceGrid.Node.CollocateRegistry") > 0) { _registry = new CollocatedRegistry(communicator(), _activator, nowarn, readonly, initFromReplica); if(!_registry->start()) { return false; } // // Set the default locator property to point to the collocated // locator (this property is passed by the activator to each // activated server). The default locator is also needed by // the node session manager. // if(properties->getProperty("Ice.Default.Locator").empty()) { Identity locatorId; locatorId.category = properties->getPropertyWithDefault("IceGrid.InstanceName", "IceGrid"); locatorId.name = "Locator"; string endpoints = properties->getProperty("IceGrid.Registry.Client.Endpoints"); string locPrx = "\"" + communicator()->identityToString(locatorId) + "\" :" + endpoints; communicator()->setDefaultLocator(Ice::LocatorPrx::uncheckedCast(communicator()->stringToProxy(locPrx))); properties->setProperty("Ice.Default.Locator", locPrx); } } else if(properties->getProperty("Ice.Default.Locator").empty()) { error("property `Ice.Default.Locator' is not set"); return false; } // // Initialize the database environment (first setup the directory structure if needed). // string dataPath = properties->getProperty("IceGrid.Node.Data"); string dbPath; if(dataPath.empty()) { error("property `IceGrid.Node.Data' is not set"); return false; } else { if(!IceUtilInternal::directoryExists(dataPath)) { FileException ex(__FILE__, __LINE__); ex.path = dataPath; ex.error = IceInternal::getSystemErrno(); ServiceError err(this); err << "property `IceGrid.Node.Data' is set to an invalid path:\n" << ex; return false; } // // Creates subdirectories. // if(dataPath[dataPath.length() - 1] != '/') { dataPath += "/"; } IcePatch2::createDirectory(dataPath + "servers"); IcePatch2::createDirectory(dataPath + "tmp"); IcePatch2::createDirectory(dataPath + "distrib"); #ifdef _WIN32 // // Make sure these directories are not indexed by the Windows // indexing service (which can cause random "Access Denied" // errors if indexing runs at the same time as the node is // creating/deleting files). // try { setNoIndexingAttribute(dataPath + "servers"); setNoIndexingAttribute(dataPath + "tmp"); setNoIndexingAttribute(dataPath + "distrib"); } catch(const FileException& ex) { if(!nowarn) { Warning out(communicator()->getLogger()); out << "couldn't disable file indexing:\n" << ex; } } #endif } // // Check that required properties are set and valid. // if(properties->getProperty("IceGrid.Node.Endpoints").empty()) { error("property `IceGrid.Node.Endpoints' is not set"); return false; } string name = properties->getProperty("IceGrid.Node.Name"); if(name.empty()) { error("property `IceGrid.Node.Name' is not set"); return false; } // // Setup the Freeze database environment home directory. The name of the database // environment for the IceGrid node is the name of the node. // properties->setProperty("Freeze.DbEnv." + name + ".DbHome", dbPath); // // Create the node object adapter. // _adapter = communicator()->createObjectAdapter("IceGrid.Node"); // // Setup the user account mapper if configured. // string mapperProperty = "IceGrid.Node.UserAccountMapper"; string mapperPropertyValue = properties->getProperty(mapperProperty); UserAccountMapperPrx mapper; if(!mapperPropertyValue.empty()) { try { mapper = UserAccountMapperPrx::uncheckedCast(communicator()->propertyToProxy(mapperProperty)); } catch(const std::exception& ex) { ServiceError err(this); err << "user account mapper `" << mapperProperty << "' is invalid:\n" << ex; return false; } } else { string userAccountFileProperty = properties->getProperty("IceGrid.Node.UserAccounts"); if(!userAccountFileProperty.empty()) { try { Ice::ObjectPrx object = _adapter->addWithUUID(new FileUserAccountMapperI(userAccountFileProperty)); object = object->ice_collocationOptimized(true); mapper = UserAccountMapperPrx::uncheckedCast(object); } catch(const std::string& msg) { error(msg); return false; } } } // // Create a new timer to handle server activation/deactivation timeouts. // _timer = new IceUtil::Timer(); // // The IceGrid instance name. // const string instanceName = communicator()->getDefaultLocator()->ice_getIdentity().category; _sessions.reset(new NodeSessionManager(communicator())); // // Create the server factory. The server factory creates persistent objects // for the server and server adapter. It also takes care of installing the // evictors and object factories necessary to store these objects. // Identity id = communicator()->stringToIdentity(instanceName + "/Node-" + name); NodePrx nodeProxy = NodePrx::uncheckedCast(_adapter->createProxy(id)); _node = new NodeI(_adapter, *_sessions, _activator, _timer, traceLevels, nodeProxy, name, mapper); _adapter->add(_node, nodeProxy->ice_getIdentity()); _adapter->addServantLocator(new DefaultServantLocator(new NodeServerAdminRouter(_node)), _node->getServerAdminCategory()); // // Start the platform info thread if needed. // _node->getPlatformInfo().start(); // // Ensures that the locator is reachable. // if(!nowarn) { try { communicator()->getDefaultLocator()->ice_timeout(1000)->ice_ping(); } catch(const Ice::LocalException& ex) { Warning out(communicator()->getLogger()); out << "couldn't reach the IceGrid registry (this is expected "; out << "if it's down, otherwise please check the value of the "; out << "Ice.Default.Locator property):\n" << ex; } } // // Create the node sessions with the registries. // _sessions->create(_node); // // In some tests, we deploy icegridnodes using IceGrid: // if(properties->getProperty("Ice.Admin.Endpoints") != "") { // // Replace Process facet and create Admin object // try { ProcessPtr origProcess = ProcessPtr::dynamicCast(communicator()->removeAdminFacet("Process")); communicator()->addAdminFacet(new ProcessI(_activator, origProcess), "Process"); communicator()->getAdmin(); } catch(const Ice::NotRegisteredException&) { // // Some plug-in removed the Process facet, so we don't replace it. // (unlikely error though) // } } // // Start the activator. // _activator->start(); // // Activate the adapter. // _adapter->activate(); // // Notify the node session manager that the node can start // accepting incoming connections. // _sessions->activate(); string bundleName = properties->getProperty("IceGrid.Node.PrintServersReady"); if(!bundleName.empty() || !desc.empty()) { enableInterrupt(); if(!_sessions->waitForCreate()) { // // Create was interrupted, return true as if the service was // correctly initiliazed to make sure it's properly stopped. // return true; } disableInterrupt(); } // // Deploy application if a descriptor is passed as a command-line option. // if(!desc.empty()) { try { Ice::Identity regId; regId.category = instanceName; regId.name = "Registry"; RegistryPrx registry = RegistryPrx::checkedCast(communicator()->getDefaultLocator()->findObjectById(regId)); if(!registry) { throw "invalid registry"; } registry = registry->ice_preferSecure(true); // Use SSL if available. IceGrid::AdminSessionPrx session; if(communicator()->getProperties()->getPropertyAsInt("IceGridAdmin.AuthenticateUsingSSL")) { session = registry->createAdminSessionFromSecureConnection(); } else { string id = communicator()->getProperties()->getProperty("IceGridAdmin.Username"); string password = communicator()->getProperties()->getProperty("IceGridAdmin.Password"); while(id.empty()) { cout << "user id: " << flush; getline(cin, id); id = IceUtilInternal::trim(id); } if(password.empty()) { cout << "password: "******"failed to deploy application `" << desc << "':\n" << ex; } catch(const AccessDeniedException& ex) { ServiceWarning warn(this); warn << "failed to deploy application `" << desc << "':\n" << "registry database is locked by `" << ex.lockUserId << "'"; } catch(const std::exception& ex) { ServiceWarning warn(this); warn << "failed to deploy application `" << desc << "':\n" << ex; } catch(const string& reason) { ServiceWarning warn(this); warn << "failed to deploy application `" << desc << "':\n" << reason; } } if(!bundleName.empty()) { print(bundleName + " ready"); } return true; }
Test::MyClassPrx allTests(const Ice::CommunicatorPtr& communicator) { cout << "testing stringToProxy... " << flush; string ref = "test:default -p 12010"; Ice::ObjectPrx base = communicator->stringToProxy(ref); test(base); Ice::ObjectPrx b1 = communicator->stringToProxy("test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId().empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("test "); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy(" test "); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy(" test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("'test -f facet'"); test(b1->ice_getIdentity().name == "test -f facet" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); try { b1 = communicator->stringToProxy("\"test -f facet'"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("\"test -f facet\""); test(b1->ice_getIdentity().name == "test -f facet" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("\"test -f facet@test\""); test(b1->ice_getIdentity().name == "test -f facet@test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); b1 = communicator->stringToProxy("\"test -f facet@test @test\""); test(b1->ice_getIdentity().name == "test -f facet@test @test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet().empty()); try { b1 = communicator->stringToProxy("test test"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test\\040test"); test(b1->ice_getIdentity().name == "test test" && b1->ice_getIdentity().category.empty()); try { b1 = communicator->stringToProxy("test\\777"); test(false); } catch(const Ice::IdentityParseException&) { } b1 = communicator->stringToProxy("test\\40test"); test(b1->ice_getIdentity().name == "test test"); // Test some octal and hex corner cases. b1 = communicator->stringToProxy("test\\4test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\04test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\004test"); test(b1->ice_getIdentity().name == "test\4test"); b1 = communicator->stringToProxy("test\\1114test"); test(b1->ice_getIdentity().name == "test\1114test"); b1 = communicator->stringToProxy("test\\b\\f\\n\\r\\t\\'\\\"\\\\test"); test(b1->ice_getIdentity().name == "test\b\f\n\r\t\'\"\\test" && b1->ice_getIdentity().category.empty()); b1 = communicator->stringToProxy("category/test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy(""); test(!b1); b1 = communicator->stringToProxy("\"\""); test(!b1); try { b1 = communicator->stringToProxy("\"\" test"); // Invalid trailing characters. test(false); } catch(const Ice::ProxyParseException&) { } try { b1 = communicator->stringToProxy("test:"); // Missing endpoint. test(false); } catch(const Ice::EndpointParseException&) { } b1 = communicator->stringToProxy("test@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId() == "adapter"); try { b1 = communicator->stringToProxy("id@adapter test"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("category/test@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("category/test@adapter:tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter:tcp"); b1 = communicator->stringToProxy("'category 1/test'@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category 1" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("'category/test 1'@adapter"); test(b1->ice_getIdentity().name == "test 1" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("'category/test'@'adapter 1'"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category" && b1->ice_getAdapterId() == "adapter 1"); b1 = communicator->stringToProxy("\"category \\/test@foo/test\"@adapter"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category /test@foo" && b1->ice_getAdapterId() == "adapter"); b1 = communicator->stringToProxy("\"category \\/test@foo/test\"@\"adapter:tcp\""); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category == "category /test@foo" && b1->ice_getAdapterId() == "adapter:tcp"); b1 = communicator->stringToProxy("id -f facet"); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet"); b1 = communicator->stringToProxy("id -f 'facet x'"); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet x"); b1 = communicator->stringToProxy("id -f \"facet x\""); test(b1->ice_getIdentity().name == "id" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet x"); try { b1 = communicator->stringToProxy("id -f \"facet x"); test(false); } catch(const Ice::ProxyParseException&) { } try { b1 = communicator->stringToProxy("id -f \'facet x"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test -f facet:tcp"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f \"facet:tcp\""); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet:tcp" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f facet@test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet" && b1->ice_getAdapterId() == "test"); b1 = communicator->stringToProxy("test -f 'facet@test'"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet@test" && b1->ice_getAdapterId().empty()); b1 = communicator->stringToProxy("test -f 'facet@test'@test"); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getFacet() == "facet@test" && b1->ice_getAdapterId() == "test"); try { b1 = communicator->stringToProxy("test -f facet@test @test"); test(false); } catch(const Ice::ProxyParseException&) { } b1 = communicator->stringToProxy("test"); test(b1->ice_isTwoway()); b1 = communicator->stringToProxy("test -t"); test(b1->ice_isTwoway()); b1 = communicator->stringToProxy("test -o"); test(b1->ice_isOneway()); b1 = communicator->stringToProxy("test -O"); test(b1->ice_isBatchOneway()); b1 = communicator->stringToProxy("test -d"); test(b1->ice_isDatagram()); b1 = communicator->stringToProxy("test -D"); test(b1->ice_isBatchDatagram()); b1 = communicator->stringToProxy("test"); test(!b1->ice_isSecure()); b1 = communicator->stringToProxy("test -s"); test(b1->ice_isSecure()); test(b1->ice_getEncodingVersion() == Ice::currentEncoding); b1 = communicator->stringToProxy("test -e 1.0"); test(b1->ice_getEncodingVersion().major == 1 && b1->ice_getEncodingVersion().minor == 0); b1 = communicator->stringToProxy("test -e 6.5"); test(b1->ice_getEncodingVersion().major == 6 && b1->ice_getEncodingVersion().minor == 5); b1 = communicator->stringToProxy("test -p 1.0 -e 1.0"); test(b1->ice_toString() == "test -t -e 1.0"); b1 = communicator->stringToProxy("test -p 6.5 -e 1.0"); test(b1->ice_toString() == "test -t -p 6.5 -e 1.0"); try { b1 = communicator->stringToProxy("test:tcp@adapterId"); test(false); } catch(const Ice::EndpointParseException&) { } // This is an unknown endpoint warning, not a parse exception. // //try //{ // b1 = communicator->stringToProxy("test -f the:facet:tcp"); // test(false); //} //catch(const Ice::EndpointParseException&) //{ //} try { b1 = communicator->stringToProxy("test::tcp"); test(false); } catch(const Ice::EndpointParseException&) { } // // Test for bug ICE-5543: escaped escapes in stringToIdentity // Ice::Identity id = { "test", ",X2QNUAzSBcJ_e$AV;E\\" }; Ice::Identity id2 = communicator->stringToIdentity(communicator->identityToString(id)); test(id == id2); id.name = "test"; id.category = ",X2QNUAz\\SB\\/cJ_e$AV;E\\\\"; id2 = communicator->stringToIdentity(communicator->identityToString(id)); test(id == id2); cout << "ok" << endl; cout << "testing propertyToProxy... " << flush; Ice::PropertiesPtr prop = communicator->getProperties(); string propertyPrefix = "Foo.Proxy"; prop->setProperty(propertyPrefix, "test:default -p 12010"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getIdentity().name == "test" && b1->ice_getIdentity().category.empty() && b1->ice_getAdapterId().empty() && b1->ice_getFacet().empty()); string property; property = propertyPrefix + ".Locator"; test(!b1->ice_getLocator()); prop->setProperty(property, "locator:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocator() && b1->ice_getLocator()->ice_getIdentity().name == "locator"); prop->setProperty(property, ""); property = propertyPrefix + ".LocatorCacheTimeout"; test(b1->ice_getLocatorCacheTimeout() == -1); prop->setProperty(property, "1"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocatorCacheTimeout() == 1); prop->setProperty(property, ""); // Now retest with an indirect proxy. prop->setProperty(propertyPrefix, "test"); property = propertyPrefix + ".Locator"; prop->setProperty(property, "locator:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocator() && b1->ice_getLocator()->ice_getIdentity().name == "locator"); prop->setProperty(property, ""); property = propertyPrefix + ".LocatorCacheTimeout"; test(b1->ice_getLocatorCacheTimeout() == -1); prop->setProperty(property, "1"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getLocatorCacheTimeout() == 1); prop->setProperty(property, ""); // This cannot be tested so easily because the property is cached // on communicator initialization. // //prop->setProperty("Ice.Default.LocatorCacheTimeout", "60"); //b1 = communicator->propertyToProxy(propertyPrefix); //test(b1->ice_getLocatorCacheTimeout() == 60); //prop->setProperty("Ice.Default.LocatorCacheTimeout", ""); prop->setProperty(propertyPrefix, "test:default -p 12010"); property = propertyPrefix + ".Router"; test(!b1->ice_getRouter()); prop->setProperty(property, "router:default -p 10000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getRouter() && b1->ice_getRouter()->ice_getIdentity().name == "router"); prop->setProperty(property, ""); property = propertyPrefix + ".PreferSecure"; test(!b1->ice_isPreferSecure()); prop->setProperty(property, "1"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_isPreferSecure()); prop->setProperty(property, ""); property = propertyPrefix + ".ConnectionCached"; test(b1->ice_isConnectionCached()); prop->setProperty(property, "0"); b1 = communicator->propertyToProxy(propertyPrefix); test(!b1->ice_isConnectionCached()); prop->setProperty(property, ""); property = propertyPrefix + ".InvocationTimeout"; test(b1->ice_getInvocationTimeout() == -1); prop->setProperty(property, "1000"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getInvocationTimeout() == 1000); prop->setProperty(property, ""); property = propertyPrefix + ".EndpointSelection"; test(b1->ice_getEndpointSelection() == Ice::Random); prop->setProperty(property, "Random"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getEndpointSelection() == Ice::Random); prop->setProperty(property, "Ordered"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getEndpointSelection() == Ice::Ordered); prop->setProperty(property, ""); property = propertyPrefix + ".CollocationOptimized"; test(b1->ice_isCollocationOptimized()); prop->setProperty(property, "0"); b1 = communicator->propertyToProxy(propertyPrefix); test(!b1->ice_isCollocationOptimized()); prop->setProperty(property, ""); property = propertyPrefix + ".Context.c1"; test(b1->ice_getContext()["c1"].empty()); prop->setProperty(property, "TEST"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getContext()["c1"] == "TEST"); property = propertyPrefix + ".Context.c2"; test(b1->ice_getContext()["c2"].empty()); prop->setProperty(property, "TEST"); b1 = communicator->propertyToProxy(propertyPrefix); test(b1->ice_getContext()["c2"] == "TEST"); prop->setProperty(propertyPrefix + ".Context.c1", ""); prop->setProperty(propertyPrefix + ".Context.c2", ""); cout << "ok" << endl; cout << "testing proxyToProperty... " << flush; b1 = communicator->stringToProxy("test"); b1 = b1->ice_collocationOptimized(true); b1 = b1->ice_connectionCached(true); b1 = b1->ice_preferSecure(false); b1 = b1->ice_endpointSelection(Ice::Ordered); b1 = b1->ice_locatorCacheTimeout(100); b1 = b1->ice_invocationTimeout(1234); Ice::EncodingVersion v = { 1, 0 }; b1 = b1->ice_encodingVersion(v); Ice::ObjectPrx router = communicator->stringToProxy("router"); router = router->ice_collocationOptimized(false); router = router->ice_connectionCached(true); router = router->ice_preferSecure(true); router = router->ice_endpointSelection(Ice::Random); router = router->ice_locatorCacheTimeout(200); router = router->ice_invocationTimeout(1500); Ice::ObjectPrx locator = communicator->stringToProxy("locator"); locator = locator->ice_collocationOptimized(true); locator = locator->ice_connectionCached(false); locator = locator->ice_preferSecure(true); locator = locator->ice_endpointSelection(Ice::Random); locator = locator->ice_locatorCacheTimeout(300); locator = locator->ice_invocationTimeout(1500); locator = locator->ice_router(Ice::RouterPrx::uncheckedCast(router)); b1 = b1->ice_locator(Ice::LocatorPrx::uncheckedCast(locator)); Ice::PropertyDict proxyProps = communicator->proxyToProperty(b1, "Test"); test(proxyProps.size() == 21); test(proxyProps["Test"] == "test -t -e 1.0"); test(proxyProps["Test.CollocationOptimized"] == "1"); test(proxyProps["Test.ConnectionCached"] == "1"); test(proxyProps["Test.PreferSecure"] == "0"); test(proxyProps["Test.EndpointSelection"] == "Ordered"); test(proxyProps["Test.LocatorCacheTimeout"] == "100"); test(proxyProps["Test.InvocationTimeout"] == "1234"); test(proxyProps["Test.Locator"] == "locator -t -e " + Ice::encodingVersionToString(Ice::currentEncoding)); // Locator collocation optimization is always disabled. //test(proxyProps["Test.Locator.CollocationOptimized"] == "1"); test(proxyProps["Test.Locator.ConnectionCached"] == "0"); test(proxyProps["Test.Locator.PreferSecure"] == "1"); test(proxyProps["Test.Locator.EndpointSelection"] == "Random"); test(proxyProps["Test.Locator.LocatorCacheTimeout"] == "300"); test(proxyProps["Test.Locator.InvocationTimeout"] == "1500"); test(proxyProps["Test.Locator.Router"] == "router -t -e " + Ice::encodingVersionToString(Ice::currentEncoding)); test(proxyProps["Test.Locator.Router.CollocationOptimized"] == "0"); test(proxyProps["Test.Locator.Router.ConnectionCached"] == "1"); test(proxyProps["Test.Locator.Router.PreferSecure"] == "1"); test(proxyProps["Test.Locator.Router.EndpointSelection"] == "Random"); test(proxyProps["Test.Locator.Router.LocatorCacheTimeout"] == "200"); test(proxyProps["Test.Locator.Router.InvocationTimeout"] == "1500"); cout << "ok" << endl; cout << "testing ice_getCommunicator... " << flush; test(base->ice_getCommunicator() == communicator); cout << "ok" << endl; cout << "testing proxy methods... " << flush; test(communicator->identityToString(base->ice_identity(communicator->stringToIdentity("other"))->ice_getIdentity()) == "other"); test(base->ice_facet("facet")->ice_getFacet() == "facet"); test(base->ice_adapterId("id")->ice_getAdapterId() == "id"); test(base->ice_twoway()->ice_isTwoway()); test(base->ice_oneway()->ice_isOneway()); test(base->ice_batchOneway()->ice_isBatchOneway()); test(base->ice_datagram()->ice_isDatagram()); test(base->ice_batchDatagram()->ice_isBatchDatagram()); test(base->ice_secure(true)->ice_isSecure()); test(!base->ice_secure(false)->ice_isSecure()); test(base->ice_collocationOptimized(true)->ice_isCollocationOptimized()); test(!base->ice_collocationOptimized(false)->ice_isCollocationOptimized()); test(base->ice_preferSecure(true)->ice_isPreferSecure()); test(!base->ice_preferSecure(false)->ice_isPreferSecure()); test(base->ice_encodingVersion(Ice::Encoding_1_0)->ice_getEncodingVersion() == Ice::Encoding_1_0); test(base->ice_encodingVersion(Ice::Encoding_1_1)->ice_getEncodingVersion() == Ice::Encoding_1_1); test(base->ice_encodingVersion(Ice::Encoding_1_0)->ice_getEncodingVersion() != Ice::Encoding_1_1); try { base->ice_timeout(0); test(false); } catch(const IceUtil::IllegalArgumentException&) { } try { base->ice_timeout(-1); } catch(const IceUtil::IllegalArgumentException&) { test(false); } try { base->ice_timeout(-2); test(false); } catch(const IceUtil::IllegalArgumentException&) { } try { base->ice_invocationTimeout(0); test(false); } catch(const IceUtil::IllegalArgumentException&) { } try { base->ice_invocationTimeout(-1); base->ice_invocationTimeout(-2); } catch(const IceUtil::IllegalArgumentException&) { test(false); } try { base->ice_invocationTimeout(-3); test(false); } catch(const IceUtil::IllegalArgumentException&) { } try { base->ice_locatorCacheTimeout(0); } catch(const IceUtil::IllegalArgumentException&) { test(false); } try { base->ice_locatorCacheTimeout(-1); } catch(const IceUtil::IllegalArgumentException&) { test(false); } try { base->ice_locatorCacheTimeout(-2); test(false); } catch(const IceUtil::IllegalArgumentException&) { } cout << "ok" << endl; cout << "testing proxy comparison... " << flush; test(communicator->stringToProxy("foo") == communicator->stringToProxy("foo")); test(communicator->stringToProxy("foo") != communicator->stringToProxy("foo2")); test(communicator->stringToProxy("foo") < communicator->stringToProxy("foo2")); test(!(communicator->stringToProxy("foo2") < communicator->stringToProxy("foo"))); Ice::ObjectPrx compObj = communicator->stringToProxy("foo"); test(compObj->ice_facet("facet") == compObj->ice_facet("facet")); test(compObj->ice_facet("facet") != compObj->ice_facet("facet1")); test(compObj->ice_facet("facet") < compObj->ice_facet("facet1")); test(!(compObj->ice_facet("facet") < compObj->ice_facet("facet"))); test(compObj->ice_oneway() == compObj->ice_oneway()); test(compObj->ice_oneway() != compObj->ice_twoway()); test(compObj->ice_twoway() < compObj->ice_oneway()); test(!(compObj->ice_oneway() < compObj->ice_twoway())); test(compObj->ice_secure(true) == compObj->ice_secure(true)); test(compObj->ice_secure(false) != compObj->ice_secure(true)); test(compObj->ice_secure(false) < compObj->ice_secure(true)); test(!(compObj->ice_secure(true) < compObj->ice_secure(false))); test(compObj->ice_collocationOptimized(true) == compObj->ice_collocationOptimized(true)); test(compObj->ice_collocationOptimized(false) != compObj->ice_collocationOptimized(true)); test(compObj->ice_collocationOptimized(false) < compObj->ice_collocationOptimized(true)); test(!(compObj->ice_collocationOptimized(true) < compObj->ice_collocationOptimized(false))); test(compObj->ice_connectionCached(true) == compObj->ice_connectionCached(true)); test(compObj->ice_connectionCached(false) != compObj->ice_connectionCached(true)); test(compObj->ice_connectionCached(false) < compObj->ice_connectionCached(true)); test(!(compObj->ice_connectionCached(true) < compObj->ice_connectionCached(false))); test(compObj->ice_endpointSelection(Ice::Random) == compObj->ice_endpointSelection(Ice::Random)); test(compObj->ice_endpointSelection(Ice::Random) != compObj->ice_endpointSelection(Ice::Ordered)); test(compObj->ice_endpointSelection(Ice::Random) < compObj->ice_endpointSelection(Ice::Ordered)); test(!(compObj->ice_endpointSelection(Ice::Ordered) < compObj->ice_endpointSelection(Ice::Random))); test(compObj->ice_connectionId("id2") == compObj->ice_connectionId("id2")); test(compObj->ice_connectionId("id1") != compObj->ice_connectionId("id2")); test(compObj->ice_connectionId("id1") < compObj->ice_connectionId("id2")); test(!(compObj->ice_connectionId("id2") < compObj->ice_connectionId("id1"))); test(compObj->ice_connectionId("id1")->ice_getConnectionId() == "id1"); test(compObj->ice_connectionId("id2")->ice_getConnectionId() == "id2"); test(compObj->ice_compress(true) == compObj->ice_compress(true)); test(compObj->ice_compress(false) != compObj->ice_compress(true)); test(compObj->ice_compress(false) < compObj->ice_compress(true)); test(!(compObj->ice_compress(true) < compObj->ice_compress(false))); test(compObj->ice_timeout(20) == compObj->ice_timeout(20)); test(compObj->ice_timeout(10) != compObj->ice_timeout(20)); test(compObj->ice_timeout(10) < compObj->ice_timeout(20)); test(!(compObj->ice_timeout(20) < compObj->ice_timeout(10))); Ice::LocatorPrx loc1 = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("loc1:default -p 10000")); Ice::LocatorPrx loc2 = Ice::LocatorPrx::uncheckedCast(communicator->stringToProxy("loc2:default -p 10000")); test(compObj->ice_locator(0) == compObj->ice_locator(0)); test(compObj->ice_locator(loc1) == compObj->ice_locator(loc1)); test(compObj->ice_locator(loc1) != compObj->ice_locator(0)); test(compObj->ice_locator(0) != compObj->ice_locator(loc2)); test(compObj->ice_locator(loc1) != compObj->ice_locator(loc2)); test(compObj->ice_locator(0) < compObj->ice_locator(loc1)); test(!(compObj->ice_locator(loc1) < compObj->ice_locator(0))); test(compObj->ice_locator(loc1) < compObj->ice_locator(loc2)); test(!(compObj->ice_locator(loc2) < compObj->ice_locator(loc1))); Ice::RouterPrx rtr1 = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("rtr1:default -p 10000")); Ice::RouterPrx rtr2 = Ice::RouterPrx::uncheckedCast(communicator->stringToProxy("rtr2:default -p 10000")); test(compObj->ice_router(0) == compObj->ice_router(0)); test(compObj->ice_router(rtr1) == compObj->ice_router(rtr1)); test(compObj->ice_router(rtr1) != compObj->ice_router(0)); test(compObj->ice_router(0) != compObj->ice_router(rtr2)); test(compObj->ice_router(rtr1) != compObj->ice_router(rtr2)); test(compObj->ice_router(0) < compObj->ice_router(rtr1)); test(!(compObj->ice_router(rtr1) < compObj->ice_router(0))); test(compObj->ice_router(rtr1) < compObj->ice_router(rtr2)); test(!(compObj->ice_router(rtr2) < compObj->ice_router(rtr1))); Ice::Context ctx1; ctx1["ctx1"] = "v1"; Ice::Context ctx2; ctx2["ctx2"] = "v2"; test(compObj->ice_context(Ice::Context()) == compObj->ice_context(Ice::Context())); test(compObj->ice_context(ctx1) == compObj->ice_context(ctx1)); test(compObj->ice_context(ctx1) != compObj->ice_context(Ice::Context())); test(compObj->ice_context(Ice::Context()) != compObj->ice_context(ctx2)); test(compObj->ice_context(ctx1) != compObj->ice_context(ctx2)); test(compObj->ice_context(ctx1) < compObj->ice_context(ctx2)); test(!(compObj->ice_context(ctx2) < compObj->ice_context(ctx1))); test(compObj->ice_preferSecure(true) == compObj->ice_preferSecure(true)); test(compObj->ice_preferSecure(true) != compObj->ice_preferSecure(false)); test(compObj->ice_preferSecure(false) < compObj->ice_preferSecure(true)); test(!(compObj->ice_preferSecure(true) < compObj->ice_preferSecure(false))); Ice::ObjectPrx compObj1 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10000"); Ice::ObjectPrx compObj2 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10001"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); compObj1 = communicator->stringToProxy("foo@MyAdapter1"); compObj2 = communicator->stringToProxy("foo@MyAdapter2"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); test(compObj1->ice_locatorCacheTimeout(20) == compObj1->ice_locatorCacheTimeout(20)); test(compObj1->ice_locatorCacheTimeout(10) != compObj1->ice_locatorCacheTimeout(20)); test(compObj1->ice_locatorCacheTimeout(10) < compObj1->ice_locatorCacheTimeout(20)); test(!(compObj1->ice_locatorCacheTimeout(20) < compObj1->ice_locatorCacheTimeout(10))); test(compObj1->ice_invocationTimeout(20) == compObj1->ice_invocationTimeout(20)); test(compObj1->ice_invocationTimeout(10) != compObj1->ice_invocationTimeout(20)); test(compObj1->ice_invocationTimeout(10) < compObj1->ice_invocationTimeout(20)); test(!(compObj1->ice_invocationTimeout(20) < compObj1->ice_invocationTimeout(10))); compObj1 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 1000"); compObj2 = communicator->stringToProxy("foo@MyAdapter1"); test(compObj1 != compObj2); test(compObj1 < compObj2); test(!(compObj2 < compObj1)); Ice::EndpointSeq endpts1 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10000")->ice_getEndpoints(); Ice::EndpointSeq endpts2 = communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10001")->ice_getEndpoints(); test(endpts1 != endpts2); test(endpts1 < endpts2); test(!(endpts2 < endpts1)); test(endpts1 == communicator->stringToProxy("foo:tcp -h 127.0.0.1 -p 10000")->ice_getEndpoints()); test(compObj1->ice_encodingVersion(Ice::Encoding_1_0) == compObj1->ice_encodingVersion(Ice::Encoding_1_0)); test(compObj1->ice_encodingVersion(Ice::Encoding_1_0) != compObj1->ice_encodingVersion(Ice::Encoding_1_1)); test(compObj->ice_encodingVersion(Ice::Encoding_1_0) < compObj->ice_encodingVersion(Ice::Encoding_1_1)); test(!(compObj->ice_encodingVersion(Ice::Encoding_1_1) < compObj->ice_encodingVersion(Ice::Encoding_1_0))); // // TODO: Ideally we should also test comparison of fixed proxies. // cout << "ok" << endl; cout << "testing checked cast... " << flush; Test::MyClassPrx cl = Test::MyClassPrx::checkedCast(base); test(cl); Test::MyDerivedClassPrx derived = Test::MyDerivedClassPrx::checkedCast(cl); test(derived); test(cl == base); test(derived == base); test(cl == derived); Ice::LocatorPrx loc = Ice::LocatorPrx::checkedCast(base); test(loc == 0); // // Upcasting // Test::MyClassPrx cl2 = Test::MyClassPrx::checkedCast(derived); Ice::ObjectPrx obj = Ice::ObjectPrx::checkedCast(derived); test(cl2); test(obj); test(cl2 == obj); test(cl2 == derived); // // Now with alternate API // cl = checkedCast<Test::MyClassPrx>(base); test(cl); derived = checkedCast<Test::MyDerivedClassPrx>(cl); test(derived); test(cl == base); test(derived == base); test(cl == derived); loc = checkedCast<Ice::LocatorPrx>(base); test(loc == 0); cl2 = checkedCast<Test::MyClassPrx>(derived); obj = checkedCast<Ice::ObjectPrx>(derived); test(cl2); test(obj); test(cl2 == obj); test(cl2 == derived); cout << "ok" << endl; cout << "testing checked cast with context... " << flush; Ice::Context c = cl->getContext(); test(c.size() == 0); c["one"] = "hello"; c["two"] = "world"; cl = Test::MyClassPrx::checkedCast(base, c); Ice::Context c2 = cl->getContext(); test(c == c2); // // Now with alternate API // cl = checkedCast<Test::MyClassPrx>(base); c = cl->getContext(); test(c.size() == 0); cl = checkedCast<Test::MyClassPrx>(base, c); c2 = cl->getContext(); test(c == c2); cout << "ok" << endl; cout << "testing encoding versioning... " << flush; string ref20 = "test -e 2.0:default -p 12010"; Test::MyClassPrx cl20 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref20)); try { cl20->ice_ping(); test(false); } catch(const Ice::UnsupportedEncodingException&) { // Server 2.0 endpoint doesn't support 1.1 version. } string ref10 = "test -e 1.0:default -p 12010"; Test::MyClassPrx cl10 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref10)); cl10->ice_ping(); cl10->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); cl->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); // 1.3 isn't supported but since a 1.3 proxy supports 1.1, the // call will use the 1.1 encoding string ref13 = "test -e 1.3:default -p 12010"; Test::MyClassPrx cl13 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref13)); cl13->ice_ping(); cl13->end_ice_ping(cl13->begin_ice_ping()); try { // Send request with bogus 1.2 encoding. Ice::EncodingVersion version = { 1, 2 }; Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); out->startEncapsulation(); out->endEncapsulation(); vector<Ice::Byte> inEncaps; out->finished(inEncaps); inEncaps[4] = version.major; inEncaps[5] = version.minor; vector<Ice::Byte> outEncaps; cl->ice_invoke("ice_ping", Ice::Normal, inEncaps, outEncaps); test(false); } catch(const Ice::UnknownLocalException& ex) { // The server thrown an UnsupportedEncodingException test(ex.unknown.find("UnsupportedEncodingException") != string::npos); } try { // Send request with bogus 2.0 encoding. Ice::EncodingVersion version = { 2, 0 }; Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); out->startEncapsulation(); out->endEncapsulation(); vector<Ice::Byte> inEncaps; out->finished(inEncaps); inEncaps[4] = version.major; inEncaps[5] = version.minor; vector<Ice::Byte> outEncaps; cl->ice_invoke("ice_ping", Ice::Normal, inEncaps, outEncaps); test(false); } catch(const Ice::UnknownLocalException& ex) { // The server thrown an UnsupportedEncodingException test(ex.unknown.find("UnsupportedEncodingException") != string::npos); } cout << "ok" << endl; cout << "testing protocol versioning... " << flush; ref20 = "test -p 2.0:default -p 12010"; cl20 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref20)); try { cl20->ice_ping(); test(false); } catch(const Ice::UnsupportedProtocolException&) { // Server 2.0 proxy doesn't support 1.0 version. } ref10 = "test -p 1.0:default -p 12010"; cl10 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref10)); cl10->ice_ping(); // 1.3 isn't supported but since a 1.3 proxy supports 1.0, the // call will use the 1.0 encoding ref13 = "test -p 1.3:default -p 12010"; cl13 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref13)); cl13->ice_ping(); cl13->end_ice_ping(cl13->begin_ice_ping()); cout << "ok" <<endl; cout << "testing opaque endpoints... " << flush; try { // Invalid -x option Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 99 -v abc -x abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -t and -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Repeated -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -t 1 -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Repeated -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -v abc -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing arg for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Missing arg for -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 1 -v"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Not a number for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t x -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // < 0 for -t Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t -1 -v abc"); test(false); } catch(const Ice::EndpointParseException&) { } try { // Invalid char for -v Ice::ObjectPrx p = communicator->stringToProxy("id:opaque -t 99 -v x?c"); test(false); } catch(const Ice::EndpointParseException&) { } // Legal TCP endpoint expressed as opaque endpoint Ice::ObjectPrx p1 = communicator->stringToProxy("test -e 1.1:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA=="); string pstr = communicator->proxyToString(p1); test(pstr == "test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000"); // Opaque endpoint encoded with 1.1 encoding. Ice::ObjectPrx p2 = communicator->stringToProxy("test -e 1.1:opaque -e 1.1 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA=="); test(communicator->proxyToString(p2) == "test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000"); if(communicator->getProperties()->getPropertyAsInt("Ice.IPv6") == 0) { // Working? #ifndef ICE_OS_WINRT const bool ssl = communicator->getProperties()->getProperty("Ice.Default.Protocol") == "ssl"; #else const bool ssl = true; #endif const bool tcp = communicator->getProperties()->getProperty("Ice.Default.Protocol") == "tcp"; if(tcp) { p1->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); } // Two legal TCP endpoints expressed as opaque endpoints p1 = communicator->stringToProxy("test -e 1.0:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMusuAAAQJwAAAA=="); pstr = communicator->proxyToString(p1); test(pstr == "test -t -e 1.0:tcp -h 127.0.0.1 -p 12010 -t 10000:tcp -h 127.0.0.2 -p 12011 -t 10000"); // // Test that an SSL endpoint and a nonsense endpoint get written // back out as an opaque endpoint. // p1 = communicator->stringToProxy( "test -e 1.0:opaque -e 1.0 -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -e 1.0 -t 99 -v abch"); pstr = communicator->proxyToString(p1); if(ssl) { test(pstr == "test -t -e 1.0:ssl -h 127.0.0.1 -p 10001 -t infinite:opaque -t 99 -e 1.0 -v abch"); } else if(tcp) { test(pstr == "test -t -e 1.0:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch"); } // // Try to invoke on the endpoint to verify that we get a // NoEndpointException (or ConnectionRefusedException when // running with SSL). // if(ssl) { try { p1->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); test(false); } catch(const Ice::ConnectFailedException&) { } } // // Test that the proxy with an SSL endpoint and a nonsense // endpoint (which the server doesn't understand either) can be // sent over the wire and returned by the server without losing // the opaque endpoints. // Ice::ObjectPrx p2 = derived->echo(p1); pstr = communicator->proxyToString(p2); if(ssl) { test(pstr == "test -t -e 1.0:ssl -h 127.0.0.1 -p 10001 -t infinite:opaque -t 99 -e 1.0 -v abch"); } else if(tcp) { test(pstr == "test -t -e 1.0:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch"); } } cout << "ok" << endl; return cl; }
void PluginI::initialize() { Ice::PropertiesPtr properties = _communicator->getProperties(); bool ipv4 = properties->getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0; bool preferIPv6 = properties->getPropertyAsInt("Ice.PreferIPv6Address") > 0; string address; if(ipv4 && !preferIPv6) { address = properties->getPropertyWithDefault("IceDiscovery.Address", "239.255.0.1"); } else { address = properties->getPropertyWithDefault("IceDiscovery.Address", "ff15::1"); } int port = properties->getPropertyAsIntWithDefault("IceDiscovery.Port", 4061); string interface = properties->getProperty("IceDiscovery.Interface"); if(properties->getProperty("IceDiscovery.Multicast.Endpoints").empty()) { ostringstream os; os << "udp -h \"" << address << "\" -p " << port; if(!interface.empty()) { os << " --interface \"" << interface << "\""; } properties->setProperty("IceDiscovery.Multicast.Endpoints", os.str()); } if(properties->getProperty("IceDiscovery.Reply.Endpoints").empty()) { ostringstream os; os << "udp"; if(!interface.empty()) { os << " -h \"" << interface << "\""; } properties->setProperty("IceDiscovery.Reply.Endpoints", os.str()); } if(properties->getProperty("IceDiscovery.Locator.Endpoints").empty()) { properties->setProperty("IceDiscovery.Locator.AdapterId", IceUtil::generateUUID()); } _multicastAdapter = _communicator->createObjectAdapter("IceDiscovery.Multicast"); _replyAdapter = _communicator->createObjectAdapter("IceDiscovery.Reply"); _locatorAdapter = _communicator->createObjectAdapter("IceDiscovery.Locator"); // // Setup locatory registry. // LocatorRegistryIPtr locatorRegistry = new LocatorRegistryI(_communicator); Ice::LocatorRegistryPrx locatorRegistryPrx = Ice::LocatorRegistryPrx::uncheckedCast(_locatorAdapter->addWithUUID(locatorRegistry)); string lookupEndpoints = properties->getProperty("IceDiscovery.Lookup"); if(lookupEndpoints.empty()) { ostringstream os; os << "udp -h \"" << address << "\" -p " << port; if(!interface.empty()) { os << " --interface \"" << interface << "\""; } lookupEndpoints = os.str(); } Ice::ObjectPrx lookupPrx = _communicator->stringToProxy("IceDiscovery/Lookup -d:" + lookupEndpoints); lookupPrx = lookupPrx->ice_collocationOptimized(false); // No collocation optimization for the multicast proxy! try { // Ensure we can establish a connection to the multicast proxy // but don't block. Ice::AsyncResultPtr result = lookupPrx->begin_ice_getConnection(); if(result->sentSynchronously()) { lookupPrx->end_ice_getConnection(result); } } catch(const Ice::LocalException& ex) { ostringstream os; os << "IceDiscovery is unable to establish a multicast connection:\n"; os << "proxy = " << lookupPrx << '\n'; os << ex; throw Ice::PluginInitializationException(__FILE__, __LINE__, os.str()); } // // Add lookup and lookup reply Ice objects // _lookup = new LookupI(locatorRegistry, LookupPrx::uncheckedCast(lookupPrx), properties); _multicastAdapter->add(_lookup, _communicator->stringToIdentity("IceDiscovery/Lookup")); Ice::ObjectPrx lookupReply = _replyAdapter->addWithUUID(new LookupReplyI(_lookup))->ice_datagram(); _lookup->setLookupReply(LookupReplyPrx::uncheckedCast(lookupReply)); // // Setup locator on the communicator. // Ice::ObjectPrx loc = _locatorAdapter->addWithUUID(new LocatorI(_lookup, locatorRegistryPrx)); _communicator->setDefaultLocator(Ice::LocatorPrx::uncheckedCast(loc)); _multicastAdapter->activate(); _replyAdapter->activate(); _locatorAdapter->activate(); }