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)
{
}
