NodeI::NodeI(const InstancePtr& instance, const ReplicaPtr& replica, const Ice::ObjectPrx& replicaProxy, int id, const map<int, NodePrx>& nodes) : _timer(instance->timer()), _traceLevels(instance->traceLevels()), _observers(instance->observers()), _replica(replica), _replicaProxy(replicaProxy), _id(id), _nodes(nodes), _state(NodeStateInactive), _updateCounter(0), _max(0), _generation(-1), _destroy(false) { map<int, NodePrx> oneway; for(map<int, NodePrx>::const_iterator p = _nodes.begin(); p != _nodes.end(); ++p) { oneway[p->first] = NodePrx::uncheckedCast(p->second->ice_oneway()); } const_cast<map<int, NodePrx>& >(_nodesOneway) = oneway; Ice::PropertiesPtr properties = instance->communicator()->getProperties(); const_cast<IceUtil::Time&>(_masterTimeout) = getTimeout( instance->serviceName() + ".Election.MasterTimeout", 10, properties, _traceLevels); const_cast<IceUtil::Time&>(_electionTimeout) = getTimeout( instance->serviceName() + ".Election.ElectionTimeout", 10, properties, _traceLevels); const_cast<IceUtil::Time&>(_mergeTimeout) = getTimeout( instance->serviceName() + ".Election.ResponseTimeout", 10, properties, _traceLevels); }
IceInternal::TcpTransceiver::TcpTransceiver(const InstancePtr& instance, SOCKET fd, bool connected) : NativeInfo(fd), _traceLevels(instance->traceLevels()), _logger(instance->initializationData().logger), _stats(instance->initializationData().stats), _state(connected ? StateConnected : StateNeedConnect), _desc(connected ? fdToString(_fd) : string()) #ifdef ICE_USE_IOCP , _read(SocketOperationRead), _write(SocketOperationWrite) #endif { setBlock(_fd, false); setTcpBufSize(_fd, instance->initializationData().properties, _logger); #ifdef ICE_USE_IOCP // // On Windows, limiting the buffer size is important to prevent // poor throughput performances when transfering large amount of // data. See Microsoft KB article KB823764. // _maxSendPacketSize = IceInternal::getSendBufferSize(fd) / 2; if(_maxSendPacketSize < 512) { _maxSendPacketSize = 0; } _maxReceivePacketSize = IceInternal::getRecvBufferSize(fd); if(_maxReceivePacketSize < 512) { _maxReceivePacketSize = 0; } #endif }
IceInternal::TcpConnector::TcpConnector(const InstancePtr& instance, const Address& addr, Ice::Int timeout, const string& connectionId) : _instance(instance), _traceLevels(instance->traceLevels()), _logger(instance->initializationData().logger), _addr(addr), _timeout(timeout), _connectionId(connectionId) { }
IceInternal::TcpAcceptor::TcpAcceptor(const InstancePtr& instance, const string& host, int port, ProtocolSupport protocol) : _instance(instance), _traceLevels(instance->traceLevels()), _logger(instance->initializationData().logger), _addr(getAddressForServer(host, port, protocol)) #ifdef ICE_USE_IOCP , _acceptFd(INVALID_SOCKET), _info(SocketOperationRead) #endif { #ifdef SOMAXCONN _backlog = instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.TCP.Backlog", SOMAXCONN); #else _backlog = instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.TCP.Backlog", 511); #endif _fd = createSocket(false, _addr.ss_family); #ifdef ICE_USE_IOCP _acceptBuf.resize((sizeof(sockaddr_storage) + 16) * 2); #endif setBlock(_fd, false); setTcpBufSize(_fd, _instance->initializationData().properties, _logger); #ifndef _WIN32 // // Enable SO_REUSEADDR on Unix platforms to allow re-using the // socket even if it's in the TIME_WAIT state. On Windows, // this doesn't appear to be necessary and enabling // SO_REUSEADDR would actually not be a good thing since it // allows a second process to bind to an address even it's // already bound by another process. // // TODO: using SO_EXCLUSIVEADDRUSE on Windows would probably // be better but it's only supported by recent Windows // versions (XP SP2, Windows Server 2003). // setReuseAddress(_fd, true); #endif if(_traceLevels->network >= 2) { Trace out(_logger, _traceLevels->networkCat); out << "attempting to bind to tcp socket " << toString(); } const_cast<struct sockaddr_storage&>(_addr) = doBind(_fd, _addr); }
SubscriberPtr Subscriber::create( const InstancePtr& instance, const SubscriberRecord& rec) { if(rec.link) { return new SubscriberLink(instance, rec); } else { PerSubscriberPublisherIPtr per = new PerSubscriberPublisherI(instance); Ice::Identity perId; perId.category = instance->instanceName(); perId.name = "topic." + rec.topicName + ".publish." + instance->communicator()->identityToString(rec.obj->ice_getIdentity()); Ice::ObjectPrx proxy = instance->publishAdapter()->add(per, perId); TraceLevelsPtr traceLevels = instance->traceLevels(); SubscriberPtr subscriber; try { int retryCount = 0; QoS::const_iterator p = rec.theQoS.find("retryCount"); if(p != rec.theQoS.end()) { retryCount = atoi(p->second.c_str()); } string reliability; p = rec.theQoS.find("reliability"); if(p != rec.theQoS.end()) { reliability = p->second; } if(!reliability.empty() && reliability != "ordered") { throw BadQoS("invalid reliability: " + reliability); } // // Override the timeout. // Ice::ObjectPrx newObj; try { newObj = rec.obj->ice_timeout(instance->sendTimeout()); } catch(const Ice::FixedProxyException&) { // // In the event IceStorm is collocated this could be a // fixed proxy in which case its not possible to set the // timeout. // newObj = rec.obj; } p = rec.theQoS.find("locatorCacheTimeout"); if(p != rec.theQoS.end()) { istringstream is(IceUtilInternal::trim(p->second)); int locatorCacheTimeout; if(!(is >> locatorCacheTimeout) || !is.eof()) { throw BadQoS("invalid locator cache timeout (numeric value required): " + p->second); } newObj = newObj->ice_locatorCacheTimeout(locatorCacheTimeout); } p = rec.theQoS.find("connectionCached"); if(p != rec.theQoS.end()) { istringstream is(IceUtilInternal::trim(p->second)); int connectionCached; if(!(is >> connectionCached) || !is.eof()) { throw BadQoS("invalid connection cached setting (numeric value required): " + p->second); } newObj = newObj->ice_connectionCached(connectionCached > 0); } if(reliability == "ordered") { if(!newObj->ice_isTwoway()) { throw BadQoS("ordered reliability requires a twoway proxy"); } subscriber = new SubscriberTwoway(instance, rec, proxy, retryCount, 1, newObj); } else if(newObj->ice_isOneway() || newObj->ice_isDatagram()) { if(retryCount > 0) { throw BadQoS("non-zero retryCount QoS requires a twoway proxy"); } subscriber = new SubscriberOneway(instance, rec, proxy, retryCount, newObj); } else if(newObj->ice_isBatchOneway() || newObj->ice_isBatchDatagram()) { if(retryCount > 0) { throw BadQoS("non-zero retryCount QoS requires a twoway proxy"); } subscriber = new SubscriberBatch(instance, rec, proxy, retryCount, newObj); } else //if(newObj->ice_isTwoway()) { assert(newObj->ice_isTwoway()); subscriber = new SubscriberTwoway(instance, rec, proxy, retryCount, 5, newObj); } per->setSubscriber(subscriber); }
Observers::Observers(const InstancePtr& instance) : _traceLevels(instance->traceLevels()), _majority(0) { }