def connection_made(self, transport: asyncio.BaseTransport) -> None:
"""Called when a connection is established with the auto-trader."""
sock = transport.get_extra_info("socket")
peername = transport.get_extra_info("peername")
if sock is not None:
self.file_number = sock.fileno()
self.logger.info("fd=%d accepted a new connection: peer=%s:%d",
self.file_number, *(peername or ("unknown", 0)))
self.transport = transport
def connection_made(self, transport: asyncio.BaseTransport) -> None:
"""Just logging for now."""
self.transport = transport
log.debug("connected")
sock = transport.get_extra_info("socket")
if self.keepalive is not None and socket is not None:
log.debug(
"applying TCP KEEPALIVE settings: IDLE={}/INTVL={}/CNT={}".
format(
self.keepalive,
DEFAULT_TCP_KEEPALIVE_INTERVAL,
DEFAULT_TCP_KEEPALIVE_COUNT,
))
if hasattr(socket, "SO_KEEPALIVE"):
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
if hasattr(socket, "TCP_KEEPIDLE"):
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE,
self.keepalive)
if hasattr(socket, "TCP_KEEPINTVL"):
sock.setsockopt(
socket.IPPROTO_TCP,
socket.TCP_KEEPINTVL,
DEFAULT_TCP_KEEPALIVE_INTERVAL,
)
if hasattr(socket, "TCP_KEEPCNT"):
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT,
DEFAULT_TCP_KEEPALIVE_COUNT)
def connection_made(self, peerTransport: asyncio.BaseTransport):
self.peerTransport = peerTransport
peername = peerTransport.get_extra_info('peername')
sockname = peerTransport.get_extra_info('sockname')
peerAddress = peername[0] + ':' + str(peername[1])
self.lport = str(sockname[1])
listenAddress = sockname[0] + ':' + self.lport
self.peerAddress = peerAddress
self.listenAddress = listenAddress
# Connected callback
def cbConnected(future: asyncio.Future):
# Handle exception
exc = future.exception()
if exc is None:
print(peerAddress, 'connected to', listenAddress)
else:
print("Error: Redirecting connection from " + peerAddress +
' to ' + listenAddress + " was failed!",
file=sys.stderr)
# Close client connection
peerTransport.close()
# Create connection to redirector server
ctask = asyncio.ensure_future(
Client.loop.create_connection(
lambda: Client.RedirectorClient(self),
Client.redirectorServerHost, Client.redirectorServerPort))
ctask.add_done_callback(cbConnected)
def connection_made(self, transport: BaseTransport) -> None:
sock = transport.get_extra_info('socket')
if sock is not None:
_set_nodelay(sock)
h2_conn = H2Connection(config=self.h2_config)
h2_conn.initiate_connection()
initial = h2_conn.local_settings.initial_window_size
conn_delta = self.config.http2_connection_window_size - initial
stream_delta = self.config.http2_stream_window_size - initial
if conn_delta:
h2_conn.increment_flow_control_window(conn_delta)
if stream_delta:
h2_conn.update_settings({
SettingCodes.INITIAL_WINDOW_SIZE:
self.config.http2_stream_window_size,
})
self.connection = Connection(
h2_conn,
cast(Transport, transport),
config=self.config,
)
self.connection.flush()
self.connection.initialize()
self.processor = EventsProcessor(self.handler, self.connection)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
""" React to a new connection being made """
self.remote_addr = transport.get_extra_info("peername")
self.transport = transport
self.buf = bytearray()
logger.debug("SBSProtocol connected to {}".format(self.remote_addr))
self.wait_connected.set_result(None)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
ssl_object = transport.get_extra_info('ssl_object')
if ssl_object is not None:
self._ssl_enabled = True
protocol = ssl_object.selected_alpn_protocol()
else:
protocol = 'http/1.1'
if protocol == 'h2':
self._server = H2Server(
self.app,
self.loop,
transport,
self.logger,
self.access_log_format,
self.timeout,
)
else:
self._server = H11Server(
self.app,
self.loop,
transport,
self.logger,
self.access_log_format,
self.timeout,
max_incomplete_size=self.h11_max_incomplete_size,
)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
"""Capture the new transport and set the connected event."""
# NB - this will return a 4-part tuple in some cases
server, port = transport.get_extra_info('peername')[:2]
self.logger.info('connected to statsd %s:%s', server, port)
self.transport = transport
self.transport.set_protocol(self)
self.connected.set()
def connection_made(self, transport: asyncio.BaseTransport) -> None:
"""Called when the datagram endpoint is created."""
sock: socket.socket = transport.get_extra_info("socket")
if sock is not None:
self.__file_number = sock.fileno()
self.__logger.info("fd=%d information channel established",
self.__file_number)
self.__transport = transport
def get_client_ip(transport: asyncio.BaseTransport) -> Tuple[str, None]:
""" Helper function to return the IP of the client connecting to us.
Returns None on error.
"""
peername = transport.get_extra_info("peername")
if peername:
return peername[0]
return None
def data_received(self, transport: asyncio.BaseTransport,
data: bytes) -> None:
self.peername = transport.get_extra_info('peername')
for m in self.reader.data_received(data):
try:
f = getattr(self, '_m_{}'.format(m[0].lower()))
f(*m[1:])
except Exception as ex:
self.logger.error(ex)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
"""Called twice, when the execution connection and the information channel are established."""
if transport.get_extra_info("peername") is not None:
Connection.connection_made(self, transport)
self.send_message(MessageType.LOGIN,
LOGIN_MESSAGE.pack(self.team_name, self.secret),
LOGIN_MESSAGE_SIZE)
else:
Subscription.connection_made(self, transport)
def connection_made(self, transport: BaseTransport) -> None:
self.transport = typing.cast(Transport, transport)
sock = transport.get_extra_info("socket")
self.file_no = sock.fileno()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
if self._node.opts.enable_tcp_quickack:
self.enable_tcp_quickack()
if self.direction == NetworkDirection.INBOUND:
self.endpoint = IpEndpoint(*transport.get_extra_info("peername"))
logger.debug("[{}] - accepted connection.", self)
self._node.on_connection_added(self)
self.state = SocketConnectionStates.INITIALIZED
self.can_send = True
self.send()
logger.debug("[{}] - connection established successfully.", self)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
"""Accept an incoming TCP connection.
Args:
transport: Passed in asyncio.Transport
"""
peername = transport.get_extra_info('peername')
logger.debug(f"Connection made with: {peername}")
self.transport = cast(asyncio.Transport, transport)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
self.transport = cast(asyncio.Transport, transport)
self._over_ssl = transport.get_extra_info("sslcontext") is not None
self._response_waiter = self._loop.create_future()
self._command_lock = asyncio.Lock(loop=self._loop)
if self._connection_lost_callback is not None:
self._connection_lost_waiter = self._loop.create_future()
self._connection_lost_waiter.add_done_callback(
self._connection_lost_callback)
def data_received(self, transport: asyncio.BaseTransport, data: bytes) -> None:
self.peername = transport.get_extra_info('peername')
for y in self.decoder.data_received(data):
try:
# check version and vendorId
if y[1] > 16 or y[2] not in (0, 100):
return
f = getattr(self, '_y_{}'.format(binascii.hexlify(struct.pack('!H', y[0])).decode()))
f(*y[1:])
except Exception as ex:
self.logger.error(ex)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
ssl_object = transport.get_extra_info('ssl_object')
if ssl_object is not None:
protocol = ssl_object.selected_alpn_protocol()
else:
protocol = 'http/1.1'
if protocol == 'h2':
self._http_server = H2Server(self.app, self.loop, transport)
else:
self._http_server = H11Server(self.app, self.loop, transport)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
ssl_object = transport.get_extra_info("ssl_object")
if ssl_object is not None:
self._ssl_enabled = True
protocol = ssl_object.selected_alpn_protocol()
else:
protocol = "http/1.1"
if protocol == "h2":
self._server = H2Server(self.app, self.loop, self.config, transport)
else:
self._server = H11Server(self.app, self.loop, self.config, transport)
def connection_made(self, transport: BaseTransport) -> None:
sock = transport.get_extra_info('socket')
if sock is not None:
_set_nodelay(sock)
h2_conn = H2Connection(config=self.config)
h2_conn.initiate_connection()
self.connection = Connection(h2_conn,
cast(Transport, transport),
loop=self.loop)
self.connection.flush()
self.processor = EventsProcessor(self.handler, self.connection)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
self.request_start = clock_ns()
print('connection made')
self.connections.add(self)
self.transport = transport
self.flow = FlowControl(transport)
sn_info = pn_info = None # sockname, peername
t_sock = transport.get_extra_info('socket')
if t_sock is not None:
t_sock: socket.socket
# INET: (host, port)
# INET6: ???
# UNIX: path
sn_info = t_sock.getsockname()
if not sn_info:
sn_info = transport.get_extra_info('sockname')
if sn_info:
self.server = sn_info
pn_info = t_sock.getpeername()
if not pn_info:
pn_info = transport.get_extra_info('peername')
if pn_info:
self.client = pn_info
else:
print('couldnt get socket from transport')
breakpoint()
is_ssl = bool(transport.get_extra_info('sslcontext'))
self.scheme = 'https' if is_ssl else 'http'
def connection_made(self, transport: asyncio.BaseTransport) -> None:
"""
Modified ``connection_made`` that supports upgrading our transport in
place using STARTTLS.
The only difference here from StreamReaderProtocol's version is we
are setting the _transport directly on the StreamReader, rather than
calling set_transport (which will raise an AssertionError on upgrade).
"""
self._stream_reader._transport = transport # type: ignore
self._over_ssl = transport.get_extra_info('sslcontext') is not None
if self._client_connected_cb is not None: # type: ignore
self._stream_writer = asyncio.StreamWriter(
transport, self, self._stream_reader, self._loop)
res = self._client_connected_cb( # type: ignore
self._stream_reader, self._stream_writer)
if asyncio.iscoroutine(res):
self._loop.create_task(res)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
"""
Modified ``connection_made`` that supports upgrading our transport in
place using STARTTLS.
We set the _transport directly on the StreamReader, rather than calling
set_transport (which will raise an AssertionError on upgrade).
"""
if self._stream_reader is None:
raise SMTPServerDisconnected("Client not connected")
self._stream_reader._transport = transport # type: ignore
self._over_ssl = transport.get_extra_info("sslcontext") is not None
self._stream_writer = asyncio.StreamWriter(transport, self,
self._stream_reader,
self._loop)
self._client_connected_cb( # type: ignore
self._stream_reader, self._stream_writer)
def connection_made(self, transport: BaseTransport) -> None:
transport = typing.cast(Transport, transport)
if self._endpoint is None:
self._endpoint = IpEndpoint(*transport.get_extra_info("peername"))
endpoint = self._endpoint
assert endpoint is not None
if self._is_server:
try:
cert = self.get_peer_certificate(transport)
key = extensions_factory.get_node_id(cert)
if key is None:
key = endpoint.ip_address
except TypeError:
key = endpoint.ip_address
attempts = self._node.report_connection_attempt(key)
if attempts >= constants.MAX_HIGH_RECONNECT_ATTEMPTS_ALLOWED:
logger.debug(
"Rejecting connection attempt from {} / {}. Too many attempts: {}",
self._endpoint, key, attempts)
# transport.abort()
# return
if sys.version.startswith("3.6."):
protocol_cls = SocketConnectionProtocolPy36
else:
from bxcommon.network.socket_connection_protocol import SocketConnectionProtocol
protocol_cls = SocketConnectionProtocol
if self._is_server:
endpoint = None
delegate_protocol = protocol_cls(self._node, endpoint, self.is_ssl)
delegate_protocol.connection_made(transport)
self._delegate_protocol = delegate_protocol
def connection_made(self, transport: asyncio.BaseTransport) -> None:
super().connection_made(transport)
sock = transport.get_extra_info('socket')
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
def connection_made(self, transport: asyncio.BaseTransport) -> None:
self.transport = transport
self.peer = transport.get_extra_info(
"peername") # type: Tuple[str, int]
logger.debug(f"{self.__class__.__name__} connected to {self.peer}")
self.server.register_protocol(self.peer, self)
