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