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);
}
IceSSL::AcceptorI::AcceptorI(const InstancePtr& instance, const string& adapterName, const string& host, int port) :
_instance(instance),
_adapterName(adapterName),
_logger(instance->communicator()->getLogger()),
_addr(IceInternal::getAddressForServer(host, port, instance->protocolSupport()))
#ifdef ICE_USE_IOCP
, _acceptFd(INVALID_SOCKET),
_info(IceInternal::SocketOperationRead)
#endif
{
#ifdef SOMAXCONN
_backlog = instance->communicator()->getProperties()->getPropertyAsIntWithDefault("Ice.TCP.Backlog", SOMAXCONN);
#else
_backlog = instance->communicator()->getProperties()->getPropertyAsIntWithDefault("Ice.TCP.Backlog", 511);
#endif
_fd = IceInternal::createSocket(false, _addr.ss_family);
#ifdef ICE_USE_IOCP
_acceptBuf.resize((sizeof(sockaddr_storage) + 16) * 2);
#endif
IceInternal::setBlock(_fd, false);
IceInternal::setTcpBufSize(_fd, _instance->communicator()->getProperties(), _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).
//
IceInternal::setReuseAddress(_fd, true);
#endif
if(_instance->networkTraceLevel() >= 2)
{
Trace out(_logger, _instance->networkTraceCategory());
out << "attempting to bind to ssl socket " << toString();
}
const_cast<struct sockaddr_storage&>(_addr) = IceInternal::doBind(_fd, _addr);
}
IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, SOCKET fd, const string& adapterName) :
IceInternal::NativeInfo(fd),
_instance(instance),
_logger(instance->communicator()->getLogger()),
_stats(instance->communicator()->getStats()),
_ssl(0),
_incoming(true),
_adapterName(adapterName),
_state(StateConnected),
_desc(IceInternal::fdToString(fd))
#ifdef ICE_USE_IOCP
, _iocpBio(0),
_read(IceInternal::SocketOperationRead),
_write(IceInternal::SocketOperationWrite)
#endif
{
IceInternal::setBlock(fd, false);
IceInternal::setTcpBufSize(fd, _instance->communicator()->getProperties(), _logger);
}
IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const string& host, const IceInternal::Address& addr,
const IceInternal::NetworkProxyPtr& proxy, Ice::Int timeout,
const string& connectionId) :
_instance(instance),
_logger(instance->communicator()->getLogger()),
_host(host),
_addr(addr),
_proxy(proxy),
_timeout(timeout),
_connectionId(connectionId)
{
}
IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, SOCKET fd, const string& host,
const IceInternal::Address& addr) :
IceInternal::NativeInfo(fd),
_instance(instance),
_logger(instance->communicator()->getLogger()),
_stats(instance->communicator()->getStats()),
_ssl(0),
_host(host),
_incoming(false),
_state(StateNeedConnect)
#ifdef ICE_USE_IOCP
, _iocpBio(0),
_read(IceInternal::SocketOperationRead),
_write(IceInternal::SocketOperationWrite)
#endif
{
IceInternal::setBlock(fd, false);
IceInternal::setTcpBufSize(fd, _instance->communicator()->getProperties(), _logger);
#ifndef ICE_USE_IOCP
if(IceInternal::doConnect(_fd, addr))
{
_state = StateConnected;
_desc = IceInternal::fdToString(_fd);
if(_instance->networkTraceLevel() >= 1)
{
Trace out(_logger, _instance->networkTraceCategory());
out << "ssl connection established\n" << _desc;
}
}
else
{
_desc = IceInternal::fdToString(_fd);
}
#endif
_connectAddr = addr;
}
Glacier2::FilterManagerPtr
Glacier2::FilterManager::create(const InstancePtr& instance, const string& userId, const bool allowAddUser)
{
PropertiesPtr props = instance->properties();
string allow = props->getProperty("Glacier2.Filter.Category.Accept");
vector<string> allowSeq;
stringToSeq(allow, allowSeq);
if(allowAddUser)
{
int addUserMode = 0;
if(!props->getProperty("Glacier2.Filter.Category.AcceptUser").empty())
{
addUserMode = props->getPropertyAsInt("Glacier2.Filter.Category.AcceptUser");
}
if(addUserMode > 0 && !userId.empty())
{
if(addUserMode == 1)
{
allowSeq.push_back(userId); // Add user id to allowed categories.
}
else if(addUserMode == 2)
{
allowSeq.push_back('_' + userId); // Add user id with prepended underscore to allowed categories.
}
}
}
Glacier2::StringSetIPtr categoryFilter = new Glacier2::StringSetI(allowSeq);
//
// TODO: refactor initialization of filters.
//
allow = props->getProperty("Glacier2.Filter.AdapterId.Accept");
stringToSeq(allow, allowSeq);
Glacier2::StringSetIPtr adapterIdFilter = new Glacier2::StringSetI(allowSeq);
//
// TODO: Object id's from configurations?
//
IdentitySeq allowIdSeq;
allow = props->getProperty("Glacier2.Filter.Identity.Accept");
stringToSeq(instance->communicator(), allow, allowIdSeq);
Glacier2::IdentitySetIPtr identityFilter = new Glacier2::IdentitySetI(allowIdSeq);
return new Glacier2::FilterManager(instance, categoryFilter, adapterIdFilter, identityFilter);
}
TopicManagerI::TopicManagerI(
const InstancePtr& instance,
const Ice::ObjectAdapterPtr& topicAdapter,
const string& envName,
const string& dbName) :
_instance(instance),
_topicAdapter(topicAdapter),
_envName(envName),
_dbName(dbName),
_connection(Freeze::createConnection(instance->communicator(), envName)),
_topics(_connection, dbName)
{
//
// Recreate each of the topics in the persistent map
//
for(PersistentTopicMap::const_iterator p = _topics.begin(); p != _topics.end(); ++p)
{
installTopic(identityToTopicName(p->first), p->first, p->second, false);
}
}
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);
}
TopicManagerImpl::TopicManagerImpl(const InstancePtr& instance) :
_instance(instance),
_connection(Freeze::createConnection(instance->communicator(), instance->serviceName()))
{
try
{
__setNoDelete(true);
if(_instance->observer())
{
_instance->observer()->setObserverUpdater(this);
}
// TODO: If we want to improve the performance of the
// non-replicated case we could allocate a null-topic manager impl
// here.
_managerImpl = new TopicManagerI(instance, this);
Ice::PropertiesPtr properties = _instance->communicator()->getProperties();
// If there is no node adapter we don't need to start the
// observer, nor sync since we're not replicating.
if(_instance->nodeAdapter())
{
_observerImpl = new ReplicaObserverI(instance, this);
_observer = _instance->nodeAdapter()->addWithUUID(_observerImpl);
_syncImpl = new TopicManagerSyncI(this);
_sync = _instance->nodeAdapter()->addWithUUID(_syncImpl);
}
// Ensure that the llu counter is present in the log.
LogUpdate empty = {0, 0};
putLLU(_connection, empty);
// Recreate each of the topics.
SubscriberMap subscriberMap(_connection, subscriberDbName);
SubscriberMap::const_iterator p = subscriberMap.begin();
while(p != subscriberMap.end())
{
// This record has to be a place holder record, otherwise
// there is a database bug.
assert(p->first.id.name.empty() && p->first.id.category.empty());
Ice::Identity topic = p->first.topic;
// Skip the place holder.
++p;
SubscriberRecordSeq content;
while(p != subscriberMap.end() && p->first.topic == topic)
{
content.push_back(p->second);
++p;
}
string name = identityToTopicName(topic);
installTopic(name, topic, false, content);
}
}
catch(...)
{
shutdown();
__setNoDelete(false);
throw;
}
__setNoDelete(false);
}
