def listen_forever(
callsign: str, callback: Callable[[str, str, float, str, int, str], None]
) -> asyncio.AbstractEventLoop:
"""Begin listening for events coming in from the Reverse Beacon Network
Args:
callsign (str): Your (or the user's) callsign
callback (Callable[[spotter: str, spotted: str, frequency: float, mode: str, strength: int, timecode: str], None]): Callback function
"""
# Get the event loop
loop = asyncio.get_event_loop()
# Coroutines for each Telnet server
RBN_LOGGER.debug("Opening telnet connections")
cw_coro = telnetlib3.open_connection(
'telnet.reversebeacon.net',
7000,
shell=lambda r, w: telnet_handler(r, w, callsign, callback))
ft8_coro = telnetlib3.open_connection(
'telnet.reversebeacon.net',
7001,
shell=lambda r, w: telnet_handler(r, w, callsign, callback))
# Register with the event loop
RBN_LOGGER.debug("Begining event loop")
reader, writer = loop.run_until_complete(cw_coro)
reader, writer = loop.run_until_complete(ft8_coro)
loop.run_until_complete(writer.protocol.waiter_closed)
return loop
def test_telnet_server_reject_environ(event_loop, bind_host,
unused_tcp_port):
"""Test Client's callback method send_environ() for specific requests."""
from telnetlib3.telopt import SB, NEW_ENVIRON
# given
given_cols = 19
given_rows = 84
given_encoding = 'cp437'
given_term = 'vt220'
class ServerTestEnviron(telnetlib3.TelnetServer):
def on_request_environ(self):
return None
yield from telnetlib3.create_server(
protocol_factory=ServerTestEnviron,
host=bind_host, port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
cols=given_cols, rows=given_rows, encoding=given_encoding,
term=given_term, connect_minwait=0.05, connect_maxwait=0.05)
# this causes the client to expect the server to have demanded environment
# values, since it did, of course demand DO NEW_ENVIRON! However, our API
# choice here has chosen not to -- the client then indicates this as a
# failed sub-negotiation (SB + NEW_ENVIRON).
_failed = {key: val for key, val in writer.pending_option.items() if val}
assert _failed == {SB + NEW_ENVIRON: True}
def test_telnet_client_send_xdisploc(event_loop, bind_host, unused_tcp_port):
"""Test Client's callback method send_xdisploc()."""
# given
_waiter = asyncio.Future()
given_xdisploc = 'alpha'
class ServerTestXdisploc(telnetlib3.TelnetServer):
def on_xdisploc(self, xdisploc):
super().on_xdisploc(xdisploc)
_waiter.set_result(xdisploc)
def begin_advanced_negotiation(self):
from telnetlib3.telopt import DO, XDISPLOC
super().begin_advanced_negotiation()
self.writer.iac(DO, XDISPLOC)
yield from telnetlib3.create_server(protocol_factory=ServerTestXdisploc,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
xdisploc=given_xdisploc,
connect_minwait=0.05)
recv_xdisploc = yield from asyncio.wait_for(_waiter, 0.5)
assert recv_xdisploc == given_xdisploc
def test_telnet_client_send_tspeed(event_loop, bind_host, unused_tcp_port):
"""Test Client's callback method send_tspeed()."""
# given
_waiter = asyncio.Future()
given_rx, given_tx = 1337, 1919
class ServerTestTspeed(telnetlib3.TelnetServer):
def on_tspeed(self, rx, tx):
super().on_tspeed(rx, tx)
_waiter.set_result((rx, tx))
def begin_advanced_negotiation(self):
from telnetlib3.telopt import DO, TSPEED
super().begin_advanced_negotiation()
self.writer.iac(DO, TSPEED)
yield from telnetlib3.create_server(protocol_factory=ServerTestTspeed,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
tspeed=(given_rx, given_tx),
connect_minwait=0.05)
recv_rx, recv_tx = yield from asyncio.wait_for(_waiter, 0.5)
assert recv_rx == given_rx
assert recv_tx == given_tx
def test_send_iac_dont_dont(event_loop, bind_host, unused_tcp_port):
"""Try a DONT and ensure it cannot be sent twice."""
from telnetlib3.telopt import DONT, ECHO
_waiter = asyncio.Future()
yield from telnetlib3.create_server(
protocol_factory=telnetlib3.BaseServer, host=bind_host,
port=unused_tcp_port, loop=event_loop, connect_maxwait=0.05,
_waiter_connected=_waiter)
_, client_writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_minwait=0.05)
# say it once,
result = client_writer.iac(DONT, ECHO)
assert result == True
# say it again, suppressed
result = client_writer.iac(DONT, ECHO)
assert result == False
server_writer = (yield from asyncio.wait_for(_waiter, 0.5)).writer
assert client_writer.remote_option[ECHO] is False
assert server_writer.local_option[ECHO] is False
def test_telnet_client_send_naws(event_loop, bind_host, unused_tcp_port):
"""Test Client's NAWS of callback method send_naws()."""
# given a server
_waiter = asyncio.Future()
given_cols, given_rows = 40, 20
class ServerTestNaws(telnetlib3.TelnetServer):
def on_naws(self, width, height):
super().on_naws(width, height)
_waiter.set_result((height, width))
yield from telnetlib3.create_server(protocol_factory=ServerTestNaws,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
connect_maxwait=0.05)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
cols=given_cols,
rows=given_rows,
connect_minwait=0.05)
recv_cols, recv_rows = yield from asyncio.wait_for(_waiter, 0.5)
assert recv_cols == given_cols
assert recv_rows == given_rows
def test_telnet_client_no_charset(event_loop, bind_host, unused_tcp_port):
"""Test Client's callback method send_charset() does not select."""
# given
_waiter = asyncio.Future()
class ServerTestCharset(telnetlib3.TelnetServer):
def on_request_charset(self):
return ['illegal', 'this-is-no-good-either']
class ClientTestCharset(telnetlib3.TelnetClient):
def send_charset(self, offered):
selected = super().send_charset(offered)
_waiter.set_result(selected)
return selected
yield from telnetlib3.create_server(protocol_factory=ServerTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
client_factory=ClientTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
encoding='latin1',
connect_minwait=0.05)
# charset remains latin1
val = yield from asyncio.wait_for(_waiter, 0.5)
assert val == ''
assert writer.get_extra_info('charset') == 'latin1'
async def test_telnet_client_negotiation_fail(
event_loop, bind_host, unused_tcp_port):
"""Test telnetlib3.TelnetCLient() negotiation failure with server."""
class ClientNegotiationFail(telnetlib3.TelnetClient):
def connection_made(self, transport):
from telnetlib3.telopt import WILL, TTYPE
super().connection_made(transport)
# this creates a pending negotiation demand from the client-side.
self.writer.iac(WILL, TTYPE)
# a server that never responds with nothing.
await event_loop.create_server(asyncio.Protocol,
bind_host, unused_tcp_port)
given_minwait = 0.05
given_maxwait = 0.100
stime = time.time()
reader, writer = await asyncio.wait_for(telnetlib3.open_connection(
client_factory=ClientNegotiationFail, host=bind_host,
port=unused_tcp_port,
connect_minwait=given_minwait,
connect_maxwait=given_maxwait), 5)
elapsed_ms = int((time.time() - stime) * 1e3)
expected_ms = int(given_maxwait * 1e3)
assert expected_ms <= elapsed_ms <= expected_ms + 50
def test_telnet_client_and_server_escape_iac_binary(event_loop, bind_host,
unused_tcp_port):
"""Ensure that IAC (byte 255) may be sent across the wire in binary."""
# given
_waiter = asyncio.Future()
given_string = bytes(range(256)) * 2
yield from telnetlib3.create_server(host=bind_host,
port=unused_tcp_port,
_waiter_connected=_waiter,
loop=event_loop,
encoding=False,
connect_maxwait=0.05)
client_reader, client_writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
encoding=False,
connect_minwait=0.05)
server = yield from asyncio.wait_for(_waiter, 0.5)
server.writer.write(given_string)
result = yield from client_reader.read(len(given_string))
assert result == given_string
server.writer.close()
eof = yield from asyncio.wait_for(client_reader.read(), 0.5)
assert eof == b''
def test_telnet_client_and_server_encoding_bidirectional(
event_loop, bind_host, unused_tcp_port):
"""Given a default encoding for client and server, client always wins!"""
# given
_waiter = asyncio.Future()
yield from telnetlib3.create_server(host=bind_host,
port=unused_tcp_port,
_waiter_connected=_waiter,
loop=event_loop,
encoding='latin1',
connect_maxwait=0.05)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
encoding='cp437',
connect_minwait=0.05)
srv_instance = yield from asyncio.wait_for(_waiter, 0.5)
assert srv_instance.encoding(incoming=True) == 'cp437'
assert srv_instance.encoding(outgoing=True) == 'cp437'
assert srv_instance.encoding(incoming=True, outgoing=True) == 'cp437'
assert writer.protocol.encoding(incoming=True) == 'cp437'
assert writer.protocol.encoding(outgoing=True) == 'cp437'
assert writer.protocol.encoding(incoming=True, outgoing=True) == 'cp437'
async def test_telnet_client_send_charset(event_loop, bind_host, unused_tcp_port):
"""Test Client's callback method send_charset() selection for illegals."""
# given
_waiter = asyncio.Future()
class ServerTestCharset(telnetlib3.TelnetServer):
def on_request_charset(self):
return ['illegal', 'cp437']
class ClientTestCharset(telnetlib3.TelnetClient):
def send_charset(self, offered):
selected = super().send_charset(offered)
_waiter.set_result(selected)
return selected
await asyncio.wait_for(
telnetlib3.create_server(
protocol_factory=ServerTestCharset,
host=bind_host, port=unused_tcp_port,
loop=event_loop),
0.15)
reader, writer = await asyncio.wait_for(
telnetlib3.open_connection(
client_factory=ClientTestCharset,
host=bind_host, port=unused_tcp_port, loop=event_loop,
encoding='latin1', connect_minwait=0.05),
0.15)
val = await asyncio.wait_for(_waiter, 1.5)
assert val == 'cp437'
assert writer.get_extra_info('charset') == 'cp437'
def test_telnet_client_send_environ(event_loop, bind_host,
unused_tcp_port):
"""Test Client's callback method send_environ() for specific requests."""
# given
_waiter = asyncio.Future()
given_cols = 19
given_rows = 84
given_encoding = 'cp437'
given_term = 'vt220'
class ServerTestEnviron(telnetlib3.TelnetServer):
def on_environ(self, mapping):
super().on_environ(mapping)
_waiter.set_result(mapping)
yield from telnetlib3.create_server(
protocol_factory=ServerTestEnviron,
host=bind_host, port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
cols=given_cols, rows=given_rows, encoding=given_encoding,
term=given_term, connect_minwait=0.05)
mapping = yield from asyncio.wait_for(_waiter, 0.5)
assert mapping == {
'COLUMNS': str(given_cols),
'LANG': 'en_US.' + given_encoding,
'LINES': str(given_rows),
'TERM': 'vt220'
}
def test_telnet_client_idle_duration_minwait(event_loop, bind_host,
unused_tcp_port):
"""Exercise TelnetClient.idle property and minimum connection time."""
from telnetlib3.telopt import IAC, WONT, TTYPE
# a server that doesn't care
yield from event_loop.create_server(asyncio.Protocol, bind_host,
unused_tcp_port)
given_minwait = 0.100
stime = time.time()
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
connect_minwait=given_minwait,
connect_maxwait=given_minwait)
elapsed_ms = int((time.time() - stime) * 1e3)
expected_ms = int(given_minwait * 1e3)
assert expected_ms <= elapsed_ms <= expected_ms + 50
# verify
assert 0 <= writer.protocol.idle <= 0.5
assert 0 <= writer.protocol.duration <= 0.5
def test_telnet_reader_read_exactly_bytes(
event_loop, bind_host, unused_tcp_port):
"""Ensure TelnetReader.readexactly, especially IncompleteReadError."""
# given
_waiter = asyncio.Future()
given = string.ascii_letters.encode('ascii')
given_partial = b'zzz'
def shell(reader, writer):
writer.write(given + given_partial)
writer.close()
yield from telnetlib3.create_server(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_maxwait=0.05, shell=shell, encoding=False)
client_reader, client_writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_minwait=0.05, encoding=False)
# exercise, readexactly # bytes of given
result = yield from asyncio.wait_for(
client_reader.readexactly(len(given)), 0.5)
# verify,
assert result == given
# exercise, read 1 byte beyond given_partial
given_readsize = len(given_partial) + 1
with pytest.raises(asyncio.IncompleteReadError) as exc_info:
result = yield from asyncio.wait_for(
client_reader.readexactly(given_readsize), 0.5)
assert exc_info.value.partial == given_partial
assert exc_info.value.expected == given_readsize
def test_telnet_client_negotiation_fail(event_loop, bind_host,
unused_tcp_port):
"""Test telnetlib3.TelnetCLient() negotiation failure with server."""
class ClientNegotiationFail(telnetlib3.TelnetClient):
def connection_made(self, transport):
from telnetlib3.telopt import WILL, TTYPE
super().connection_made(transport)
# this creates a pending negotiation demand from the client-side.
self.writer.iac(WILL, TTYPE)
# a server that never responds with nothing.
yield from event_loop.create_server(asyncio.Protocol, bind_host,
unused_tcp_port)
given_minwait = 0.05
given_maxwait = 0.100
stime = time.time()
reader, writer = yield from asyncio.wait_for(
telnetlib3.open_connection(client_factory=ClientNegotiationFail,
host=bind_host,
port=unused_tcp_port,
connect_minwait=given_minwait,
connect_maxwait=given_maxwait), 5)
elapsed_ms = int((time.time() - stime) * 1e3)
expected_ms = int(given_maxwait * 1e3)
assert expected_ms <= elapsed_ms <= expected_ms + 50
def test_telnet_reader_read_beyond_limit_bytes(
event_loop, bind_host, unused_tcp_port):
"""Ensure ability to read(-1) beyond segment sizes of reader._limit."""
# given
_waiter = asyncio.Future()
limit = 10
def shell(reader, writer):
assert reader._limit == limit
given = b'x' * (limit + 1)
writer.write(given)
writer.close()
yield from telnetlib3.create_server(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_maxwait=0.05, shell=shell, encoding=False, limit=limit)
client_reader, client_writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_minwait=0.05, encoding=False, limit=limit)
assert client_reader._limit == limit
value = yield from asyncio.wait_for(client_reader.read(), 0.5)
assert value == b'x' * (limit + 1)
async def test_telnet_client_send_charset(event_loop, bind_host,
unused_tcp_port):
"""Test Client's callback method send_charset() selection for illegals."""
# given
_waiter = asyncio.Future()
class ServerTestCharset(telnetlib3.TelnetServer):
def on_request_charset(self):
return ['illegal', 'cp437']
class ClientTestCharset(telnetlib3.TelnetClient):
def send_charset(self, offered):
selected = super().send_charset(offered)
_waiter.set_result(selected)
return selected
await asyncio.wait_for(
telnetlib3.create_server(protocol_factory=ServerTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop), 0.15)
reader, writer = await asyncio.wait_for(
telnetlib3.open_connection(client_factory=ClientTestCharset,
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
encoding='latin1',
connect_minwait=0.05), 0.15)
val = await asyncio.wait_for(_waiter, 1.5)
assert val == 'cp437'
assert writer.get_extra_info('charset') == 'cp437'
def main(self):
loop = asyncio.get_event_loop()
coro = telnetlib3.open_connection(self.server_ip, 23, shell=self.shell)
reader, writer = loop.run_until_complete(coro)
print('debut-fin')
loop.run_until_complete(writer.protocol.waiter_closed)
file_name = self.file_name
def _telnet_connect(self):
logger.debug("Connecting to GrandMA2...")
self._telnet = telnetlib3.open_connection(
self._config['grandma']['address'].get(),
self._config['grandma']['port'].get(),
shell=self._telnet_shell,
log=logger
)
self._reader, self._writer = self.loop.run_until_complete(self._telnet)
def test_telnet_client_open_close_by_write(event_loop, bind_host,
unused_tcp_port):
"""Exercise BaseClient.connection_lost() on writer closed."""
yield from event_loop.create_server(asyncio.Protocol, bind_host,
unused_tcp_port)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, connect_minwait=0.05)
writer.close()
assert (yield from reader.read()) == ''
def do_step(self):
# device, db, table):
routine = CustomRoutine(self.group, self.dev_name, self.device,
self.db, self.sql_table, self.sql_table2)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
coro = telnetlib3.open_connection(self.telnet_addr,
self.telnet_port,
shell=routine.mesh_reader)
reader, writer = loop.run_until_complete(coro)
loop.run_until_complete(writer.protocol.waiter_closed)
self.latest = str(
datetime.datetime.now()) + " Async Routine Complete. "
def test_telnet_client_open_close_by_error(event_loop, bind_host,
unused_tcp_port):
"""Exercise BaseClient.connection_lost() on error."""
yield from event_loop.create_server(asyncio.Protocol, bind_host,
unused_tcp_port)
class GivenException(Exception):
pass
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, connect_minwait=0.05)
writer.protocol.connection_lost(GivenException("candy corn 4 everyone"))
with pytest.raises(GivenException):
yield from reader.read()
async def connect(self):
# https://telnetlib3.readthedocs.io/en/latest/intro.html
# loop = asyncio.get_event_loop()
# coro = telnetlib3.open_connection(self.telnet_host, self.telnet_port, shell=self.shell) # , loop=self.loop
# https://stackoverflow.com/questions/36342899/asyncio-ensure-future-vs-baseeventloop-create-task-vs-simple-coroutine
# https://docs.python.org/3/library/asyncio-future.html#asyncio.ensure_future
# https://stackoverflow.com/questions/28609534/python-asyncio-force-timeout
#task = asyncio.ensure_future(coro) # asyncio.create_task(coro()) #
#reader, writer = loop.run_until_complete(asyncio.wait_for(task, 30))
#reader, writer = self.loop.run_until_complete(coro)
#self.loop.run_until_complete(writer.protocol.waiter_closed)
tries = 0
while (not await self.is_connected()
and tries < self.connection_retries):
tries += 1
self._waiter_connected = self.loop.create_future(
) #asyncio.Future()
self._waiter_closed = self.loop.create_future() #asyncio.Future()
# https://stackoverflow.com/questions/50678184/how-to-pass-additional-parameters-to-handle-client-coroutine
# reader, writer = await telnetlib3.open_connection(self.telnet_host, self.telnet_port, shell=self.shell, loop=self.loop)
try:
#self.reader, self.writer = await telnetlib3.open_connection(self.host, self.port, loop=self.loop)
self.reader, self.writer = await asyncio.shield(
asyncio.wait_for(telnetlib3.open_connection(
self.host,
self.port,
waiter_closed=self._waiter_closed,
_waiter_connected=self._waiter_connected,
loop=self.loop),
self.connection_timeout,
loop=self.loop))
except asyncio.TimeoutError as e:
#except Exception as e:
# self._waiter_connected = None
# self._waiter_closed = None
logging.warning(
"Connection attempt {} timed out after {}s".format(
tries, self.connection_timeout))
#await self.shell(self.reader, self.writer)
# coro = telnetlib3.open_connection(self.telnet_host, self.telnet_port, shell=self.shell, loop=self.loop)
# task = asyncio.ensure_future(coro) # asyncio.create_task(coro()) #
# reader, writer = await asyncio.wait({task}, loop = self.loop)
return tries < self.connection_retries
def test_telnet_client_open_closed_by_peer(event_loop, bind_host,
unused_tcp_port):
"""Exercise BaseClient.connection_lost()."""
class DisconnecterProtocol(asyncio.Protocol):
def connection_made(self, transport):
# disconnect on connect
transport.close()
yield from event_loop.create_server(DisconnecterProtocol, bind_host,
unused_tcp_port)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, connect_minwait=0.05)
# read until EOF, no data received.
data_received = yield from reader.read()
assert data_received == ''
def test_telnet_client_shell_as_coroutine(event_loop, bind_host,
unused_tcp_port):
"""Test callback shell(reader, writer) as coroutine of create_server()."""
_waiter = asyncio.Future()
@asyncio.coroutine
def shell(reader, writer):
_waiter.set_result(True)
# a server that doesn't care
yield from event_loop.create_server(asyncio.Protocol,
bind_host, unused_tcp_port)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
shell=shell, connect_minwait=0.05)
yield from asyncio.wait_for(_waiter, 0.5)
def test_open_connection(bind_host, unused_tcp_port):
"""Exercise telnetlib3.open_connection with default options."""
_waiter = asyncio.Future()
yield from telnetlib3.create_server(bind_host,
unused_tcp_port,
_waiter_connected=_waiter,
connect_maxwait=0.05)
client_reader, client_writer = yield from telnetlib3.open_connection(
bind_host, unused_tcp_port, connect_minwait=0.05)
server = yield from asyncio.wait_for(_waiter, 0.5)
assert repr(server.writer) == (
'<TelnetWriter server mode:kludge +lineflow -xon_any +slc_sim '
'server-will:BINARY,ECHO,SGA '
'client-will:BINARY,CHARSET,NAWS,NEW_ENVIRON,TTYPE>')
assert repr(client_writer) == (
'<TelnetWriter client mode:kludge +lineflow -xon_any +slc_sim '
'client-will:BINARY,CHARSET,NAWS,NEW_ENVIRON,TTYPE '
'server-will:BINARY,ECHO,SGA>')
async def _connect(self):
"""Make Telnet connection."""
try:
open_future = telnetlib3.open_connection(self.host, self.port)
self._reader, self._writer = await asyncio.wait_for(
open_future, self.timeout)
except Exception as error:
raise error from error
self._response_handler_task = asyncio.create_task(
self._response_handler())
self._state = const.STATE_CONNECTED
self._command_queue_task = asyncio.create_task(
self._process_command_queue())
if self._heart_beat_interval is not None and self._heart_beat_interval > 0:
self._heart_beat_task = asyncio.create_task(self._heart_beat())
_LOGGER.debug("Connected to %s", self.host)
self._avr.dispatcher.send(const.SIGNAL_TELNET_EVENT,
const.EVENT_CONNECTED)
def test_telnet_client_send_var_uservar_environ(event_loop, bind_host,
unused_tcp_port):
"""Test Client's callback method send_environ() for VAR/USERVAR request."""
# given
_waiter = asyncio.Future()
given_cols = 19
given_rows = 84
given_encoding = 'cp437'
given_term = 'vt220'
class ServerTestEnviron(telnetlib3.TelnetServer):
def on_environ(self, mapping):
super().on_environ(mapping)
_waiter.set_result(mapping)
def on_request_environ(self):
from telnetlib3.telopt import VAR, USERVAR
return [VAR, USERVAR]
yield from telnetlib3.create_server(
protocol_factory=ServerTestEnviron,
host=bind_host, port=unused_tcp_port,
loop=event_loop)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
cols=given_cols, rows=given_rows, encoding=given_encoding,
term=given_term, connect_minwait=0.05, connect_maxwait=0.05)
mapping = yield from asyncio.wait_for(_waiter, 0.5)
# although nothing was demanded by server,
assert mapping == {}
# the client still volunteered these basic variables,
mapping == {
'COLUMNS': str(given_cols),
'LANG': 'en_US.' + given_encoding,
'LINES': str(given_rows),
'TERM': 'vt220'
}
for key, val in mapping.items():
assert writer.get_extra_info(key) == val
def test_telnet_reader_using_readline_bytes(
event_loop, bind_host, unused_tcp_port):
"""Ensure strict RFC interpretation of newlines in readline method."""
# given
_waiter = asyncio.Future()
given_expected = {
b'alpha\r\x00': b'alpha\r',
b'bravo\r\n': b'bravo\r\n',
b'charlie\n': b'charlie\n',
b'---\r': b'---\r',
b'---\r\n': b'---\r\n',
b'\r\x00': b'\r',
b'\n': b'\n',
b'\r\n': b'\r\n',
b'xxxxxxxxxxx': b'xxxxxxxxxxx',
}
def shell(reader, writer):
for item in sorted(given_expected):
writer.write(item)
writer.close()
yield from telnetlib3.create_server(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_maxwait=0.05, shell=shell, encoding=False)
client_reader, client_writer = yield from telnetlib3.open_connection(
host=bind_host, port=unused_tcp_port, loop=event_loop,
connect_minwait=0.05, encoding=False)
# exercise,
for given, expected in sorted(given_expected.items()):
result = yield from asyncio.wait_for(client_reader.readline(), 0.5)
# verify.
assert result == expected
# exercise,
eof = yield from asyncio.wait_for(client_reader.read(), 0.5)
# verify.
assert eof == b''
async def try_to_connect(self):
# a little closure to capture our ip and expose it to the parser
def client_factory():
return TelnetClient(proxy=self, encoding='utf-8')
await self.feedback('frisbee_status', "trying to telnet..")
logger.info(f"Trying to telnet on {self.control_ip}")
try:
self._reader, self._writer = await asyncio.wait_for(
telnetlib3.open_connection(
self.control_ip,
23,
shell=None,
log=logger,
connect_minwait=self.connect_minwait,
connect_maxwait=self.connect_maxwait),
timeout=self.connect_timeout)
except (asyncio.TimeoutError, OSError) as exc:
self._reader, self._writer = None, None
except Exception as exc:
logger.exception(f"telnet connect: unexpected exception {exc}")
def test_telnet_client_encoding_default(event_loop, bind_host,
unused_tcp_port):
"""Default encoding US-ASCII unless it can be negotiated/confirmed!"""
from telnetlib3.telopt import IAC, WONT, TTYPE
# given
_waiter = asyncio.Future()
yield from event_loop.create_server(asyncio.Protocol, bind_host,
unused_tcp_port)
reader, writer = yield from telnetlib3.open_connection(
host=bind_host,
port=unused_tcp_port,
loop=event_loop,
connect_minwait=0.05)
# after MIN_CONNECT elapsed, client is in US-ASCII state.
assert writer.protocol.encoding(incoming=True) == 'US-ASCII'
assert writer.protocol.encoding(outgoing=True) == 'US-ASCII'
assert writer.protocol.encoding(incoming=True, outgoing=True) == 'US-ASCII'
with pytest.raises(TypeError):
# at least one direction should be specified
writer.protocol.encoding()
import asyncio, telnetlib3
@asyncio.coroutine
def shell(reader, writer): #--shell=my_module.fn_shell
while True:
# read stream until found
outp = yield from reader.read(1024)
if not outp:
# End of File
break
# Using API library xstatus with Tandberg system
elif 'Password:'******'TANDBERGsys##01\r\nxstatus\r\n')
print(outp, flush=True)
print()
# Set the event loop to use
loop = asyncio.get_event_loop()
# Connect to a TCP Telnet server as a Telnet client
coro = telnetlib3.open_connection('10.50.18.143', 23, shell=shell)
# Blocking call which returns when connecting is done
reader, writer = loop.run_until_complete(coro)
# Executing command
writer.protocol
