TransportImpl::AcceptConnectResult
MulticastTransport::connect_datalink(const RemoteTransport& remote,
const ConnectionAttribs& attribs,
TransportClient*)
{
// Check that the remote reliability matches.
if (get_remote_reliability(remote) != this->config_i_->is_reliable()) {
return AcceptConnectResult();
}
GuardThreadType guard_links(this->links_lock_);
const MulticastPeer local_peer = RepoIdConverter(attribs.local_id_).participantId();
Links::const_iterator link_iter = this->client_links_.find(local_peer);
MulticastDataLink_rch link;
if (link_iter == this->client_links_.end()) {
link = this->make_datalink(attribs.local_id_, attribs.priority_, true /*active*/);
this->client_links_[local_peer] = link;
} else {
link = link_iter->second;
}
MulticastPeer remote_peer = RepoIdConverter(remote.repo_id_).participantId();
MulticastSession_rch session =
this->start_session(link, remote_peer, true /*active*/);
if (session.is_nil()) {
return AcceptConnectResult();
}
return AcceptConnectResult(link._retn());
}
TransportImpl::AcceptConnectResult
MulticastTransport::accept_datalink(const RemoteTransport& remote,
const ConnectionAttribs& attribs,
TransportClient* client)
{
// Check that the remote reliability matches.
if (get_remote_reliability(remote) != this->config_i_->is_reliable()) {
return AcceptConnectResult();
}
const MulticastPeer local_peer = RepoIdConverter(attribs.local_id_).participantId();
GuardThreadType guard_links(this->links_lock_);
Links::const_iterator link_iter = this->server_links_.find(local_peer);
MulticastDataLink_rch link;
if (link_iter == this->server_links_.end()) {
link = this->make_datalink(attribs.local_id_, attribs.priority_, false /*passive*/);
this->server_links_[local_peer] = link;
} else {
link = link_iter->second;
}
guard_links.release();
MulticastPeer remote_peer = RepoIdConverter(remote.repo_id_).participantId();
GuardThreadType guard(this->connections_lock_);
if (connections_.count(std::make_pair(remote_peer, local_peer))) {
//can't call start session with connections_lock_ due to reactor
//call in session->start which could deadlock with passive_connection
guard.release();
VDBG((LM_DEBUG, "(%P|%t) MulticastTransport::accept_datalink found\n"));
MulticastSession_rch session =
this->start_session(link, remote_peer, false /*!active*/);
if (session.is_nil()) {
link = 0;
}
return AcceptConnectResult(link._retn());
} else {
this->pending_connections_[std::make_pair(remote_peer, local_peer)].
push_back(std::pair<TransportClient*, RepoId>(client, remote.repo_id_));
//can't call start session with connections_lock_ due to reactor
//call in session->start which could deadlock with passive_connection
guard.release();
MulticastSession_rch session =
this->start_session(link, remote_peer, false /*!active*/);
return AcceptConnectResult(AcceptConnectResult::ACR_SUCCESS);
}
}
TransportImpl::AcceptConnectResult
ShmemTransport::connect_datalink(const RemoteTransport& remote,
const ConnectionAttribs&,
TransportClient*)
{
const std::pair<std::string, std::string> key = blob_to_key(remote.blob_);
if (key.first != hostname_) {
return AcceptConnectResult();
}
GuardType guard(links_lock_);
ShmemDataLinkMap::iterator iter = links_.find(key.second);
if (iter != links_.end()) {
ShmemDataLink_rch link = iter->second;
VDBG_LVL((LM_DEBUG, ACE_TEXT("(%P|%t) ShmemTransport::connect_datalink ")
ACE_TEXT("link found.\n")), 2);
return AcceptConnectResult(link._retn());
}
VDBG_LVL((LM_DEBUG, ACE_TEXT("(%P|%t) ShmemTransport::connect_datalink ")
ACE_TEXT("new link.\n")), 2);
return AcceptConnectResult(add_datalink(key.second));
}
TransportImpl::AcceptConnectResult
TcpTransport::connect_datalink(const RemoteTransport& remote,
const ConnectionAttribs& attribs,
TransportClient* client)
{
DBG_ENTRY_LVL("TcpTransport", "connect_datalink", 6);
const PriorityKey key =
blob_to_key(remote.blob_, attribs.priority_, true /*active*/);
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::connect_datalink PriorityKey "
"prio=%d, addr=%C:%hu, is_loopback=%d, is_active=%d\n",
key.priority(), key.address().get_host_addr(),
key.address().get_port_number(), key.is_loopback(),
key.is_active()), 2);
TcpDataLink_rch link;
{
GuardType guard(links_lock_);
if (find_datalink_i(key, link, client, remote.repo_id_)) {
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::connect_datalink found datalink link[%@]\n", link.in()), 2);
return link.is_nil()
? AcceptConnectResult(AcceptConnectResult::ACR_SUCCESS)
: AcceptConnectResult(link._retn());
}
link = new TcpDataLink(key.address(), this, attribs.priority_,
key.is_loopback(), true /*active*/);
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::connect_datalink create new link[%@]\n", link.in()), 2);
if (links_.bind(key, link) != 0 /*OK*/) {
ACE_ERROR((LM_ERROR, "(%P|%t) ERROR: TcpTransport::connect_datalink "
"Unable to bind new TcpDataLink[%@] to "
"TcpTransport in links_ map.\n", link.in()));
return AcceptConnectResult();
}
}
TcpConnection_rch connection =
new TcpConnection(key.address(), link->transport_priority(), tcp_config_);
connection->set_datalink(link.in());
TcpConnection* pConn = connection.in();
TcpConnection_rch reactor_refcount(connection); // increment for reactor callback
ACE_TCHAR str[64];
key.address().addr_to_string(str,sizeof(str)/sizeof(str[0]));
// Can't make this call while holding onto TransportClient::lock_
const int ret =
connector_.connect(pConn, key.address(), ACE_Synch_Options::asynch);
if (ret == -1 && errno != EWOULDBLOCK) {
VDBG_LVL((LM_ERROR, "(%P|%t) TcpTransport::connect_datalink error %m.\n"), 2);
return AcceptConnectResult();
}
// Don't decrement count when reactor_refcount goes out of scope, see
// TcpConnection::open()
(void) reactor_refcount._retn();
if (ret == 0) {
// connect() completed synchronously and called TcpConnection::active_open().
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::connect_datalink "
"completed synchronously.\n"), 2);
return AcceptConnectResult(link._retn());
}
if (!link->add_on_start_callback(client, remote.repo_id_)) {
// link was started by the reactor thread before we could add a callback
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::connect_datalink got link.\n"), 2);
return AcceptConnectResult(link._retn());
}
GuardType connections_guard(connections_lock_);
add_pending_connection(client, link.in());
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::connect_datalink pending.\n"), 2);
return AcceptConnectResult(AcceptConnectResult::ACR_SUCCESS);
}
TransportImpl::AcceptConnectResult
TcpTransport::accept_datalink(const RemoteTransport& remote,
const ConnectionAttribs& attribs,
TransportClient* client)
{
GuidConverter remote_conv(remote.repo_id_);
GuidConverter local_conv(attribs.local_id_);
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::accept_datalink local %C "
"accepting connection from remote %C\n",
std::string(local_conv).c_str(),
std::string(remote_conv).c_str()), 5);
GuardType guard(connections_lock_);
const PriorityKey key =
blob_to_key(remote.blob_, attribs.priority_, false /* !active */);
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::accept_datalink PriorityKey "
"prio=%d, addr=%C:%hu, is_loopback=%d, is_active=%d\n", attribs.priority_,
key.address().get_host_addr(), key.address().get_port_number(),
key.is_loopback(), key.is_active()), 2);
TcpDataLink_rch link;
{
GuardType guard(links_lock_);
if (find_datalink_i(key, link, client, remote.repo_id_)) {
return link.is_nil()
? AcceptConnectResult(AcceptConnectResult::ACR_SUCCESS)
: AcceptConnectResult(link._retn());
} else {
link = new TcpDataLink(key.address(), this, key.priority(),
key.is_loopback(), key.is_active());
if (links_.bind(key, link) != 0 /*OK*/) {
ACE_ERROR((LM_ERROR,
"(%P|%t) ERROR: TcpTransport::accept_datalink "
"Unable to bind new TcpDataLink to "
"TcpTransport in links_ map.\n"));
return AcceptConnectResult();
}
}
}
TcpConnection_rch connection;
const ConnectionMap::iterator iter = connections_.find(key);
if (iter != connections_.end()) {
connection = iter->second;
connections_.erase(iter);
}
if (connection.is_nil()) {
if (!link->add_on_start_callback(client, remote.repo_id_)) {
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::accept_datalink "
"got started link %@.\n", link.in()), 2);
return AcceptConnectResult(link._retn());
}
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::accept_datalink "
"no existing TcpConnection.\n"), 2);
add_pending_connection(client, link.in());
// no link ready, passive_connection will complete later
return AcceptConnectResult(AcceptConnectResult::ACR_SUCCESS);
}
guard.release(); // connect_tcp_datalink() isn't called with connections_lock_
if (connect_tcp_datalink(link, connection) == -1) {
GuardType guard(links_lock_);
links_.unbind(key);
link = 0;
}
VDBG_LVL((LM_DEBUG, "(%P|%t) TcpTransport::accept_datalink "
"connected link %@.\n", link.in()), 2);
return AcceptConnectResult(link._retn());
}
