diff options
Diffstat (limited to 'cpp')
36 files changed, 373 insertions, 640 deletions
diff --git a/cpp/config/Make.rules.MINGW b/cpp/config/Make.rules.MINGW index 29d9c3dba4e..63d2a6a524f 100644 --- a/cpp/config/Make.rules.MINGW +++ b/cpp/config/Make.rules.MINGW @@ -29,7 +29,6 @@ ifeq ($(OPTIMIZE),yes) CXXFLAGS += -O2 -DNDEBUG else CXXFLAGS += -g -D_DEBUG - LIBSUFFIX = d endif COMPSUFFIX = mingw_ diff --git a/cpp/src/Ice/EndpointI.cpp b/cpp/src/Ice/EndpointI.cpp index e9762fe2eec..0115a5f31cc 100644 --- a/cpp/src/Ice/EndpointI.cpp +++ b/cpp/src/Ice/EndpointI.cpp @@ -46,18 +46,6 @@ Init init; Ice::LocalObject* IceInternal::upCast(EndpointI* p) { return p; } IceUtil::Shared* IceInternal::upCast(EndpointHostResolver* p) { return p; } -const Ice::EncodingVersion& -IceInternal::EndpointI::encodingVersion() const -{ - return _encoding; -} - -const Ice::ProtocolVersion& -IceInternal::EndpointI::protocolVersion() const -{ - return _protocol; -} - const string& IceInternal::EndpointI::connectionId() const { @@ -86,74 +74,17 @@ IceInternal::EndpointI::connectors(const vector<Address>& addrs) const return vector<ConnectorPtr>(); } -IceInternal::EndpointI::EndpointI(const Ice::ProtocolVersion& protocol, - const Ice::EncodingVersion& encoding, - const std::string& connectionId) : - _protocol(protocol), - _encoding(encoding), +IceInternal::EndpointI::EndpointI(const std::string& connectionId) : _connectionId(connectionId), _hashInitialized(false) { } IceInternal::EndpointI::EndpointI() : - _protocol(Ice::currentProtocol), - _encoding(Ice::currentEncoding), _hashInitialized(false) { } -void -IceInternal::EndpointI::parseOption(const string& option, const string& arg, const string& desc, const string& str) -{ - if(option == "-v") - { - if(arg.empty()) - { - Ice::EndpointParseException ex(__FILE__, __LINE__); - ex.str = "no argument provided for -v option in endpoint `" + desc + " " + str + "'"; - throw ex; - } - - try - { - const_cast<Ice::ProtocolVersion&>(_protocol) = Ice::stringToProtocolVersion(arg); - } - catch(const Ice::VersionParseException& e) - { - Ice::EndpointParseException ex(__FILE__, __LINE__); - ex.str = "invalid protocol version `" + arg + "' in endpoint `" + desc + " " + str + "':\n" + e.str; - throw ex; - } - } - else if(option == "-e") - { - if(arg.empty()) - { - Ice::EndpointParseException ex(__FILE__, __LINE__); - ex.str = "no argument provided for -e option in endpoint `" + desc + " " + str + "'"; - throw ex; - } - - try - { - const_cast<Ice::EncodingVersion&>(_encoding) = Ice::stringToEncodingVersion(arg); - } - catch(const Ice::VersionParseException& e) - { - Ice::EndpointParseException ex(__FILE__, __LINE__); - ex.str = "invalid encoding version `" + arg + "' in endpoint `" + desc + " " + str + "':\n" + e.str; - throw ex; - } - } - else - { - Ice::EndpointParseException ex(__FILE__, __LINE__); - ex.str = "unknown option `" + option + "' in `" + desc + " " + str + "'"; - throw ex; - } -} - #ifndef ICE_OS_WINRT IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& instance) : diff --git a/cpp/src/Ice/EndpointI.h b/cpp/src/Ice/EndpointI.h index 17f079d1c1e..e7e1a208f19 100644 --- a/cpp/src/Ice/EndpointI.h +++ b/cpp/src/Ice/EndpointI.h @@ -105,16 +105,6 @@ public: virtual bool secure() const = 0; // - // Returns the encoding version supported by this endpoint. - // - const ::Ice::EncodingVersion& encodingVersion() const; - - // - // Returns the encoding version supported by this endpoint. - // - const ::Ice::ProtocolVersion& protocolVersion() const; - - // // Return a server side transceiver for this endpoint, or null if a // transceiver can only be created by an acceptor. In case a // transceiver is created, this operation also returns a new @@ -165,15 +155,11 @@ protected: virtual std::vector<ConnectorPtr> connectors(const std::vector<Address>&) const; friend class EndpointHostResolver; - EndpointI(const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::string&); + EndpointI(const std::string&); EndpointI(); - void parseOption(const std::string&, const std::string&, const std::string&, const std::string&); - virtual ::Ice::Int hashInit() const = 0; - const Ice::ProtocolVersion _protocol; - const Ice::EncodingVersion _encoding; const std::string _connectionId; private: diff --git a/cpp/src/Ice/InstrumentationI.h b/cpp/src/Ice/InstrumentationI.h index d8f9641c76c..035aed387cc 100644 --- a/cpp/src/Ice/InstrumentationI.h +++ b/cpp/src/Ice/InstrumentationI.h @@ -24,8 +24,6 @@ void addEndpointAttributes(typename Helper::Attributes& attrs) attrs.add("endpointType", &Helper::getEndpointInfo, &Ice::EndpointInfo::type); attrs.add("endpointIsDatagram", &Helper::getEndpointInfo, &Ice::EndpointInfo::datagram); attrs.add("endpointIsSecure", &Helper::getEndpointInfo, &Ice::EndpointInfo::secure); - attrs.add("endpointProtocolVersion", &Helper::getEndpointInfo, &Ice::EndpointInfo::protocol); - attrs.add("endpointEncodingVersion", &Helper::getEndpointInfo, &Ice::EndpointInfo::encoding); attrs.add("endpointTimeout", &Helper::getEndpointInfo, &Ice::EndpointInfo::timeout); attrs.add("endpointCompress", &Helper::getEndpointInfo, &Ice::EndpointInfo::compress); diff --git a/cpp/src/Ice/LocatorInfo.cpp b/cpp/src/Ice/LocatorInfo.cpp index ac693041b2e..0acf9db3f90 100644 --- a/cpp/src/Ice/LocatorInfo.cpp +++ b/cpp/src/Ice/LocatorInfo.cpp @@ -156,16 +156,17 @@ IceInternal::LocatorManager::get(const LocatorPrx& loc) // have only one table per locator (not one per locator // proxy). // - map<Identity, LocatorTablePtr>::iterator t = _locatorTables.find(locator->ice_getIdentity()); + pair<Identity, EncodingVersion> locatorKey(locator->ice_getIdentity(), locator->ice_getEncodingVersion()); + map<pair<Identity, EncodingVersion>, LocatorTablePtr>::iterator t = _locatorTables.find(locatorKey); if(t == _locatorTables.end()) { t = _locatorTables.insert(_locatorTables.begin(), - pair<const Identity, LocatorTablePtr>(locator->ice_getIdentity(), - new LocatorTable())); + pair<const pair<Identity, EncodingVersion>, LocatorTablePtr>( + locatorKey, new LocatorTable())); } - _tableHint = _table.insert(_tableHint, - pair<const LocatorPrx, LocatorInfoPtr>(locator, + _tableHint = _table.insert(_tableHint, + pair<const LocatorPrx, LocatorInfoPtr>(locator, new LocatorInfo(locator, t->second, _background))); } @@ -536,15 +537,6 @@ IceInternal::LocatorInfo::operator<(const LocatorInfo& rhs) const return _locator < rhs._locator; } -LocatorPrx -IceInternal::LocatorInfo::getLocator() const -{ - // - // No mutex lock necessary, _locator is immutable. - // - return _locator; -} - LocatorRegistryPrx IceInternal::LocatorInfo::getLocatorRegistry() { diff --git a/cpp/src/Ice/LocatorInfo.h b/cpp/src/Ice/LocatorInfo.h index 9a863107e38..15d4ad3075a 100644 --- a/cpp/src/Ice/LocatorInfo.h +++ b/cpp/src/Ice/LocatorInfo.h @@ -20,6 +20,7 @@ #include <Ice/Identity.h> #include <Ice/EndpointIF.h> #include <Ice/PropertiesF.h> +#include <Ice/Version.h> #include <IceUtil/UniquePtr.h> @@ -47,7 +48,7 @@ private: std::map<Ice::LocatorPrx, LocatorInfoPtr> _table; std::map<Ice::LocatorPrx, LocatorInfoPtr>::iterator _tableHint; - std::map<Ice::Identity, LocatorTablePtr> _locatorTables; + std::map<std::pair<Ice::Identity, Ice::EncodingVersion>, LocatorTablePtr> _locatorTables; }; class LocatorTable : public IceUtil::Shared, public IceUtil::Mutex @@ -143,7 +144,13 @@ public: bool operator!=(const LocatorInfo&) const; bool operator<(const LocatorInfo&) const; - Ice::LocatorPrx getLocator() const; + const Ice::LocatorPrx& getLocator() const + { + // + // No mutex lock necessary, _locator is immutable. + // + return _locator; + } Ice::LocatorRegistryPrx getLocatorRegistry(); std::vector<EndpointIPtr> getEndpoints(const ReferencePtr& ref, int ttl, bool& cached) diff --git a/cpp/src/Ice/OpaqueEndpointI.cpp b/cpp/src/Ice/OpaqueEndpointI.cpp index 5b3bedbaedd..10b16984b56 100644 --- a/cpp/src/Ice/OpaqueEndpointI.cpp +++ b/cpp/src/Ice/OpaqueEndpointI.cpp @@ -25,7 +25,7 @@ const Ice::EncodingVersion Encoding_0_0 = { 0, 0 }; } IceInternal::OpaqueEndpointI::OpaqueEndpointI(const string& str) : - EndpointI(Protocol_0_0, Encoding_0_0, ""), + EndpointI(""), _rawEncoding(Ice::currentEncoding) { const string delim = " \t\n\r"; @@ -183,7 +183,7 @@ IceInternal::OpaqueEndpointI::OpaqueEndpointI(const string& str) : } IceInternal::OpaqueEndpointI::OpaqueEndpointI(Short type, BasicStream* s) : - EndpointI(Protocol_0_0, Encoding_0_0, ""), + EndpointI(""), _type(type) { _rawEncoding = s->startReadEncaps(); @@ -247,7 +247,7 @@ private: // COMPILERFIX: inlining this constructor causes crashes with gcc 4.0.1. // InfoI::InfoI(Ice::Short type, const Ice::EncodingVersion& rawEncoding, const Ice::ByteSeq& rawBytes) : - Ice::OpaqueEndpointInfo(Protocol_0_0, Encoding_0_0, -1, false, rawEncoding, rawBytes), + Ice::OpaqueEndpointInfo(-1, false, rawEncoding, rawBytes), _type(type) { } diff --git a/cpp/src/Ice/Outgoing.cpp b/cpp/src/Ice/Outgoing.cpp index c46b95bad14..85e15a53509 100644 --- a/cpp/src/Ice/Outgoing.cpp +++ b/cpp/src/Ice/Outgoing.cpp @@ -92,6 +92,8 @@ IceInternal::Outgoing::Outgoing(RequestHandler* handler, const string& operation _os(handler->getReference()->getInstance().get(), Ice::currentProtocolEncoding), _sent(false) { + checkSupportedProtocol(handler->getReference()->getProtocol()); + switch(_handler->getReference()->getMode()) { case Reference::ModeTwoway: @@ -561,6 +563,7 @@ IceInternal::BatchOutgoing::BatchOutgoing(RequestHandler* handler, InvocationObs _os(handler->getReference()->getInstance().get(), Ice::currentProtocolEncoding), _observer(observer) { + checkSupportedProtocol(handler->getReference()->getProtocol()); } IceInternal::BatchOutgoing::BatchOutgoing(ConnectionI* connection, Instance* instance, InvocationObserver& observer) : diff --git a/cpp/src/Ice/OutgoingAsync.cpp b/cpp/src/Ice/OutgoingAsync.cpp index 5dd2238944f..33ac9dee0f5 100644 --- a/cpp/src/Ice/OutgoingAsync.cpp +++ b/cpp/src/Ice/OutgoingAsync.cpp @@ -438,6 +438,8 @@ IceInternal::OutgoingAsync::__prepare(const std::string& operation, OperationMod _mode = mode; _sentSynchronously = false; + checkSupportedProtocol(_proxy->__reference()->getProtocol()); + _observer.attach(_proxy.get(), operation, context); // @@ -935,6 +937,8 @@ IceInternal::ProxyBatchOutgoingAsync::ProxyBatchOutgoingAsync(const Ice::ObjectP void IceInternal::ProxyBatchOutgoingAsync::__send() { + checkSupportedProtocol(_proxy->__reference()->getProtocol()); + // // We don't automatically retry if ice_flushBatchRequests fails. Otherwise, if some batch // requests were queued with the connection, they would be lost without being noticed. diff --git a/cpp/src/Ice/PropertyNames.cpp b/cpp/src/Ice/PropertyNames.cpp index e9e05239474..62d94b80fa7 100644 --- a/cpp/src/Ice/PropertyNames.cpp +++ b/cpp/src/Ice/PropertyNames.cpp @@ -8,7 +8,7 @@ // ********************************************************************** // -// Generated by makeprops.py from file ../config/PropertyNames.xml, Mon Oct 22 18:48:40 2012 +// Generated by makeprops.py from file ./config/PropertyNames.xml, Mon Nov 12 21:17:34 2012 // IMPORTANT: Do not edit this file -- any edits made here will be lost! @@ -27,7 +27,6 @@ const IceInternal::Property IcePropsData[] = IceInternal::Property("Ice.Admin.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("Ice.Admin.Locator.Locator", false, 0), IceInternal::Property("Ice.Admin.Locator.Router", false, 0), - IceInternal::Property("Ice.Admin.Locator.EncodingVersion", false, 0), IceInternal::Property("Ice.Admin.Locator.CollocationOptimized", false, 0), IceInternal::Property("Ice.Admin.Locator", false, 0), IceInternal::Property("Ice.Admin.PublishedEndpoints", false, 0), @@ -38,7 +37,6 @@ const IceInternal::Property IcePropsData[] = IceInternal::Property("Ice.Admin.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("Ice.Admin.Router.Locator", false, 0), IceInternal::Property("Ice.Admin.Router.Router", false, 0), - IceInternal::Property("Ice.Admin.Router.EncodingVersion", false, 0), IceInternal::Property("Ice.Admin.Router.CollocationOptimized", false, 0), IceInternal::Property("Ice.Admin.Router", false, 0), IceInternal::Property("Ice.Admin.ProxyOptions", false, 0), @@ -69,7 +67,6 @@ const IceInternal::Property IcePropsData[] = IceInternal::Property("Ice.Default.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("Ice.Default.Locator.Locator", false, 0), IceInternal::Property("Ice.Default.Locator.Router", false, 0), - IceInternal::Property("Ice.Default.Locator.EncodingVersion", false, 0), IceInternal::Property("Ice.Default.Locator.CollocationOptimized", false, 0), IceInternal::Property("Ice.Default.Locator", false, 0), IceInternal::Property("Ice.Default.LocatorCacheTimeout", false, 0), @@ -82,7 +79,6 @@ const IceInternal::Property IcePropsData[] = IceInternal::Property("Ice.Default.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("Ice.Default.Router.Locator", false, 0), IceInternal::Property("Ice.Default.Router.Router", false, 0), - IceInternal::Property("Ice.Default.Router.EncodingVersion", false, 0), IceInternal::Property("Ice.Default.Router.CollocationOptimized", false, 0), IceInternal::Property("Ice.Default.Router", false, 0), IceInternal::Property("Ice.Default.SlicedFormat", false, 0), @@ -188,7 +184,6 @@ const IceInternal::Property IceBoxPropsData[] = IceInternal::Property("IceBox.ServiceManager.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("IceBox.ServiceManager.Locator.Locator", false, 0), IceInternal::Property("IceBox.ServiceManager.Locator.Router", false, 0), - IceInternal::Property("IceBox.ServiceManager.Locator.EncodingVersion", false, 0), IceInternal::Property("IceBox.ServiceManager.Locator.CollocationOptimized", false, 0), IceInternal::Property("IceBox.ServiceManager.Locator", false, 0), IceInternal::Property("IceBox.ServiceManager.PublishedEndpoints", false, 0), @@ -199,7 +194,6 @@ const IceInternal::Property IceBoxPropsData[] = IceInternal::Property("IceBox.ServiceManager.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("IceBox.ServiceManager.Router.Locator", false, 0), IceInternal::Property("IceBox.ServiceManager.Router.Router", false, 0), - IceInternal::Property("IceBox.ServiceManager.Router.EncodingVersion", false, 0), IceInternal::Property("IceBox.ServiceManager.Router.CollocationOptimized", false, 0), IceInternal::Property("IceBox.ServiceManager.Router", false, 0), IceInternal::Property("IceBox.ServiceManager.ProxyOptions", false, 0), @@ -226,7 +220,6 @@ const IceInternal::Property IceBoxAdminPropsData[] = IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.LocatorCacheTimeout", false, 0), IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.Locator", false, 0), IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.Router", false, 0), - IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.EncodingVersion", false, 0), IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy.CollocationOptimized", false, 0), IceInternal::Property("IceBoxAdmin.ServiceManager.Proxy", false, 0), }; @@ -261,7 +254,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Node.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Node.Locator.Locator", false, 0), IceInternal::Property("IceGrid.Node.Locator.Router", false, 0), - IceInternal::Property("IceGrid.Node.Locator.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Node.Locator.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Node.Locator", false, 0), IceInternal::Property("IceGrid.Node.PublishedEndpoints", false, 0), @@ -272,7 +264,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Node.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Node.Router.Locator", false, 0), IceInternal::Property("IceGrid.Node.Router.Router", false, 0), - IceInternal::Property("IceGrid.Node.Router.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Node.Router.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Node.Router", false, 0), IceInternal::Property("IceGrid.Node.ProxyOptions", false, 0), @@ -306,7 +297,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Node.UserAccountMapper.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Node.UserAccountMapper.Locator", false, 0), IceInternal::Property("IceGrid.Node.UserAccountMapper.Router", false, 0), - IceInternal::Property("IceGrid.Node.UserAccountMapper.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Node.UserAccountMapper.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Node.UserAccountMapper", false, 0), IceInternal::Property("IceGrid.Node.WaitTime", false, 0), @@ -317,7 +307,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.Locator", false, 0), IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.Router", false, 0), - IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.AdminPermissionsVerifier", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionFilters", false, 0), @@ -330,7 +319,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.Locator", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.Router", false, 0), - IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.Locator", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.PublishedEndpoints", false, 0), @@ -341,7 +329,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.Locator", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.Router", false, 0), - IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.Router", false, 0), IceInternal::Property("IceGrid.Registry.AdminSessionManager.ProxyOptions", false, 0), @@ -358,7 +345,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.Locator", false, 0), IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.Router", false, 0), - IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.AdminSSLPermissionsVerifier", false, 0), IceInternal::Property("IceGrid.Registry.Client.ACM", false, 0), @@ -370,7 +356,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.Client.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.Client.Locator.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Client.Locator.Router", false, 0), - IceInternal::Property("IceGrid.Registry.Client.Locator.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.Client.Locator.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.Client.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Client.PublishedEndpoints", false, 0), @@ -381,7 +366,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.Client.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.Client.Router.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Client.Router.Router", false, 0), - IceInternal::Property("IceGrid.Registry.Client.Router.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.Client.Router.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.Client.Router", false, 0), IceInternal::Property("IceGrid.Registry.Client.ProxyOptions", false, 0), @@ -405,7 +389,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.Internal.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.Internal.Locator.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Internal.Locator.Router", false, 0), - IceInternal::Property("IceGrid.Registry.Internal.Locator.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.Internal.Locator.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.Internal.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Internal.PublishedEndpoints", false, 0), @@ -416,7 +399,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.Internal.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.Internal.Router.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Internal.Router.Router", false, 0), - IceInternal::Property("IceGrid.Registry.Internal.Router.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.Internal.Router.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.Internal.Router", false, 0), IceInternal::Property("IceGrid.Registry.Internal.ProxyOptions", false, 0), @@ -434,7 +416,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.PermissionsVerifier.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.PermissionsVerifier.Locator", false, 0), IceInternal::Property("IceGrid.Registry.PermissionsVerifier.Router", false, 0), - IceInternal::Property("IceGrid.Registry.PermissionsVerifier.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.PermissionsVerifier.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.PermissionsVerifier", false, 0), IceInternal::Property("IceGrid.Registry.ReplicaName", false, 0), @@ -450,7 +431,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.Server.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.Server.Locator.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Server.Locator.Router", false, 0), - IceInternal::Property("IceGrid.Registry.Server.Locator.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.Server.Locator.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.Server.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Server.PublishedEndpoints", false, 0), @@ -461,7 +441,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.Server.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.Server.Router.Locator", false, 0), IceInternal::Property("IceGrid.Registry.Server.Router.Router", false, 0), - IceInternal::Property("IceGrid.Registry.Server.Router.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.Server.Router.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.Server.Router", false, 0), IceInternal::Property("IceGrid.Registry.Server.ProxyOptions", false, 0), @@ -482,7 +461,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.SessionManager.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.Locator.Locator", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.Locator.Router", false, 0), - IceInternal::Property("IceGrid.Registry.SessionManager.Locator.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.Locator.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.Locator", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.PublishedEndpoints", false, 0), @@ -493,7 +471,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.SessionManager.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.Router.Locator", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.Router.Router", false, 0), - IceInternal::Property("IceGrid.Registry.SessionManager.Router.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.Router.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.Router", false, 0), IceInternal::Property("IceGrid.Registry.SessionManager.ProxyOptions", false, 0), @@ -511,7 +488,6 @@ const IceInternal::Property IceGridPropsData[] = IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.LocatorCacheTimeout", false, 0), IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.Locator", false, 0), IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.Router", false, 0), - IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.EncodingVersion", false, 0), IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier.CollocationOptimized", false, 0), IceInternal::Property("IceGrid.Registry.SSLPermissionsVerifier", false, 0), IceInternal::Property("IceGrid.Registry.Trace.Application", false, 0), @@ -551,7 +527,6 @@ const IceInternal::Property IcePatch2PropsData[] = IceInternal::Property("IcePatch2.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("IcePatch2.Locator.Locator", false, 0), IceInternal::Property("IcePatch2.Locator.Router", false, 0), - IceInternal::Property("IcePatch2.Locator.EncodingVersion", false, 0), IceInternal::Property("IcePatch2.Locator.CollocationOptimized", false, 0), IceInternal::Property("IcePatch2.Locator", false, 0), IceInternal::Property("IcePatch2.PublishedEndpoints", false, 0), @@ -562,7 +537,6 @@ const IceInternal::Property IcePatch2PropsData[] = IceInternal::Property("IcePatch2.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("IcePatch2.Router.Locator", false, 0), IceInternal::Property("IcePatch2.Router.Router", false, 0), - IceInternal::Property("IcePatch2.Router.EncodingVersion", false, 0), IceInternal::Property("IcePatch2.Router.CollocationOptimized", false, 0), IceInternal::Property("IcePatch2.Router", false, 0), IceInternal::Property("IcePatch2.ProxyOptions", false, 0), @@ -658,7 +632,6 @@ const IceInternal::Property Glacier2PropsData[] = IceInternal::Property("Glacier2.Client.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("Glacier2.Client.Locator.Locator", false, 0), IceInternal::Property("Glacier2.Client.Locator.Router", false, 0), - IceInternal::Property("Glacier2.Client.Locator.EncodingVersion", false, 0), IceInternal::Property("Glacier2.Client.Locator.CollocationOptimized", false, 0), IceInternal::Property("Glacier2.Client.Locator", false, 0), IceInternal::Property("Glacier2.Client.PublishedEndpoints", false, 0), @@ -669,7 +642,6 @@ const IceInternal::Property Glacier2PropsData[] = IceInternal::Property("Glacier2.Client.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("Glacier2.Client.Router.Locator", false, 0), IceInternal::Property("Glacier2.Client.Router.Router", false, 0), - IceInternal::Property("Glacier2.Client.Router.EncodingVersion", false, 0), IceInternal::Property("Glacier2.Client.Router.CollocationOptimized", false, 0), IceInternal::Property("Glacier2.Client.Router", false, 0), IceInternal::Property("Glacier2.Client.ProxyOptions", false, 0), @@ -702,7 +674,6 @@ const IceInternal::Property Glacier2PropsData[] = IceInternal::Property("Glacier2.PermissionsVerifier.LocatorCacheTimeout", false, 0), IceInternal::Property("Glacier2.PermissionsVerifier.Locator", false, 0), IceInternal::Property("Glacier2.PermissionsVerifier.Router", false, 0), - IceInternal::Property("Glacier2.PermissionsVerifier.EncodingVersion", false, 0), IceInternal::Property("Glacier2.PermissionsVerifier.CollocationOptimized", false, 0), IceInternal::Property("Glacier2.PermissionsVerifier", false, 0), IceInternal::Property("Glacier2.ReturnClientProxy", false, 0), @@ -712,7 +683,6 @@ const IceInternal::Property Glacier2PropsData[] = IceInternal::Property("Glacier2.SSLPermissionsVerifier.LocatorCacheTimeout", false, 0), IceInternal::Property("Glacier2.SSLPermissionsVerifier.Locator", false, 0), IceInternal::Property("Glacier2.SSLPermissionsVerifier.Router", false, 0), - IceInternal::Property("Glacier2.SSLPermissionsVerifier.EncodingVersion", false, 0), IceInternal::Property("Glacier2.SSLPermissionsVerifier.CollocationOptimized", false, 0), IceInternal::Property("Glacier2.SSLPermissionsVerifier", false, 0), IceInternal::Property("Glacier2.RoutingTable.MaxSize", false, 0), @@ -725,7 +695,6 @@ const IceInternal::Property Glacier2PropsData[] = IceInternal::Property("Glacier2.Server.Locator.LocatorCacheTimeout", false, 0), IceInternal::Property("Glacier2.Server.Locator.Locator", false, 0), IceInternal::Property("Glacier2.Server.Locator.Router", false, 0), - IceInternal::Property("Glacier2.Server.Locator.EncodingVersion", false, 0), IceInternal::Property("Glacier2.Server.Locator.CollocationOptimized", false, 0), IceInternal::Property("Glacier2.Server.Locator", false, 0), IceInternal::Property("Glacier2.Server.PublishedEndpoints", false, 0), @@ -736,7 +705,6 @@ const IceInternal::Property Glacier2PropsData[] = IceInternal::Property("Glacier2.Server.Router.LocatorCacheTimeout", false, 0), IceInternal::Property("Glacier2.Server.Router.Locator", false, 0), IceInternal::Property("Glacier2.Server.Router.Router", false, 0), - IceInternal::Property("Glacier2.Server.Router.EncodingVersion", false, 0), IceInternal::Property("Glacier2.Server.Router.CollocationOptimized", false, 0), IceInternal::Property("Glacier2.Server.Router", false, 0), IceInternal::Property("Glacier2.Server.ProxyOptions", false, 0), @@ -759,7 +727,6 @@ const IceInternal::Property Glacier2PropsData[] = IceInternal::Property("Glacier2.SessionManager.LocatorCacheTimeout", false, 0), IceInternal::Property("Glacier2.SessionManager.Locator", false, 0), IceInternal::Property("Glacier2.SessionManager.Router", false, 0), - IceInternal::Property("Glacier2.SessionManager.EncodingVersion", false, 0), IceInternal::Property("Glacier2.SessionManager.CollocationOptimized", false, 0), IceInternal::Property("Glacier2.SessionManager", false, 0), IceInternal::Property("Glacier2.SSLSessionManager.EndpointSelection", false, 0), @@ -768,7 +735,6 @@ const IceInternal::Property Glacier2PropsData[] = IceInternal::Property("Glacier2.SSLSessionManager.LocatorCacheTimeout", false, 0), IceInternal::Property("Glacier2.SSLSessionManager.Locator", false, 0), IceInternal::Property("Glacier2.SSLSessionManager.Router", false, 0), - IceInternal::Property("Glacier2.SSLSessionManager.EncodingVersion", false, 0), IceInternal::Property("Glacier2.SSLSessionManager.CollocationOptimized", false, 0), IceInternal::Property("Glacier2.SSLSessionManager", false, 0), IceInternal::Property("Glacier2.SessionTimeout", false, 0), diff --git a/cpp/src/Ice/PropertyNames.h b/cpp/src/Ice/PropertyNames.h index f8f09b5a81c..f460865f279 100644 --- a/cpp/src/Ice/PropertyNames.h +++ b/cpp/src/Ice/PropertyNames.h @@ -8,7 +8,7 @@ // ********************************************************************** // -// Generated by makeprops.py from file ../config/PropertyNames.xml, Mon Oct 22 18:48:40 2012 +// Generated by makeprops.py from file ./config/PropertyNames.xml, Mon Nov 12 21:17:34 2012 // IMPORTANT: Do not edit this file -- any edits made here will be lost! @@ -27,9 +27,9 @@ struct Property const char* deprecatedBy; Property(const char* n, bool d, const char* b) : - pattern(n), - deprecated(d), - deprecatedBy(b) + pattern(n), + deprecated(d), + deprecatedBy(b) { } diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp index 8f519f5ca55..7b5b6781867 100644 --- a/cpp/src/Ice/Proxy.cpp +++ b/cpp/src/Ice/Proxy.cpp @@ -870,7 +870,6 @@ IceProxy::Ice::Object::ice_encodingVersion(const ::Ice::EncodingVersion& encodin } else { - checkSupportedEncoding(encoding); ObjectPrx proxy = __newInstance(); proxy->setup(_reference->changeEncoding(encoding)); return proxy; diff --git a/cpp/src/Ice/Reference.cpp b/cpp/src/Ice/Reference.cpp index dadbdf8af0d..a3d9f9478ca 100644 --- a/cpp/src/Ice/Reference.cpp +++ b/cpp/src/Ice/Reference.cpp @@ -143,7 +143,7 @@ IceInternal::Reference::changeEncoding(const Ice::EncodingVersion& encoding) con r->_encoding = encoding; return r; } - + ReferencePtr IceInternal::Reference::changeCompress(bool newCompress) const { @@ -193,6 +193,12 @@ IceInternal::Reference::streamWrite(BasicStream* s) const s->write(_secure); + if(s->getWriteEncoding() != Ice::Encoding_1_0) + { + s->write(_protocol); + s->write(_encoding); + } + // Derived class writes the remainder of the reference. } @@ -282,6 +288,16 @@ IceInternal::Reference::toString() const s << " -s"; } + if(_protocol != Ice::Protocol_1_0) + { + s << " -p " << _protocol; + } + + if(_encoding != Ice::Encoding_1_0) + { + s << " -e " << _encoding; + } + return s.str(); // Derived class writes the remainder of the string. @@ -324,7 +340,12 @@ IceInternal::Reference::operator==(const Reference& r) const return false; } - if(_encoding != r._encoding) + if(_protocol != r._protocol) + { + return false; + } + + if(_encoding != r._encoding) { return false; } @@ -410,11 +431,20 @@ IceInternal::Reference::operator<(const Reference& r) const return false; } - if(_encoding < r._encoding) + if(_protocol < r._protocol) { return true; - } - else if(r._encoding > _encoding) + } + else if(r._protocol < _protocol) + { + return false; + } + + if(_encoding < r._encoding) + { + return true; + } + else if(r._encoding < _encoding) { return false; } @@ -450,6 +480,7 @@ IceInternal::Reference::Reference(const InstancePtr& instance, const string& facet, Mode mode, bool secure, + const ProtocolVersion& protocol, const EncodingVersion& encoding) : _hashInitialized(false), _instance(instance), @@ -459,6 +490,7 @@ IceInternal::Reference::Reference(const InstancePtr& instance, _identity(id), _context(new SharedContext), _facet(facet), + _protocol(protocol), _encoding(encoding), _overrideCompress(false), _compress(false) @@ -474,6 +506,7 @@ IceInternal::Reference::Reference(const Reference& r) : _identity(r._identity), _context(r._context), _facet(r._facet), + _protocol(r._protocol), _encoding(r._encoding), _overrideCompress(r._overrideCompress), _compress(r._compress) @@ -495,6 +528,8 @@ IceInternal::Reference::hashInit() const { hashAdd(h, _compress); } + hashAdd(h, _protocol.major); + hashAdd(h, _protocol.minor); hashAdd(h, _encoding.major); hashAdd(h, _encoding.minor); return h; @@ -510,7 +545,7 @@ IceInternal::FixedReference::FixedReference(const InstancePtr& instance, bool secure, const EncodingVersion& encoding, const ConnectionIPtr& fixedConnection) : - Reference(instance, communicator, id, facet, mode, secure, encoding), + Reference(instance, communicator, id, facet, mode, secure, Ice::Protocol_1_0, encoding), _fixedConnection(fixedConnection) { } @@ -820,7 +855,8 @@ IceInternal::RoutableReference::RoutableReference(const InstancePtr& instance, const string& facet, Mode mode, bool secure, - const EncodingVersion& version, + const ProtocolVersion& protocol, + const EncodingVersion& encoding, const vector<EndpointIPtr>& endpoints, const string& adapterId, const LocatorInfoPtr& locatorInfo, @@ -830,7 +866,7 @@ IceInternal::RoutableReference::RoutableReference(const InstancePtr& instance, bool preferSecure, EndpointSelectionType endpointSelection, int locatorCacheTimeout) : - Reference(instance, communicator, id, facet, mode, secure, version), + Reference(instance, communicator, id, facet, mode, secure, protocol, encoding), _endpoints(endpoints), _adapterId(adapterId), _locatorInfo(locatorInfo), @@ -907,6 +943,21 @@ IceInternal::RoutableReference::getConnectionId() const } ReferencePtr +IceInternal::RoutableReference::changeEncoding(const Ice::EncodingVersion& encoding) const +{ + ReferencePtr r = Reference::changeEncoding(encoding); + if(r.get() != const_cast<RoutableReference*>(this)) + { + LocatorInfoPtr& locInfo = RoutableReferencePtr::dynamicCast(r)->_locatorInfo; + if(locInfo && locInfo->getLocator()->ice_getEncodingVersion() != encoding) + { + locInfo = getInstance()->locatorManager()->get(locInfo->getLocator()->ice_encodingVersion(encoding)); + } + } + return r; +} + +ReferencePtr IceInternal::RoutableReference::changeCompress(bool newCompress) const { ReferencePtr r = Reference::changeCompress(newCompress); @@ -1175,7 +1226,6 @@ IceInternal::RoutableReference::toProperty(const string& prefix) const properties[prefix + ".ConnectionCached"] = _cacheConnection ? "1" : "0"; properties[prefix + ".PreferSecure"] = _preferSecure ? "1" : "0"; properties[prefix + ".EndpointSelection"] = _endpointSelection == Random ? "Random" : "Ordered"; - properties[prefix + ".EncodingVersion"] = versionToString(getEncoding()); ostringstream s; s << _locatorCacheTimeout; @@ -1888,20 +1938,14 @@ IceInternal::RoutableReference::RoutableReference(const RoutableReference& r) : namespace { -struct EndpointIsIncompatible : public unary_function<EndpointIPtr, bool> +struct EndpointIsOpaque : public unary_function<EndpointIPtr, bool> { - const Reference* _reference; - - EndpointIsIncompatible(const Reference* reference) : _reference(reference) - { - } +public: bool - operator()(const EndpointIPtr& p) const + operator()(EndpointIPtr p) const { - // If the enpoint doesn't support the proxy encoding or protocol, it's incompatible. - return !(isSupported(_reference->getEncoding(), p->encodingVersion()) && - isSupported(currentProtocol, p->protocolVersion())); + return dynamic_cast<OpaqueEndpointI*>(p.get()) != 0; } }; @@ -1913,10 +1957,9 @@ IceInternal::RoutableReference::filterEndpoints(const vector<EndpointIPtr>& allE vector<EndpointIPtr> endpoints = allEndpoints; // - // Filter out incompatible endpoints (whose encoding/protocol - // versions aren't supported by this runtime, or are opaque). + // Filter out unknown endpoints. // - endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), EndpointIsIncompatible(this)), endpoints.end()); + endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), EndpointIsOpaque()), endpoints.end()); // // Filter out endpoints according to the mode of the reference. diff --git a/cpp/src/Ice/Reference.h b/cpp/src/Ice/Reference.h index 4fad67eab08..ceff28a7c01 100644 --- a/cpp/src/Ice/Reference.h +++ b/cpp/src/Ice/Reference.h @@ -55,6 +55,7 @@ public: Mode getMode() const { return _mode; } bool getSecure() const { return _secure; } + const Ice::ProtocolVersion& getProtocol() const { return _protocol; } const Ice::EncodingVersion& getEncoding() const { return _encoding; } const Ice::Identity& getIdentity() const { return _identity; } const std::string& getFacet() const { return _facet; } @@ -85,7 +86,7 @@ public: ReferencePtr changeSecure(bool) const; ReferencePtr changeIdentity(const Ice::Identity&) const; ReferencePtr changeFacet(const std::string&) const; - ReferencePtr changeEncoding(const Ice::EncodingVersion&) const; + virtual ReferencePtr changeEncoding(const Ice::EncodingVersion&) const; virtual ReferencePtr changeCompress(bool) const; virtual ReferencePtr changeEndpoints(const std::vector<EndpointIPtr>&) const = 0; @@ -139,7 +140,7 @@ public: protected: Reference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const std::string&, Mode, bool, - const Ice::EncodingVersion&); + const Ice::ProtocolVersion&, const Ice::EncodingVersion&); Reference(const Reference&); virtual Ice::Int hashInit() const; @@ -157,6 +158,7 @@ private: Ice::Identity _identity; SharedContextPtr _context; std::string _facet; + Ice::ProtocolVersion _protocol; Ice::EncodingVersion _encoding; protected: @@ -222,8 +224,9 @@ class RoutableReference : public Reference public: RoutableReference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const std::string&, Mode, - bool, const Ice::EncodingVersion&, const std::vector<EndpointIPtr>&, const std::string&, - const LocatorInfoPtr&, const RouterInfoPtr&, bool, bool, bool, Ice::EndpointSelectionType, int); + bool, const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::vector<EndpointIPtr>&, + const std::string&, const LocatorInfoPtr&, const RouterInfoPtr&, bool, bool, bool, + Ice::EndpointSelectionType, int); virtual std::vector<EndpointIPtr> getEndpoints() const; virtual std::string getAdapterId() const; @@ -236,6 +239,7 @@ public: virtual int getLocatorCacheTimeout() const; virtual std::string getConnectionId() const; + virtual ReferencePtr changeEncoding(const Ice::EncodingVersion&) const; virtual ReferencePtr changeCompress(bool) const; virtual ReferencePtr changeEndpoints(const std::vector<EndpointIPtr>&) const; virtual ReferencePtr changeAdapterId(const std::string&) const; diff --git a/cpp/src/Ice/ReferenceFactory.cpp b/cpp/src/Ice/ReferenceFactory.cpp index 37ccafa1976..b4193f3a374 100644 --- a/cpp/src/Ice/ReferenceFactory.cpp +++ b/cpp/src/Ice/ReferenceFactory.cpp @@ -55,7 +55,8 @@ IceInternal::ReferenceFactory::create(const Identity& ident, return 0; } - return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), endpoints, "", ""); + return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), tmpl->getProtocol(), tmpl->getEncoding(), + endpoints, "", ""); } ReferencePtr @@ -69,7 +70,8 @@ IceInternal::ReferenceFactory::create(const Identity& ident, return 0; } - return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), vector<EndpointIPtr>(), adapterId, ""); + return create(ident, facet, tmpl->getMode(), tmpl->getSecure(), tmpl->getProtocol(), tmpl->getEncoding(), + vector<EndpointIPtr>(), adapterId, ""); } ReferencePtr @@ -80,8 +82,6 @@ IceInternal::ReferenceFactory::create(const Identity& ident, const Ice::Connecti return 0; } - DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides(); - // // Create new reference // @@ -91,7 +91,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, const Ice::Connecti "", // Facet connection->endpoint()->datagram() ? Reference::ModeDatagram : Reference::ModeTwoway, connection->endpoint()->secure(), - defaultsAndOverrides->defaultEncoding, + _instance->defaultsAndOverrides()->defaultEncoding, connection); } @@ -189,6 +189,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP string facet; Reference::Mode mode = Reference::ModeTwoway; bool secure = false; + Ice::EncodingVersion encoding = _instance->defaultsAndOverrides()->defaultEncoding; string adapter; while(true) @@ -362,6 +363,28 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP break; } + case 'e': + { + if(argument.empty()) + { + Ice::ProxyParseException ex(__FILE__, __LINE__); + ex.str = "no argument provided for -e option in `" + s + "'"; + throw ex; + } + + try + { + encoding = Ice::stringToEncodingVersion(argument); + } + catch(const Ice::VersionParseException& e) + { + Ice::ProxyParseException ex(__FILE__, __LINE__); + ex.str = "invalid encoding version `" + argument + "' in `" + s + "':\n" + e.str; + throw ex; + } + break; + } + default: { ProxyParseException ex(__FILE__, __LINE__); @@ -371,14 +394,12 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP } } - if(beg == string::npos) { - return create(ident, facet, mode, secure, vector<EndpointIPtr>(), "", propertyPrefix); + return create(ident, facet, mode, secure, Protocol_1_0, encoding, vector<EndpointIPtr>(), "", propertyPrefix); } vector<EndpointIPtr> endpoints; - switch(s[beg]) { case ':': @@ -463,7 +484,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP } } - return create(ident, facet, mode, secure, endpoints, "", propertyPrefix); + return create(ident, facet, mode, secure, Protocol_1_0, encoding, endpoints, "", propertyPrefix); break; } case '@': @@ -527,7 +548,7 @@ IceInternal::ReferenceFactory::create(const string& str, const string& propertyP adapter = Ice::UTF8ToNative(_instance->initializationData().stringConverter, adapter); - return create(ident, facet, mode, secure, vector<EndpointIPtr>(), adapter, propertyPrefix); + return create(ident, facet, mode, secure, Protocol_1_0, encoding, endpoints, adapter, propertyPrefix); break; } default: @@ -580,6 +601,19 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s) bool secure; s->read(secure); + Ice::ProtocolVersion protocol; + Ice::EncodingVersion encoding; + if(s->getReadEncoding() != Ice::Encoding_1_0) + { + s->read(protocol); + s->read(encoding); + } + else + { + protocol = Ice::Protocol_1_0; + encoding = Ice::Encoding_1_0; + } + vector<EndpointIPtr> endpoints; string adapterId; @@ -599,7 +633,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s) s->read(adapterId); } - return create(ident, facet, mode, secure, endpoints, adapterId, ""); + return create(ident, facet, mode, secure, protocol, encoding, endpoints, adapterId, ""); } ReferenceFactoryPtr @@ -656,7 +690,6 @@ IceInternal::ReferenceFactory::checkForUnknownProperties(const string& prefix) "EndpointSelection", "ConnectionCached", "PreferSecure", - "EncodingVersion", "LocatorCacheTimeout", "Locator", "Router", @@ -711,6 +744,8 @@ IceInternal::ReferenceFactory::create(const Identity& ident, const string& facet, Reference::Mode mode, bool secure, + const Ice::ProtocolVersion& protocol, + const Ice::EncodingVersion& encoding, const vector<EndpointIPtr>& endpoints, const string& adapterId, const string& propertyPrefix) @@ -720,12 +755,22 @@ IceInternal::ReferenceFactory::create(const Identity& ident, // // Default local proxy options. // - LocatorInfoPtr locatorInfo = _instance->locatorManager()->get(_defaultLocator); + LocatorInfoPtr locatorInfo; + if(_defaultLocator) + { + if(_defaultLocator->ice_getEncodingVersion() != encoding) + { + locatorInfo = _instance->locatorManager()->get(_defaultLocator->ice_encodingVersion(encoding)); + } + else + { + locatorInfo = _instance->locatorManager()->get(_defaultLocator); + } + } RouterInfoPtr routerInfo = _instance->routerManager()->get(_defaultRouter); bool collocationOptimized = defaultsAndOverrides->defaultCollocationOptimization; bool cacheConnection = true; bool preferSecure = defaultsAndOverrides->defaultPreferSecure; - EncodingVersion encoding = defaultsAndOverrides->defaultEncoding; Ice::EndpointSelectionType endpointSelection = defaultsAndOverrides->defaultEndpointSelection; int locatorCacheTimeout = defaultsAndOverrides->defaultLocatorCacheTimeout; @@ -746,7 +791,14 @@ IceInternal::ReferenceFactory::create(const Identity& ident, LocatorPrx locator = LocatorPrx::uncheckedCast(_communicator->propertyToProxy(property)); if(locator) { - locatorInfo = _instance->locatorManager()->get(locator); + if(locator->ice_getEncodingVersion() != encoding) + { + locatorInfo = _instance->locatorManager()->get(locator->ice_encodingVersion(encoding)); + } + else + { + locatorInfo = _instance->locatorManager()->get(locator); + } } property = propertyPrefix + ".Router"; @@ -774,14 +826,6 @@ IceInternal::ReferenceFactory::create(const Identity& ident, property = propertyPrefix + ".PreferSecure"; preferSecure = properties->getPropertyAsIntWithDefault(property, preferSecure) > 0; - property = propertyPrefix + ".EncodingVersion"; - string encodingStr = properties->getProperty(property); - if(!encodingStr.empty()) - { - encoding = stringToEncodingVersion(encodingStr); - checkSupportedEncoding(encoding); - } - property = propertyPrefix + ".EndpointSelection"; if(!properties->getProperty(property).empty()) { @@ -815,6 +859,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, facet, mode, secure, + protocol, encoding, endpoints, adapterId, diff --git a/cpp/src/Ice/ReferenceFactory.h b/cpp/src/Ice/ReferenceFactory.h index dd1982f96de..6542b062887 100644 --- a/cpp/src/Ice/ReferenceFactory.h +++ b/cpp/src/Ice/ReferenceFactory.h @@ -67,6 +67,7 @@ private: void checkForUnknownProperties(const std::string&); RoutableReferencePtr create(const ::Ice::Identity&, const ::std::string&, Reference::Mode, bool, + const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::vector<EndpointIPtr>&, const std::string&, const std::string&); const InstancePtr _instance; diff --git a/cpp/src/Ice/RouterInfo.cpp b/cpp/src/Ice/RouterInfo.cpp index 291e0ec03d9..84feadb9869 100644 --- a/cpp/src/Ice/RouterInfo.cpp +++ b/cpp/src/Ice/RouterInfo.cpp @@ -142,15 +142,6 @@ IceInternal::RouterInfo::operator<(const RouterInfo& rhs) const return _router < rhs._router; } -RouterPrx -IceInternal::RouterInfo::getRouter() const -{ - // - // No mutex lock necessary, _router is immutable. - // - return _router; -} - vector<EndpointIPtr> IceInternal::RouterInfo::getClientEndpoints() { diff --git a/cpp/src/Ice/RouterInfo.h b/cpp/src/Ice/RouterInfo.h index c1b1077a73b..7caaafc97cf 100644 --- a/cpp/src/Ice/RouterInfo.h +++ b/cpp/src/Ice/RouterInfo.h @@ -76,7 +76,13 @@ public: bool operator!=(const RouterInfo&) const; bool operator<(const RouterInfo&) const; - Ice::RouterPrx getRouter() const; + const Ice::RouterPrx& getRouter() const + { + // + // No mutex lock necessary, _router is immutable. + // + return _router; + } void getClientProxyResponse(const Ice::ObjectPrx&, const GetClientEndpointsCallbackPtr&); void getClientProxyException(const Ice::Exception&, const GetClientEndpointsCallbackPtr&); std::vector<EndpointIPtr> getClientEndpoints(); diff --git a/cpp/src/Ice/TcpConnector.cpp b/cpp/src/Ice/TcpConnector.cpp index a3211c28eb7..7c4dedb9cf2 100644 --- a/cpp/src/Ice/TcpConnector.cpp +++ b/cpp/src/Ice/TcpConnector.cpp @@ -77,16 +77,6 @@ IceInternal::TcpConnector::operator==(const Connector& r) const return false; } - if(_protocol != p->_protocol) - { - return false; - } - - if(_encoding != p->_encoding) - { - return false; - } - if(_connectionId != p->_connectionId) { return false; @@ -119,24 +109,6 @@ IceInternal::TcpConnector::operator<(const Connector& r) const return false; } - if(_protocol < p->_protocol) - { - return true; - } - else if(p->_protocol < _protocol) - { - return false; - } - - if(_encoding < p->_encoding) - { - return true; - } - else if(p->_encoding < _encoding) - { - return false; - } - if(_connectionId < p->_connectionId) { return true; @@ -149,15 +121,12 @@ IceInternal::TcpConnector::operator<(const Connector& r) const } IceInternal::TcpConnector::TcpConnector(const InstancePtr& instance, const Address& addr, - Ice::Int timeout, const Ice::ProtocolVersion& protocol, - const Ice::EncodingVersion& encoding, const string& connectionId) : + Ice::Int timeout, const string& connectionId) : _instance(instance), _traceLevels(instance->traceLevels()), _logger(instance->initializationData().logger), _addr(addr), _timeout(timeout), - _protocol(protocol), - _encoding(encoding), _connectionId(connectionId) { } diff --git a/cpp/src/Ice/TcpConnector.h b/cpp/src/Ice/TcpConnector.h index 341696087ef..6a1d5fdab50 100644 --- a/cpp/src/Ice/TcpConnector.h +++ b/cpp/src/Ice/TcpConnector.h @@ -36,8 +36,7 @@ public: private: - TcpConnector(const InstancePtr&, const Address&, Ice::Int, const Ice::ProtocolVersion&, - const Ice::EncodingVersion&, const std::string&); + TcpConnector(const InstancePtr&, const Address&, Ice::Int, const std::string&); virtual ~TcpConnector(); friend class TcpEndpointI; @@ -46,8 +45,6 @@ private: const ::Ice::LoggerPtr _logger; const Address _addr; const Ice::Int _timeout; - const Ice::ProtocolVersion _protocol; - const Ice::EncodingVersion _encoding; const std::string _connectionId; }; diff --git a/cpp/src/Ice/TcpEndpointI.cpp b/cpp/src/Ice/TcpEndpointI.cpp index 1eac94a8988..f69cfb1094b 100644 --- a/cpp/src/Ice/TcpEndpointI.cpp +++ b/cpp/src/Ice/TcpEndpointI.cpp @@ -23,9 +23,8 @@ using namespace Ice; using namespace IceInternal; IceInternal::TcpEndpointI::TcpEndpointI(const InstancePtr& instance, const string& ho, Int po, Int ti, - const Ice::ProtocolVersion& protocol, const Ice::EncodingVersion& encoding, const string& conId, bool co) : - EndpointI(protocol, encoding, conId), + EndpointI(conId), _instance(instance), _host(ho), _port(po), @@ -35,7 +34,7 @@ IceInternal::TcpEndpointI::TcpEndpointI(const InstancePtr& instance, const strin } IceInternal::TcpEndpointI::TcpEndpointI(const InstancePtr& instance, const string& str, bool oaEndpoint) : - EndpointI(Ice::currentProtocol, instance->defaultsAndOverrides()->defaultEncoding, ""), + EndpointI(""), _instance(instance), _port(0), _timeout(-1), @@ -155,7 +154,9 @@ IceInternal::TcpEndpointI::TcpEndpointI(const InstancePtr& instance, const strin default: { - parseOption(option, argument, "tcp", str); + Ice::EndpointParseException ex(__FILE__, __LINE__); + ex.str = "unknown option `" + option + "' in endpoint `tcp " + str + "'"; + throw ex; } } } @@ -190,16 +191,6 @@ IceInternal::TcpEndpointI::TcpEndpointI(BasicStream* s) : s->read(const_cast<Int&>(_port)); s->read(const_cast<Int&>(_timeout)); s->read(const_cast<bool&>(_compress)); - if(s->getReadEncoding() > Ice::Encoding_1_0) - { - s->read(const_cast<Ice::ProtocolVersion&>(_protocol)); - s->read(const_cast<Ice::EncodingVersion&>(_encoding)); - } - else - { - const_cast<ProtocolVersion&>(_protocol) = Ice::Protocol_1_0; - const_cast<EncodingVersion&>(_encoding) = Ice::Encoding_1_0; - } s->endReadEncaps(); } @@ -212,11 +203,6 @@ IceInternal::TcpEndpointI::streamWrite(BasicStream* s) const s->write(_port); s->write(_timeout); s->write(_compress); - if(s->getWriteEncoding() > Ice::Encoding_1_0) - { - s->write(_protocol); - s->write(_encoding); - } s->endWriteEncaps(); } @@ -233,16 +219,6 @@ IceInternal::TcpEndpointI::toString() const ostringstream s; s << "tcp"; - if(_protocol != Ice::Protocol_1_0) - { - s << " -v " << _protocol; - } - - if(_encoding != Ice::Encoding_1_0) - { - s << " -e " << _encoding; - } - if(!_host.empty()) { s << " -h "; @@ -277,9 +253,8 @@ IceInternal::TcpEndpointI::getInfo() const { public: - InfoI(const ProtocolVersion& pv, const EncodingVersion& ev, Ice::Int to, bool comp, const string& host, - Ice::Int port) : - TCPEndpointInfo(pv, ev, to, comp, host, port) + InfoI(Ice::Int to, bool comp, const string& host, Ice::Int port) : + TCPEndpointInfo(to, comp, host, port) { } @@ -302,7 +277,7 @@ IceInternal::TcpEndpointI::getInfo() const } }; - return new InfoI(_protocol, _encoding, _timeout, _compress, _host, _port); + return new InfoI(_timeout, _compress, _host, _port); } Short @@ -332,7 +307,7 @@ IceInternal::TcpEndpointI::timeout(Int timeout) const } else { - return new TcpEndpointI(_instance, _host, _port, timeout, _protocol, _encoding, _connectionId, _compress); + return new TcpEndpointI(_instance, _host, _port, timeout, _connectionId, _compress); } } @@ -345,7 +320,7 @@ IceInternal::TcpEndpointI::connectionId(const string& connectionId) const } else { - return new TcpEndpointI(_instance, _host, _port, _timeout, _protocol, _encoding, connectionId, _compress); + return new TcpEndpointI(_instance, _host, _port, _timeout, connectionId, _compress); } } @@ -364,7 +339,7 @@ IceInternal::TcpEndpointI::compress(bool compress) const } else { - return new TcpEndpointI(_instance, _host, _port, _timeout, _protocol, _encoding, _connectionId, compress); + return new TcpEndpointI(_instance, _host, _port, _timeout, _connectionId, compress); } } @@ -403,8 +378,8 @@ AcceptorPtr IceInternal::TcpEndpointI::acceptor(EndpointIPtr& endp, const string&) const { TcpAcceptor* p = new TcpAcceptor(_instance, _host, _port, _instance->protocolSupport()); - endp = new TcpEndpointI(_instance, _host, p->effectivePort(), _timeout, _protocol, _encoding, _connectionId, - _compress); + + endp = new TcpEndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress); return p; } @@ -422,8 +397,7 @@ IceInternal::TcpEndpointI::expand() const { for(vector<string>::const_iterator p = hosts.begin(); p != hosts.end(); ++p) { - endps.push_back(new TcpEndpointI(_instance, *p, _port, _timeout, _protocol, _encoding, _connectionId, - _compress)); + endps.push_back(new TcpEndpointI(_instance, *p, _port, _timeout, _connectionId, _compress)); } } return endps; @@ -454,16 +428,6 @@ IceInternal::TcpEndpointI::operator==(const LocalObject& r) const return true; } - if(_protocol != p->_protocol) - { - return false; - } - - if(_encoding != p->_encoding) - { - return false; - } - if(_host != p->_host) { return false; @@ -511,24 +475,6 @@ IceInternal::TcpEndpointI::operator<(const LocalObject& r) const return false; } - if(_protocol < p->_protocol) - { - return true; - } - else if(p->_protocol < _protocol) - { - return false; - } - - if(_encoding < p->_encoding) - { - return true; - } - else if(p->_encoding < _encoding) - { - return false; - } - if(_host < p->_host) { return true; @@ -585,10 +531,6 @@ IceInternal::TcpEndpointI::hashInit() const hashAdd(h, _host); hashAdd(h, _port); hashAdd(h, _timeout); - hashAdd(h, _protocol.major); - hashAdd(h, _protocol.minor); - hashAdd(h, _encoding.major); - hashAdd(h, _encoding.minor); hashAdd(h, _connectionId); hashAdd(h, _compress); return h; @@ -600,7 +542,7 @@ IceInternal::TcpEndpointI::connectors(const vector<Address>& addresses) const vector<ConnectorPtr> connectors; for(unsigned int i = 0; i < addresses.size(); ++i) { - connectors.push_back(new TcpConnector(_instance, addresses[i], _timeout, _protocol, _encoding, _connectionId)); + connectors.push_back(new TcpConnector(_instance, addresses[i], _timeout, _connectionId)); } return connectors; } diff --git a/cpp/src/Ice/TcpEndpointI.h b/cpp/src/Ice/TcpEndpointI.h index feaba9879a2..c1d410ebacd 100644 --- a/cpp/src/Ice/TcpEndpointI.h +++ b/cpp/src/Ice/TcpEndpointI.h @@ -22,8 +22,7 @@ class TcpEndpointI : public EndpointI { public: - TcpEndpointI(const InstancePtr&, const std::string&, Ice::Int, Ice::Int, const Ice::ProtocolVersion&, - const Ice::EncodingVersion&, const std::string&, bool); + TcpEndpointI(const InstancePtr&, const std::string&, Ice::Int, Ice::Int, const std::string&, bool); TcpEndpointI(const InstancePtr&, const std::string&, bool); TcpEndpointI(BasicStream*); diff --git a/cpp/src/Ice/UdpConnector.cpp b/cpp/src/Ice/UdpConnector.cpp index 29782122b53..b52c5a44bd6 100644 --- a/cpp/src/Ice/UdpConnector.cpp +++ b/cpp/src/Ice/UdpConnector.cpp @@ -48,16 +48,6 @@ IceInternal::UdpConnector::operator==(const Connector& r) const return false; } - if(_protocol != p->_protocol) - { - return false; - } - - if(_encoding != p->_encoding) - { - return false; - } - if(_connectionId != p->_connectionId) { return false; @@ -91,24 +81,6 @@ IceInternal::UdpConnector::operator<(const Connector& r) const return type() < r.type(); } - if(_protocol < p->_protocol) - { - return true; - } - else if(p->_protocol < _protocol) - { - return false; - } - - if(_encoding < p->_encoding) - { - return true; - } - else if(p->_encoding < _encoding) - { - return false; - } - if(_connectionId < p->_connectionId) { return true; @@ -139,15 +111,11 @@ IceInternal::UdpConnector::operator<(const Connector& r) const } IceInternal::UdpConnector::UdpConnector(const InstancePtr& instance, const Address& addr, - const string& mcastInterface, int mcastTtl, - const Ice::ProtocolVersion& protocol, const Ice::EncodingVersion& encoding, - const std::string& connectionId) : + const string& mcastInterface, int mcastTtl, const std::string& connectionId) : _instance(instance), _addr(addr), _mcastInterface(mcastInterface), _mcastTtl(mcastTtl), - _protocol(protocol), - _encoding(encoding), _connectionId(connectionId) { } diff --git a/cpp/src/Ice/UdpConnector.h b/cpp/src/Ice/UdpConnector.h index 148c767407b..e325e5007b6 100644 --- a/cpp/src/Ice/UdpConnector.h +++ b/cpp/src/Ice/UdpConnector.h @@ -34,8 +34,7 @@ public: private: - UdpConnector(const InstancePtr&, const Address&, const std::string&, int, - const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::string&); + UdpConnector(const InstancePtr&, const Address&, const std::string&, int, const std::string&); virtual ~UdpConnector(); friend class UdpEndpointI; @@ -44,8 +43,6 @@ private: const Address _addr; const std::string _mcastInterface; const int _mcastTtl; - const Ice::ProtocolVersion _protocol; - const Ice::EncodingVersion _encoding; const std::string _connectionId; }; diff --git a/cpp/src/Ice/UdpEndpointI.cpp b/cpp/src/Ice/UdpEndpointI.cpp index 8f508a98c0d..8d812e591dc 100644 --- a/cpp/src/Ice/UdpEndpointI.cpp +++ b/cpp/src/Ice/UdpEndpointI.cpp @@ -17,15 +17,15 @@ #include <Ice/DefaultsAndOverrides.h> #include <Ice/Protocol.h> #include <Ice/HashUtil.h> +#include <Ice/Logger.h> using namespace std; using namespace Ice; using namespace IceInternal; IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const string& ho, Int po, const string& mif, - Int mttl, const Ice::ProtocolVersion& protocol, - const Ice::EncodingVersion& encoding, bool conn, const string& conId, bool co) : - EndpointI(protocol, encoding, conId), + Int mttl, bool conn, const string& conId, bool co) : + EndpointI(conId), _instance(instance), _host(ho), _port(po), @@ -37,7 +37,7 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin } IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const string& str, bool oaEndpoint) : - EndpointI(Ice::currentProtocol, instance->defaultsAndOverrides()->defaultEncoding, ""), + EndpointI(""), _instance(instance), _port(0), _mcastTtl(-1), @@ -157,6 +157,14 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin } const_cast<bool&>(_compress) = true; } + else if(option == "-v") + { + _instance->initializationData().logger->warning("deprecated udp endpoint option: -v"); + } + else if(option == "-e") + { + _instance->initializationData().logger->warning("deprecated udp endpoint option: -e"); + } else if(option == "--interface") { if(argument.empty()) @@ -185,7 +193,9 @@ IceInternal::UdpEndpointI::UdpEndpointI(const InstancePtr& instance, const strin } else { - parseOption(option, argument, "udp", str); + Ice::EndpointParseException ex(__FILE__, __LINE__); + ex.str = "unknown option `" + option + "' in endpoint `udp " + str + "'"; + throw ex; } } @@ -218,8 +228,14 @@ IceInternal::UdpEndpointI::UdpEndpointI(BasicStream* s) : s->startReadEncaps(); s->read(const_cast<string&>(_host), false); s->read(const_cast<Int&>(_port)); - s->read(const_cast<Ice::ProtocolVersion&>(_protocol)); - s->read(const_cast<Ice::EncodingVersion&>(_encoding)); + if(s->getReadEncoding() == Ice::Encoding_1_0) + { + Ice::Byte b; + s->read(b); + s->read(b); + s->read(b); + s->read(b); + } // Not transmitted. //s->read(const_cast<bool&>(_connect)); s->read(const_cast<bool&>(_compress)); @@ -233,8 +249,11 @@ IceInternal::UdpEndpointI::streamWrite(BasicStream* s) const s->startWriteEncaps(); s->write(_host, false); s->write(_port); - s->write(_protocol); - s->write(_encoding); + if(s->getWriteEncoding() == Ice::Encoding_1_0) + { + s->write(Ice::Protocol_1_0); + s->write(Ice::Encoding_1_0); + } // Not transmitted. //s->write(_connect); s->write(_compress); @@ -255,16 +274,6 @@ IceInternal::UdpEndpointI::toString() const s << "udp"; - if(_protocol != Ice::Protocol_1_0) - { - s << " -v " << _protocol; - } - - if(_encoding != Ice::Encoding_1_0) - { - s << " -e " << _encoding; - } - if(!_host.empty()) { s << " -h "; @@ -312,9 +321,8 @@ IceInternal::UdpEndpointI::getInfo() const { public: - InfoI(const ProtocolVersion& pv, const EncodingVersion& ev, bool comp, const string& host, Ice::Int port, - const std::string& mcastInterface, Ice::Int mcastTtl) : - UDPEndpointInfo(pv, ev, -1, comp, host, port, mcastInterface, mcastTtl) + InfoI(bool comp, const string& host, Ice::Int port, const std::string& mcastInterface, Ice::Int mcastTtl) : + UDPEndpointInfo(-1, comp, host, port, mcastInterface, mcastTtl) { } @@ -337,7 +345,7 @@ IceInternal::UdpEndpointI::getInfo() const } }; - return new InfoI(_protocol, _encoding, _compress, _host, _port, _mcastInterface, _mcastTtl); + return new InfoI(_compress, _host, _port, _mcastInterface, _mcastTtl); } Short @@ -373,8 +381,7 @@ IceInternal::UdpEndpointI::connectionId(const string& connectionId) const } else { - return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _protocol, _encoding, _connect, - connectionId, _compress); + return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _connect, connectionId, _compress); } } @@ -393,8 +400,7 @@ IceInternal::UdpEndpointI::compress(bool compress) const } else { - return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _protocol, _encoding, _connect, - _connectionId, compress); + return new UdpEndpointI(_instance, _host, _port, _mcastInterface, _mcastTtl, _connect, _connectionId, compress); } } @@ -414,8 +420,8 @@ TransceiverPtr IceInternal::UdpEndpointI::transceiver(EndpointIPtr& endp) const { UdpTransceiver* p = new UdpTransceiver(_instance, _host, _port, _mcastInterface, _connect); - endp = new UdpEndpointI(_instance, _host, p->effectivePort(), _mcastInterface, _mcastTtl, _protocol, _encoding, - _connect, _connectionId, _compress); + endp = new UdpEndpointI(_instance, _host, p->effectivePort(), _mcastInterface, _mcastTtl, _connect, _connectionId, + _compress); return p; } @@ -451,8 +457,8 @@ IceInternal::UdpEndpointI::expand() const { for(vector<string>::const_iterator p = hosts.begin(); p != hosts.end(); ++p) { - endps.push_back(new UdpEndpointI(_instance, *p, _port, _mcastInterface, _mcastTtl, _protocol, _encoding, - _connect, _connectionId, _compress)); + endps.push_back(new UdpEndpointI(_instance, *p, _port, _mcastInterface, _mcastTtl, _connect, _connectionId, + _compress)); } } return endps; @@ -483,16 +489,6 @@ IceInternal::UdpEndpointI::operator==(const LocalObject& r) const return true; } - if(_protocol != p->_protocol) - { - return false; - } - - if(_encoding != p->_encoding) - { - return false; - } - if(_host != p->_host) { return false; @@ -550,24 +546,6 @@ IceInternal::UdpEndpointI::operator<(const LocalObject& r) const return false; } - if(_protocol < p->_protocol) - { - return true; - } - else if(p->_protocol < _protocol) - { - return false; - } - - if(_encoding < p->_encoding) - { - return true; - } - else if(p->_encoding < _encoding) - { - return false; - } - if(_host < p->_host) { return true; @@ -644,10 +622,6 @@ IceInternal::UdpEndpointI::hashInit() const hashAdd(h, _mcastInterface); hashAdd(h, _mcastTtl); hashAdd(h, _connect); - hashAdd(h, _protocol.major); - hashAdd(h, _protocol.minor); - hashAdd(h, _encoding.major); - hashAdd(h, _encoding.minor); hashAdd(h, _connectionId); hashAdd(h, _compress); return h; @@ -659,8 +633,7 @@ IceInternal::UdpEndpointI::connectors(const vector<Address>& addresses) const vector<ConnectorPtr> connectors; for(unsigned int i = 0; i < addresses.size(); ++i) { - connectors.push_back(new UdpConnector(_instance, addresses[i], _mcastInterface, _mcastTtl, _protocol, _encoding, - _connectionId)); + connectors.push_back(new UdpConnector(_instance, addresses[i], _mcastInterface, _mcastTtl, _connectionId)); } return connectors; } diff --git a/cpp/src/Ice/UdpEndpointI.h b/cpp/src/Ice/UdpEndpointI.h index dccdf28e796..765396cc436 100644 --- a/cpp/src/Ice/UdpEndpointI.h +++ b/cpp/src/Ice/UdpEndpointI.h @@ -22,8 +22,8 @@ class UdpEndpointI : public EndpointI { public: - UdpEndpointI(const InstancePtr&, const std::string&, Ice::Int, const std::string&, Ice::Int, - const Ice::ProtocolVersion&, const Ice::EncodingVersion&, bool, const std::string&, bool); + UdpEndpointI(const InstancePtr&, const std::string&, Ice::Int, const std::string&, Ice::Int, bool, + const std::string&, bool); UdpEndpointI(const InstancePtr&, const std::string&, bool); UdpEndpointI(BasicStream*); diff --git a/cpp/src/IceSSL/ConnectorI.cpp b/cpp/src/IceSSL/ConnectorI.cpp index 8c9857880fa..c881e5574f6 100644 --- a/cpp/src/IceSSL/ConnectorI.cpp +++ b/cpp/src/IceSSL/ConnectorI.cpp @@ -86,16 +86,6 @@ IceSSL::ConnectorI::operator==(const IceInternal::Connector& r) const return false; } - if(_protocol != p->_protocol) - { - return false; - } - - if(_encoding != p->_encoding) - { - return false; - } - if(_connectionId != p->_connectionId) { return false; @@ -128,24 +118,6 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const return false; } - if(_protocol < p->_protocol) - { - return true; - } - else if(p->_protocol < _protocol) - { - return false; - } - - if(_encoding < p->_encoding) - { - return true; - } - else if(p->_encoding < _encoding) - { - return false; - } - if(_connectionId < p->_connectionId) { return true; @@ -159,15 +131,12 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const } IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const string& host, const struct sockaddr_storage& addr, - Ice::Int timeout, const Ice::ProtocolVersion& protocol, - const Ice::EncodingVersion& encoding, const string& connectionId) : + Ice::Int timeout, const string& connectionId) : _instance(instance), _logger(instance->communicator()->getLogger()), _host(host), _addr(addr), _timeout(timeout), - _protocol(protocol), - _encoding(encoding), _connectionId(connectionId) { } diff --git a/cpp/src/IceSSL/ConnectorI.h b/cpp/src/IceSSL/ConnectorI.h index 5e00e714678..8a32689aeb7 100644 --- a/cpp/src/IceSSL/ConnectorI.h +++ b/cpp/src/IceSSL/ConnectorI.h @@ -42,8 +42,7 @@ public: private: - ConnectorI(const InstancePtr&, const std::string&, const struct sockaddr_storage&, Ice::Int, - const Ice::ProtocolVersion&, const Ice::EncodingVersion&, const std::string&); + ConnectorI(const InstancePtr&, const std::string&, const struct sockaddr_storage&, Ice::Int, const std::string&); virtual ~ConnectorI(); friend class EndpointI; @@ -52,8 +51,6 @@ private: const std::string _host; struct sockaddr_storage _addr; const Ice::Int _timeout; - const Ice::ProtocolVersion _protocol; - const Ice::EncodingVersion _encoding; const std::string _connectionId; }; diff --git a/cpp/src/IceSSL/EndpointI.cpp b/cpp/src/IceSSL/EndpointI.cpp index 5c15d89fdd3..a433b3259d1 100644 --- a/cpp/src/IceSSL/EndpointI.cpp +++ b/cpp/src/IceSSL/EndpointI.cpp @@ -23,10 +23,9 @@ using namespace std; using namespace Ice; using namespace IceSSL; -IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& ho, Int po, Int ti, - const Ice::ProtocolVersion& protocol, const Ice::EncodingVersion& encoding, - const string& conId, bool co) : - IceInternal::EndpointI(protocol, encoding, conId), +IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& ho, Int po, Int ti, const string& conId, + bool co) : + IceInternal::EndpointI(conId), _instance(instance), _host(ho), _port(po), @@ -36,7 +35,7 @@ IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& ho, Int } IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& str, bool oaEndpoint) : - IceInternal::EndpointI(Ice::currentProtocol, instance->defaultEncoding(), ""), + IceInternal::EndpointI(""), _instance(instance), _port(0), _timeout(-1), @@ -156,7 +155,9 @@ IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& str, boo default: { - parseOption(option, argument, "ssl", str); + Ice::EndpointParseException ex(__FILE__, __LINE__); + ex.str = "unknown option `" + option + "' in endpoint `ssl " + str + "'"; + throw ex; } } } @@ -191,16 +192,6 @@ IceSSL::EndpointI::EndpointI(const InstancePtr& instance, IceInternal::BasicStre s->read(const_cast<Int&>(_port)); s->read(const_cast<Int&>(_timeout)); s->read(const_cast<bool&>(_compress)); - if(s->getReadEncoding() > Ice::Encoding_1_0) - { - s->read(const_cast<Ice::ProtocolVersion&>(_protocol)); - s->read(const_cast<Ice::EncodingVersion&>(_encoding)); - } - else - { - const_cast<ProtocolVersion&>(_protocol) = Ice::Protocol_1_0; - const_cast<EncodingVersion&>(_encoding) = Ice::Encoding_1_0; - } s->endReadEncaps(); } @@ -213,11 +204,6 @@ IceSSL::EndpointI::streamWrite(IceInternal::BasicStream* s) const s->write(_port); s->write(_timeout); s->write(_compress); - if(s->getWriteEncoding() > Ice::Encoding_1_0) - { - s->write(_protocol); - s->write(_encoding); - } s->endWriteEncaps(); } @@ -234,16 +220,6 @@ IceSSL::EndpointI::toString() const ostringstream s; s << "ssl"; - if(_protocol != Ice::Protocol_1_0) - { - s << " -v " << _protocol; - } - - if(_encoding != Ice::Encoding_1_0) - { - s << " -e " << _encoding; - } - if(!_host.empty()) { s << " -h "; @@ -278,8 +254,7 @@ IceSSL::EndpointI::getInfo() const { public: - InfoI(const ProtocolVersion& pv, const EncodingVersion& ev, Int to, bool comp, const string& host, Int port) : - IceSSL::EndpointInfo(pv, ev, to, comp, host, port) + InfoI(Int to, bool comp, const string& host, Int port) : IceSSL::EndpointInfo(to, comp, host, port) { } @@ -301,7 +276,7 @@ IceSSL::EndpointI::getInfo() const return true; } }; - return new InfoI(_protocol, _encoding, _timeout, _compress, _host, _port); + return new InfoI(_timeout, _compress, _host, _port); } Short @@ -331,7 +306,7 @@ IceSSL::EndpointI::timeout(Int timeout) const } else { - return new EndpointI(_instance, _host, _port, timeout, _protocol, _encoding, _connectionId, _compress); + return new EndpointI(_instance, _host, _port, timeout, _connectionId, _compress); } } @@ -344,7 +319,7 @@ IceSSL::EndpointI::connectionId(const string& connectionId) const } else { - return new EndpointI(_instance, _host, _port, _timeout, _protocol, _encoding, connectionId, _compress); + return new EndpointI(_instance, _host, _port, _timeout, connectionId, _compress); } } @@ -363,7 +338,7 @@ IceSSL::EndpointI::compress(bool compress) const } else { - return new EndpointI(_instance, _host, _port, _timeout, _protocol, _encoding, _connectionId, compress); + return new EndpointI(_instance, _host, _port, _timeout, _connectionId, compress); } } @@ -402,8 +377,7 @@ IceInternal::AcceptorPtr IceSSL::EndpointI::acceptor(IceInternal::EndpointIPtr& endp, const string& adapterName) const { AcceptorI* p = new AcceptorI(_instance, adapterName, _host, _port); - endp = new EndpointI(_instance, _host, p->effectivePort(), _timeout, _protocol, _encoding, _connectionId, - _compress); + endp = new EndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress); return p; } @@ -420,8 +394,7 @@ IceSSL::EndpointI::expand() const { for(vector<string>::const_iterator p = hosts.begin(); p != hosts.end(); ++p) { - endps.push_back(new EndpointI(_instance, *p, _port, _timeout, _protocol, _encoding, _connectionId, - _compress)); + endps.push_back(new EndpointI(_instance, *p, _port, _timeout, _connectionId, _compress)); } } return endps; @@ -452,16 +425,6 @@ IceSSL::EndpointI::operator==(const Ice::LocalObject& r) const return true; } - if(_protocol != p->_protocol) - { - return false; - } - - if(_encoding != p->_encoding) - { - return false; - } - if(_host != p->_host) { return false; @@ -509,24 +472,6 @@ IceSSL::EndpointI::operator<(const Ice::LocalObject& r) const return false; } - if(_protocol < p->_protocol) - { - return true; - } - else if(p->_protocol < _protocol) - { - return false; - } - - if(_encoding < p->_encoding) - { - return true; - } - else if(p->_encoding < _encoding) - { - return false; - } - if(_host < p->_host) { return true; @@ -583,10 +528,6 @@ IceSSL::EndpointI::hashInit() const IceInternal::hashAdd(h, _host); IceInternal::hashAdd(h, _port); IceInternal::hashAdd(h, _timeout); - IceInternal::hashAdd(h, _protocol.major); - IceInternal::hashAdd(h, _protocol.minor); - IceInternal::hashAdd(h, _encoding.major); - IceInternal::hashAdd(h, _encoding.minor); IceInternal::hashAdd(h, _connectionId); IceInternal::hashAdd(h, _compress); return h; @@ -598,8 +539,7 @@ IceSSL::EndpointI::connectors(const vector<struct sockaddr_storage>& addresses) vector<IceInternal::ConnectorPtr> connectors; for(unsigned int i = 0; i < addresses.size(); ++i) { - connectors.push_back(new ConnectorI(_instance, _host, addresses[i], _timeout, _protocol, _encoding, - _connectionId)); + connectors.push_back(new ConnectorI(_instance, _host, addresses[i], _timeout, _connectionId)); } return connectors; } diff --git a/cpp/src/IceSSL/EndpointI.h b/cpp/src/IceSSL/EndpointI.h index 4eec180dfa8..14787ae1b0a 100644 --- a/cpp/src/IceSSL/EndpointI.h +++ b/cpp/src/IceSSL/EndpointI.h @@ -22,8 +22,7 @@ class EndpointI : public IceInternal::EndpointI { public: - EndpointI(const InstancePtr&, const std::string&, Ice::Int, Ice::Int, const Ice::ProtocolVersion&, - const Ice::EncodingVersion&, const std::string&, bool); + EndpointI(const InstancePtr&, const std::string&, Ice::Int, Ice::Int, const std::string&, bool); EndpointI(const InstancePtr&, const std::string&, bool); EndpointI(const InstancePtr&, IceInternal::BasicStream*); diff --git a/cpp/test/Ice/info/AllTests.cpp b/cpp/test/Ice/info/AllTests.cpp index b7527f182fb..8640bc0d291 100644 --- a/cpp/test/Ice/info/AllTests.cpp +++ b/cpp/test/Ice/info/AllTests.cpp @@ -20,7 +20,7 @@ allTests(const Ice::CommunicatorPtr& communicator) { cout << "testing proxy endpoint information... " << flush; { - Ice::ObjectPrx p1 = communicator->stringToProxy("test -t:default -v 1.4 -e 1.3 -h tcphost -p 10000 -t 1200 -z:" + Ice::ObjectPrx p1 = communicator->stringToProxy("test -t:default -h tcphost -p 10000 -t 1200 -z:" "udp -h udphost -p 10001 --interface eth0 --ttl 5:" "opaque -e 1.8 -t 100 -v ABCD"); @@ -28,14 +28,6 @@ allTests(const Ice::CommunicatorPtr& communicator) Ice::IPEndpointInfoPtr ipEndpoint = Ice::IPEndpointInfoPtr::dynamicCast(endps[0]->getInfo()); test(ipEndpoint); - Ice::ProtocolVersion pv; - pv.major = 1; - pv.minor = 4; - test(ipEndpoint->protocol == pv); - Ice::EncodingVersion ev; - ev.major = 1; - ev.minor = 3; - test(ipEndpoint->encoding == ev); test(ipEndpoint->host == "tcphost"); test(ipEndpoint->port == 10000); test(ipEndpoint->timeout == 1200); @@ -48,8 +40,6 @@ allTests(const Ice::CommunicatorPtr& communicator) Ice::UDPEndpointInfoPtr udpEndpoint = Ice::UDPEndpointInfoPtr::dynamicCast(endps[1]->getInfo()); test(udpEndpoint); - test(udpEndpoint->protocol == Ice::currentProtocol); - test(udpEndpoint->encoding == Ice::currentEncoding); test(udpEndpoint->host == "udphost"); test(udpEndpoint->port == 10001); test(udpEndpoint->mcastInterface == "eth0"); diff --git a/cpp/test/Ice/info/TestI.cpp b/cpp/test/Ice/info/TestI.cpp index 306b6493690..183d39018f9 100644 --- a/cpp/test/Ice/info/TestI.cpp +++ b/cpp/test/Ice/info/TestI.cpp @@ -48,10 +48,6 @@ TestI::getEndpointInfoAsContext(const Ice::Current& c) if(Ice::UDPEndpointInfoPtr::dynamicCast(ipinfo)) { Ice::UDPEndpointInfoPtr udp = Ice::UDPEndpointInfoPtr::dynamicCast(ipinfo); - ctx["protocolMajor"] = udp->protocol.major; - ctx["protocolMinor"] = udp->protocol.minor; - ctx["encodingMajor"] = udp->encoding.major; - ctx["encodingMinor"] = udp->encoding.minor; ctx["mcastInterface"] = udp->mcastInterface; ctx["mcastTtl"] = udp->mcastTtl; } diff --git a/cpp/test/Ice/location/AllTests.cpp b/cpp/test/Ice/location/AllTests.cpp index 1c6a73461d2..53751798b20 100644 --- a/cpp/test/Ice/location/AllTests.cpp +++ b/cpp/test/Ice/location/AllTests.cpp @@ -577,6 +577,19 @@ allTests(const Ice::CommunicatorPtr& communicator, const string& ref) hello->sayHello(); cout << "ok" << endl; + cout << "testing locator encoding resolution... " << flush; + + hello = HelloPrx::checkedCast(communicator->stringToProxy("hello")); + count = locator->getRequestCount(); + communicator->stringToProxy("test@TestAdapter")->ice_encodingVersion(Ice::Encoding_1_1)->ice_ping(); + test(count == locator->getRequestCount()); + communicator->stringToProxy("test@TestAdapter10")->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); + test(++count == locator->getRequestCount()); + communicator->stringToProxy("test -e 1.0@TestAdapter10-2")->ice_ping(); + test(++count == locator->getRequestCount()); + + cout << "ok" << endl; + cout << "shutdown server... " << flush; obj->shutdown(); cout << "ok" << endl; diff --git a/cpp/test/Ice/location/ServerLocator.cpp b/cpp/test/Ice/location/ServerLocator.cpp index 75f403e83fc..efb4e9b71b7 100644 --- a/cpp/test/Ice/location/ServerLocator.cpp +++ b/cpp/test/Ice/location/ServerLocator.cpp @@ -9,6 +9,7 @@ #include <Ice/Ice.h> #include <Ice/BuiltinSequences.h> +#include <TestCommon.h> #include <ServerLocator.h> using namespace std; @@ -117,6 +118,13 @@ ServerLocator::findAdapterById_async(const Ice::AMD_Locator_findAdapterByIdPtr& const Ice::Current& current) const { ++const_cast<int&>(_requestCount); + if(id == "TestAdapter10" || id == "TestAdapter10-2") + { + test(current.encoding == Ice::Encoding_1_0); + response->ice_response(_registry->getAdapter("TestAdapter")); + return; + } + // We add a small delay to make sure locator request queuing gets tested when // running the test on a fast machine IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1)); diff --git a/cpp/test/Ice/metrics/AllTests.cpp b/cpp/test/Ice/metrics/AllTests.cpp index 215dab04312..3c1bfa42822 100644 --- a/cpp/test/Ice/metrics/AllTests.cpp +++ b/cpp/test/Ice/metrics/AllTests.cpp @@ -488,7 +488,8 @@ allTests(const Ice::CommunicatorPtr& communicator) cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]); sm2 = IceMX::ConnectionMetricsPtr::dynamicCast(serverMetrics->getMetricsView("View", timestamp)["Connection"][0]); - test(cm2->sentBytes - cm1->sentBytes == requestSz + static_cast<int>(bs.size()) + 4); // 4 is for the seq variable size + // 4 is for the seq variable size + test(cm2->sentBytes - cm1->sentBytes == requestSz + static_cast<int>(bs.size()) + 4); test(cm2->receivedBytes - cm1->receivedBytes == replySz); test(sm2->receivedBytes - sm1->receivedBytes == requestSz + static_cast<int>(bs.size()) + 4); if(sm2->sentBytes - sm1->sentBytes != replySz) @@ -498,7 +499,8 @@ allTests(const Ice::CommunicatorPtr& communicator) // to the operation is sent and getMetricsView can be dispatched before the metric is really // updated. IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100)); - sm2 = IceMX::ConnectionMetricsPtr::dynamicCast(serverMetrics->getMetricsView("View", timestamp)["Connection"][0]); + sm2 = IceMX::ConnectionMetricsPtr::dynamicCast( + serverMetrics->getMetricsView("View", timestamp)["Connection"][0]); } test(sm2->sentBytes - sm1->sentBytes == replySz); @@ -511,7 +513,8 @@ allTests(const Ice::CommunicatorPtr& communicator) cm2 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]); sm2 = IceMX::ConnectionMetricsPtr::dynamicCast(serverMetrics->getMetricsView("View", timestamp)["Connection"][0]); - test(cm2->sentBytes - cm1->sentBytes == requestSz + static_cast<int>(bs.size()) + 4); // 4 is for the seq variable size + // 4 is for the seq variable size + test(cm2->sentBytes - cm1->sentBytes == requestSz + static_cast<int>(bs.size()) + 4); test(cm2->receivedBytes - cm1->receivedBytes == replySz); test(sm2->receivedBytes - sm1->receivedBytes == requestSz + static_cast<int>(bs.size()) + 4); if(sm2->sentBytes - sm1->sentBytes != replySz) @@ -521,7 +524,8 @@ allTests(const Ice::CommunicatorPtr& communicator) // to the operation is sent and getMetricsView can be dispatched before the metric is really // updated. IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100)); - sm2 = IceMX::ConnectionMetricsPtr::dynamicCast(serverMetrics->getMetricsView("View", timestamp)["Connection"][0]); + sm2 = IceMX::ConnectionMetricsPtr::dynamicCast( + serverMetrics->getMetricsView("View", timestamp)["Connection"][0]); } test(sm2->sentBytes - sm1->sentBytes == replySz); @@ -574,7 +578,8 @@ allTests(const Ice::CommunicatorPtr& communicator) cm1 = IceMX::ConnectionMetricsPtr::dynamicCast(clientMetrics->getMetricsView("View", timestamp)["Connection"][0]); while(true) { - sm1 = IceMX::ConnectionMetricsPtr::dynamicCast(serverMetrics->getMetricsView("View", timestamp)["Connection"][0]); + sm1 = IceMX::ConnectionMetricsPtr::dynamicCast( + serverMetrics->getMetricsView("View", timestamp)["Connection"][0]); if(sm1-> failures >= 2) { break; @@ -593,14 +598,11 @@ allTests(const Ice::CommunicatorPtr& communicator) testAttribute(clientMetrics, clientProps, update, "Connection", "parent", "Communicator"); //testAttribute(clientMetrics, clientProps, update, "Connection", "id", ""); - testAttribute(clientMetrics, clientProps, update, "Connection", "endpoint", - "tcp -e 1.1 -h 127.0.0.1 -p 12010 -t 500"); + testAttribute(clientMetrics, clientProps, update, "Connection", "endpoint", "tcp -h 127.0.0.1 -p 12010 -t 500"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointType", "1"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsDatagram", "false"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointIsSecure", "false"); - testAttribute(clientMetrics, clientProps, update, "Connection", "endpointProtocolVersion", "1.0"); - testAttribute(clientMetrics, clientProps, update, "Connection", "endpointEncodingVersion", "1.1"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointTimeout", "500"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointCompress", "false"); testAttribute(clientMetrics, clientProps, update, "Connection", "endpointHost", "127.0.0.1"); @@ -660,13 +662,11 @@ allTests(const Ice::CommunicatorPtr& communicator) testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "parent", "Communicator", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "id", "127.0.0.1:12010", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpoint", - "tcp -e 1.1 -h 127.0.0.1 -p 12010", c); + "tcp -h 127.0.0.1 -p 12010", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointType", "1", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsDatagram", "false", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointIsSecure", "false", c); - testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointProtocolVersion", "1.0", c); - testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointEncodingVersion", "1.1", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointTimeout", "-1", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointCompress", "false", c); testAttribute(clientMetrics, clientProps, update, "ConnectionEstablishment", "endpointHost", "127.0.0.1", c); @@ -691,7 +691,7 @@ allTests(const Ice::CommunicatorPtr& communicator) test(clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"].size() == 1); m1 = clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"][0]; - test(m1->current <= 1 && m1->total == 1 && m1->id == "tcp -e 1.1 -h localhost -p 12010"); + test(m1->current <= 1 && m1->total == 1 && m1->id == "tcp -h localhost -p 12010"); prx->ice_getConnection()->close(false); @@ -709,22 +709,20 @@ allTests(const Ice::CommunicatorPtr& communicator) } test(clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"].size() == 2); m1 = clientMetrics->getMetricsView("View", timestamp)["EndpointLookup"][1]; - test(m1->id == "tcp -e 1.1 -h unknownfoo.zeroc.com -p 12010" && m1->total == 2 && m1->failures == 2); + test(m1->id == "tcp -h unknownfoo.zeroc.com -p 12010" && m1->total == 2 && m1->failures == 2); checkFailure(clientMetrics, "EndpointLookup", m1->id, "Ice::DNSException", 2); c = Connect(prx); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "parent", "Communicator", c); - testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "id", "tcp -e 1.1 -h localhost -p 12010", c); + testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "id", "tcp -h localhost -p 12010", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpoint", - "tcp -e 1.1 -h localhost -p 12010", c); + "tcp -h localhost -p 12010", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointType", "1", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsDatagram", "false", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointIsSecure", "false", c); - testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointProtocolVersion", "1.0", c); - testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointEncodingVersion", "1.1", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointTimeout", "-1", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointCompress", "false", c); testAttribute(clientMetrics, clientProps, update, "EndpointLookup", "endpointHost", "localhost", c); @@ -806,14 +804,12 @@ allTests(const Ice::CommunicatorPtr& communicator) testAttribute(serverMetrics, serverProps, update, "Dispatch", "parent", "TestAdapter", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "id", "metrics [op]", op); - testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpoint", "tcp -e 1.1 -h 127.0.0.1 -p 12010", op); + testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpoint", "tcp -h 127.0.0.1 -p 12010", op); //testAttribute(serverMetrics, serverProps, update, "Dispatch", "connection", "", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointType", "1", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsDatagram", "false", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointIsSecure", "false", op); - testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointProtocolVersion", "1.0", op); - testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointEncodingVersion", "1.1", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointTimeout", "-1", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointCompress", "false", op); testAttribute(serverMetrics, serverProps, update, "Dispatch", "endpointHost", "127.0.0.1", op); @@ -997,7 +993,7 @@ allTests(const Ice::CommunicatorPtr& communicator) testAttribute(clientMetrics, clientProps, update, "Invocation", "parent", "Communicator", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "id", - "metrics -t:tcp -e 1.1 -h 127.0.0.1 -p 12010 [op]", op); + "metrics -t -e 1.1:tcp -h 127.0.0.1 -p 12010 [op]", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "operation", "op", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "identity", "metrics", op); @@ -1005,7 +1001,7 @@ allTests(const Ice::CommunicatorPtr& communicator) testAttribute(clientMetrics, clientProps, update, "Invocation", "encoding", "1.1", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "mode", "twoway", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "proxy", - "metrics -t:tcp -e 1.1 -h 127.0.0.1 -p 12010", op); + "metrics -t -e 1.1:tcp -h 127.0.0.1 -p 12010", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry1", "test", op); testAttribute(clientMetrics, clientProps, update, "Invocation", "context.entry2", "", op); diff --git a/cpp/test/Ice/proxy/AllTests.cpp b/cpp/test/Ice/proxy/AllTests.cpp index 4773088850d..9f6428f111b 100644 --- a/cpp/test/Ice/proxy/AllTests.cpp +++ b/cpp/test/Ice/proxy/AllTests.cpp @@ -212,6 +212,14 @@ allTests(const Ice::CommunicatorPtr& communicator) 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); + try { b1 = communicator->stringToProxy("test:tcp@adapterId"); @@ -327,31 +335,6 @@ allTests(const Ice::CommunicatorPtr& communicator) test(!b1->ice_isCollocationOptimized()); prop->setProperty(property, ""); - property = propertyPrefix + ".EncodingVersion"; - test(b1->ice_getEncodingVersion() == Ice::currentEncoding); - prop->setProperty(property, "1.0"); - b1 = communicator->propertyToProxy(propertyPrefix); - test(b1->ice_getEncodingVersion().major == 1 && b1->ice_getEncodingVersion().minor == 0); - prop->setProperty(property, "6.5"); - try - { - communicator->propertyToProxy(propertyPrefix); - test(false); - } - catch(const Ice::UnsupportedEncodingException&) - { - } - prop->setProperty(property, "1.2"); - try - { - communicator->propertyToProxy(propertyPrefix); - test(false); - } - catch(const Ice::UnsupportedEncodingException&) - { - } - prop->setProperty(property, ""); - cout << "ok" << endl; cout << "testing proxyToProperty... " << flush; @@ -382,42 +365,29 @@ allTests(const Ice::CommunicatorPtr& communicator) b1 = b1->ice_locator(Ice::LocatorPrx::uncheckedCast(locator)); Ice::PropertyDict proxyProps = communicator->proxyToProperty(b1, "Test"); - test(proxyProps.size() == 21); + test(proxyProps.size() == 18); test(proxyProps["Test"] == "test -t"); - test(proxyProps["Test.EncodingVersion"] == "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.Locator"] == "locator -t"); - test(proxyProps["Test.Locator.EncodingVersion"] == Ice::encodingVersionToString(Ice::currentEncoding)); + test(proxyProps["Test.Locator"] == "locator -t -e " + Ice::encodingVersionToString(Ice::currentEncoding)); 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.Router"] == "router -t"); - test(proxyProps["Test.Locator.Router.EncodingVersion"] == Ice::encodingVersionToString(Ice::currentEncoding)); + 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"); - try - { - Ice::EncodingVersion v = { 3, 4 }; - b1->ice_encodingVersion(v); - test(false); - } - catch(const Ice::UnsupportedEncodingException&) - { - } - cout << "ok" << endl; cout << "testing ice_getCommunicator... " << flush; @@ -653,35 +623,74 @@ allTests(const Ice::CommunicatorPtr& communicator) cout << "ok" << endl; + cout << "testing protocol versioning... " << flush; + { + Ice::OutputStreamPtr out = Ice::createOutputStream(communicator); + out->write(cl); + vector<Ice::Byte> inBytes; + out->finished(inBytes); + + // Protocol version 1.1 + inBytes[9] = 1; + inBytes[10] = 1; + + Ice::InputStreamPtr in = Ice::createInputStream(communicator, inBytes); + Test::MyClassPrx cl11; + in->read(cl11); + cl11 = cl11->ice_collocationOptimized(false); + test(cl11->ice_toString() == "test -t -p 1.1 -e 1.1:tcp -h 127.0.0.1 -p 12010"); + try + { + cl11->ice_ping(); + test(false); + } + catch(const Ice::UnsupportedProtocolException&) + { + } + try + { + cl11->end_ice_ping(cl11->begin_ice_ping()); + test(false); + } + catch(const Ice::UnsupportedProtocolException&) + { + } + try + { + cl11->ice_flushBatchRequests(); + test(false); + } + catch(const Ice::UnsupportedProtocolException&) + { + } + try + { + cl11->end_ice_flushBatchRequests(cl11->begin_ice_flushBatchRequests()); + test(false); + } + catch(const Ice::UnsupportedProtocolException&) + { + } + } + cout << "ok" << endl; + cout << "testing encoding versioning... " << flush; - string ref20 = "test:default -p 12010 -e 2.0"; + string ref20 = "test -e 2.0:default -p 12010"; Test::MyClassPrx cl20 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref20)); try { cl20->ice_collocationOptimized(false)->ice_ping(); test(false); } - catch(const Ice::NoEndpointException&) + catch(const Ice::UnsupportedEncodingException&) { // Server 2.0 endpoint doesn't support 1.1 version. } - string ref10 = "test:default -p 12010 -e 1.0"; + string ref10 = "test -e 1.0:default -p 12010"; Test::MyClassPrx cl10 = Test::MyClassPrx::uncheckedCast(communicator->stringToProxy(ref10)); - try - { - cl10->ice_collocationOptimized(false)->ice_ping(); // Can't send request with 1.1 encoding on 1.0 endpoint. - test(false); - } - catch(const Ice::NoEndpointException&) - { - // Server 1.0 endpoint doesn't support 1.1 version. - } - - // Server with 1.0 endpoint supports 1.0 encoding. + cl10->ice_ping(); cl10->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); - - // Server with 1.1 endpoint supports 1.0 encoding. cl->ice_collocationOptimized(false)->ice_encodingVersion(Ice::Encoding_1_0)->ice_ping(); try @@ -841,17 +850,13 @@ allTests(const Ice::CommunicatorPtr& communicator) } // Legal TCP endpoint expressed as opaque endpoint - Ice::ObjectPrx p1 = communicator->stringToProxy("test:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA=="); + 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:tcp -h 127.0.0.1 -p 12010 -t 10000"); - - // 1.1 TCP endpoint encoded with 1.1 encoding. - Ice::ObjectPrx p2 = communicator->stringToProxy("test:opaque -e 1.1 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAAEAAQE="); - test(communicator->proxyToString(p2) == "test -t:tcp -e 1.1 -h 127.0.0.1 -p 12010 -t 10000"); + test(pstr == "test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000"); - // 1.0 TCP endpoint encoded with 1.1 encoding. - p2 = communicator->stringToProxy("test: opaque -t 1 -e 1.1 -v CTEyNy4wLjAuMeouAAAQJwAAAAEAAQA="); - test(communicator->proxyToString(p2) == "test -t: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) { @@ -867,7 +872,7 @@ allTests(const Ice::CommunicatorPtr& communicator) } // Two legal TCP endpoints expressed as opaque endpoints - p1 = communicator->stringToProxy("test:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -e 1.0 -t 1 -v CTEyNy4wLjAuMusuAAAQJwAAAA=="); + 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:tcp -h 127.0.0.1 -p 12010 -t 10000:tcp -h 127.0.0.2 -p 12011 -t 10000"); @@ -875,7 +880,7 @@ allTests(const Ice::CommunicatorPtr& communicator) // Test that an SSL endpoint and a nonsense endpoint get written // back out as an opaque endpoint. // - p1 = communicator->stringToProxy("test:opaque -e 1.0 -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -e 1.0 -t 99 -v abch"); + 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) { |