TransceiverPtr
IceInternal::StreamConnector::connect()
{
if(_traceLevels->network >= 2)
{
Trace out(_logger, _traceLevels->networkCat);
out << "trying to establish " << typeToString(_type) << " connection to " << toString();
}
try
{
TransceiverPtr transceiver = new StreamTransceiver(_instance, _type, createSocket(false, _addr), false);
dynamic_cast<StreamTransceiver*>(transceiver.get())->connect(_addr);
return transceiver;
}
catch(const Ice::LocalException& ex)
{
if(_traceLevels->network >= 2)
{
Trace out(_logger, _traceLevels->networkCat);
out << "failed to establish " << typeToString(_type) << " connection to " << toString() << "\n" << ex;
}
throw;
}
}
TransceiverPtr
IceInternal::StreamConnector::connect()
{
TransceiverPtr transceiver = new StreamTransceiver(_instance, createSocket(false, _addr), false);
dynamic_cast<StreamTransceiver*>(transceiver.get())->connect(_addr);
return transceiver;
}
ConnectionIPtr
IceInternal::OutgoingConnectionFactory::createConnection(const TransceiverPtr& transceiver, const ConnectorInfo& ci)
{
IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
assert(_pending.find(ci.connector) != _pending.end() && transceiver);
//
// Create and add the connection to the connection map. Adding the connection to the map
// is necessary to support the interruption of the connection initialization and validation
// in case the communicator is destroyed.
//
Ice::ConnectionIPtr connection;
try
{
if(_destroyed)
{
throw Ice::CommunicatorDestroyedException(__FILE__, __LINE__);
}
connection = new ConnectionI(_communicator, _instance, _reaper, transceiver, ci.connector,
ci.endpoint->compress(false), 0);
}
catch(const Ice::LocalException&)
{
try
{
transceiver->close();
}
catch(const Ice::LocalException&)
{
// Ignore
}
throw;
}
_connections.insert(pair<const ConnectorPtr, ConnectionIPtr>(ci.connector, connection));
_connectionsByEndpoint.insert(pair<const EndpointIPtr, ConnectionIPtr>(connection->endpoint(), connection));
_connectionsByEndpoint.insert(pair<const EndpointIPtr, ConnectionIPtr>(connection->endpoint()->compress(true),
connection));
return connection;
}
void
IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
{
ConnectionIPtr connection;
ThreadPoolMessage<IncomingConnectionFactory> msg(current, *this);
{
IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
ThreadPoolMessage<IncomingConnectionFactory>::IOScope io(msg);
if(!io)
{
return;
}
if(_state >= StateClosed)
{
return;
}
else if(_state == StateHolding)
{
IceUtil::ThreadControl::yield();
return;
}
//
// Reap closed connections
//
vector<Ice::ConnectionIPtr> cons;
_reaper->swapConnections(cons);
for(vector<Ice::ConnectionIPtr>::const_iterator p = cons.begin(); p != cons.end(); ++p)
{
_connections.erase(*p);
}
//
// Now accept a new connection.
//
TransceiverPtr transceiver;
try
{
transceiver = _acceptor->accept();
}
catch(const SocketException& ex)
{
if(noMoreFds(ex.error))
{
{
Error out(_instance->initializationData().logger);
out << "fatal error: can't accept more connections:\n" << ex << '\n' << _acceptor->toString();
}
abort();
}
// Ignore socket exceptions.
return;
}
catch(const LocalException& ex)
{
// Warn about other Ice local exceptions.
if(_warn)
{
Warning out(_instance->initializationData().logger);
out << "connection exception:\n" << ex << '\n' << _acceptor->toString();
}
return;
}
assert(transceiver);
try
{
connection = new ConnectionI(_adapter->getCommunicator(), _instance, _reaper, transceiver, 0, _endpoint,
_adapter);
}
catch(const LocalException& ex)
{
try
{
transceiver->close();
}
catch(const Ice::LocalException&)
{
// Ignore.
}
if(_warn)
{
Warning out(_instance->initializationData().logger);
out << "connection exception:\n" << ex << '\n' << _acceptor->toString();
}
return;
}
_connections.insert(connection);
}
assert(connection);
connection->start(this);
}
