void
SubscriberOneway::flush()
{
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock);
//
// If the subscriber isn't online we're done.
//
if(_state != SubscriberStateOnline || _events.empty())
{
return;
}
// Send up to _maxOutstanding pending events.
while(_outstanding < _maxOutstanding && !_events.empty())
{
//
// Dequeue the head event, count one more outstanding AMI
// request.
//
EventDataPtr e = _events.front();
_events.erase(_events.begin());
if(_observer)
{
_observer->outstanding(1);
}
try
{
Ice::AsyncResultPtr result = _obj->begin_ice_invoke(
e->op, e->mode, e->data, e->context, Ice::newCallback_Object_ice_invoke(this,
&SubscriberOneway::exception,
&SubscriberOneway::sent));
if(!result->sentSynchronously())
{
++_outstanding;
}
else if(_observer)
{
_observer->delivered(1);
}
}
catch(const Ice::Exception& ex)
{
error(true, ex);
return;
}
}
if(_events.empty() && _outstanding == 0 && _shutdown)
{
_lock.notify();
}
}
void
SubscriberBatch::doFlush()
{
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(_lock);
//
// If the subscriber isn't online we're done.
//
if(_state != SubscriberStateOnline)
{
return;
}
EventDataSeq v;
v.swap(_events);
assert(!v.empty());
if(_observer)
{
_outstandingCount = static_cast<Ice::Int>(v.size());
_observer->outstanding(_outstandingCount);
}
try
{
vector<Ice::Byte> dummy;
for(EventDataSeq::const_iterator p = v.begin(); p != v.end(); ++p)
{
_obj->ice_invoke((*p)->op, (*p)->mode, (*p)->data, dummy, (*p)->context);
}
Ice::AsyncResultPtr result = _obj->begin_ice_flushBatchRequests(
Ice::newCallback_Object_ice_flushBatchRequests(this,
&SubscriberBatch::exception,
&SubscriberBatch::sent));
if(result->sentSynchronously())
{
--_outstanding;
assert(_outstanding == 0);
if(_observer)
{
_observer->delivered(_outstandingCount);
}
}
}
catch(const Ice::Exception& ex)
{
error(false, ex);
return;
}
if(_events.empty() && _outstanding == 0 && _shutdown)
{
_lock.notify();
}
// This is significantly faster than the async version, but it can
// block the calling thread. Bad news!
//_obj->ice_flushBatchRequests();
}
void
PluginI::initialize()
{
Ice::PropertiesPtr properties = _communicator->getProperties();
bool ipv4 = properties->getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
bool preferIPv6 = properties->getPropertyAsInt("Ice.PreferIPv6Address") > 0;
string address;
if(ipv4 && !preferIPv6)
{
address = properties->getPropertyWithDefault("IceDiscovery.Address", "239.255.0.1");
}
else
{
address = properties->getPropertyWithDefault("IceDiscovery.Address", "ff15::1");
}
int port = properties->getPropertyAsIntWithDefault("IceDiscovery.Port", 4061);
string interface = properties->getProperty("IceDiscovery.Interface");
if(properties->getProperty("IceDiscovery.Multicast.Endpoints").empty())
{
ostringstream os;
os << "udp -h \"" << address << "\" -p " << port;
if(!interface.empty())
{
os << " --interface \"" << interface << "\"";
}
properties->setProperty("IceDiscovery.Multicast.Endpoints", os.str());
}
if(properties->getProperty("IceDiscovery.Reply.Endpoints").empty())
{
ostringstream os;
os << "udp";
if(!interface.empty())
{
os << " -h \"" << interface << "\"";
}
properties->setProperty("IceDiscovery.Reply.Endpoints", os.str());
}
if(properties->getProperty("IceDiscovery.Locator.Endpoints").empty())
{
properties->setProperty("IceDiscovery.Locator.AdapterId", IceUtil::generateUUID());
}
_multicastAdapter = _communicator->createObjectAdapter("IceDiscovery.Multicast");
_replyAdapter = _communicator->createObjectAdapter("IceDiscovery.Reply");
_locatorAdapter = _communicator->createObjectAdapter("IceDiscovery.Locator");
//
// Setup locatory registry.
//
LocatorRegistryIPtr locatorRegistry = new LocatorRegistryI(_communicator);
Ice::LocatorRegistryPrx locatorRegistryPrx =
Ice::LocatorRegistryPrx::uncheckedCast(_locatorAdapter->addWithUUID(locatorRegistry));
string lookupEndpoints = properties->getProperty("IceDiscovery.Lookup");
if(lookupEndpoints.empty())
{
ostringstream os;
os << "udp -h \"" << address << "\" -p " << port;
if(!interface.empty())
{
os << " --interface \"" << interface << "\"";
}
lookupEndpoints = os.str();
}
Ice::ObjectPrx lookupPrx = _communicator->stringToProxy("IceDiscovery/Lookup -d:" + lookupEndpoints);
lookupPrx = lookupPrx->ice_collocationOptimized(false); // No collocation optimization for the multicast proxy!
try
{
// Ensure we can establish a connection to the multicast proxy
// but don't block.
Ice::AsyncResultPtr result = lookupPrx->begin_ice_getConnection();
if(result->sentSynchronously())
{
lookupPrx->end_ice_getConnection(result);
}
}
catch(const Ice::LocalException& ex)
{
ostringstream os;
os << "IceDiscovery is unable to establish a multicast connection:\n";
os << "proxy = " << lookupPrx << '\n';
os << ex;
throw Ice::PluginInitializationException(__FILE__, __LINE__, os.str());
}
//
// Add lookup and lookup reply Ice objects
//
_lookup = new LookupI(locatorRegistry, LookupPrx::uncheckedCast(lookupPrx), properties);
_multicastAdapter->add(_lookup, _communicator->stringToIdentity("IceDiscovery/Lookup"));
Ice::ObjectPrx lookupReply = _replyAdapter->addWithUUID(new LookupReplyI(_lookup))->ice_datagram();
_lookup->setLookupReply(LookupReplyPrx::uncheckedCast(lookupReply));
//
// Setup locator on the communicator.
//
Ice::ObjectPrx loc = _locatorAdapter->addWithUUID(new LocatorI(_lookup, locatorRegistryPrx));
_communicator->setDefaultLocator(Ice::LocatorPrx::uncheckedCast(loc));
_multicastAdapter->activate();
_replyAdapter->activate();
_locatorAdapter->activate();
}