def test_echo_no_sni():
"""Test against public echo server."""
try:
from lomond import session
has_sni = session.HAS_SNI
session.HAS_SNI = False
ws = lomond.WebSocket('wss://echo.websocket.org')
events = []
for event in ws.connect(poll=60, ping_rate=0, auto_pong=False):
events.append(event)
if event.name == 'ready':
ws.send_text(u'foo')
ws.send_binary(b'bar')
ws.close()
assert len(events) == 8
assert events[0].name == 'connecting'
assert events[1].name == 'connected'
assert events[2].name == 'ready'
assert events[3].name == 'poll'
assert events[4].name == 'text'
assert events[4].text == u'foo'
assert events[5].name == 'binary'
assert events[5].data == b'bar'
assert events[6].name == 'closed'
assert events[7].name == 'disconnected'
assert events[7].graceful
finally:
session.HAS_SNI = has_sni
def __init__(self, url):
self._websocket = lomond.WebSocket(debugger_url)
self._id = 0
self._messages = Queue.Queue()
self._locks = {}
self._results = {}
self._exit_event = threading.Event()
def http_connect_tunnel(
master: str, service: str, cert_file: Optional[str], cert_name: Optional[str]
) -> None:
parsed_master = request.parse_master_address(master)
assert parsed_master.hostname is not None, "Failed to parse master address: {}".format(master)
url = request.make_url(master, "proxy/{}/".format(service))
ws = lomond.WebSocket(request.maybe_upgrade_ws_scheme(url))
# We can't send data to the WebSocket before the connection becomes ready, which takes a bit of
# time; this semaphore lets the sending thread wait for that to happen.
ready_sem = threading.Semaphore(0)
# Directly using sys.stdin.buffer.read or sys.stdout.buffer.write would block due to
# buffering; instead, we use unbuffered file objects based on the same file descriptors.
unbuffered_stdin = os.fdopen(sys.stdin.fileno(), "rb", buffering=0)
unbuffered_stdout = os.fdopen(sys.stdout.fileno(), "wb", buffering=0)
c1 = threading.Thread(target=copy_to_websocket, args=(ws, unbuffered_stdin, ready_sem))
c2 = threading.Thread(
target=copy_from_websocket, args=(unbuffered_stdout, ws, ready_sem, cert_file, cert_name)
)
c1.start()
c2.start()
c1.join()
c2.join()
def __init__(self, env: det.EnvContext) -> None:
self.env = env
url = "{}://{}:{}/ws/trial/{}/{}/{}".format(
"wss" if self.env.use_tls else "ws",
self.env.master_addr,
self.env.master_port,
self.env.initial_workload.experiment_id,
self.env.initial_workload.trial_id,
self.env.container_id,
)
# Disable reading proxy configuration because we shouldn't proxy our
# own connection to the master.
self.socket = lomond.WebSocket(url, proxies={})
self.ws_events = self.socket.connect(
ping_rate=0,
session_class=lambda socket: CustomSSLWebsocketSession(
socket, env))
# Handle the messages up to and including the rendezvous message.
for ws_event in self.ws_events:
ri = self.check_for_rendezvous_info(ws_event)
if ri is None:
continue
self.rendezvous_info = ri
break
else:
raise ValueError(
"Ran out of events without finding rendezvous message")
def test_no_url_ws():
"""Test against a URL that doesn't serve websockets."""
ws = lomond.WebSocket('ws://foo.test')
events = list(ws.connect())
assert len(events) == 2
assert events[0].name == 'connecting'
assert events[1].name == 'connect_fail'
def ws(host: str, path: str) -> WebSocket:
"""
Connect to a web socket at the remote API.
"""
websocket = lomond.WebSocket(maybe_upgrade_ws_scheme(make_url(host, path)))
token = authentication.Authentication.instance().get_session_token()
websocket.add_header("Authorization".encode(), "Bearer {}".format(token).encode())
return WebSocket(websocket)
def test_not_ws():
"""Test against a URL that doesn't serve websockets."""
ws = lomond.WebSocket('wss://www.google.com')
events = list(ws.connect())
assert len(events) == 4
assert events[0].name == 'connecting'
assert events[1].name == 'connected'
assert events[2].name == 'rejected'
assert events[3].name == 'disconnected'
def _request_lock(
self, lock_request_url: str, expected_response: str
) -> Generator[None, None, None]:
with lomond.WebSocket(lock_request_url) as socket:
for event in socket.connect():
if isinstance(event, lomond.events.Text):
assert event.text == expected_response
yield
socket.close()
def __init__(self, host, port, path, debug=False):
"""Initialize the WebSocket Client"""
self._port = port
self._debug = debug
self._address = "ws://" + host + ":" + str(port) + "/" + path
self._queue = utils.GenericReceivingQueue()
self._logger = logging.getLogger(self.__class__.__name__)
self._conn = lomond.WebSocket(self._address, protocols=["v1.usp"])
self._logger.info("Trying to connect to: %s", self._address)
def _request_lock(
self, lock_request_url: str, expected_response: str
) -> Generator[None, None, None]:
with lomond.WebSocket(lock_request_url) as socket:
for event in socket.connect(
session_class=lambda socket: CustomSSLWebsocketSession(
socket, self._skip_verify, self._coordinator_cert_file
)
):
if isinstance(event, lomond.events.Text):
assert event.text == expected_response
yield
socket.close()
def test_echo_poll():
"""Test against public echo server."""
# TODO: host our own echo server
ws = lomond.WebSocket('wss://echo.websocket.org')
_events = []
polls = 0
for event in ws.connect(poll=1.0, ping_rate=1.0, auto_pong=True):
_events.append(event)
if event.name == 'poll':
polls += 1
if polls == 1:
ws.session._on_event(events.Ping(b'foo'))
elif polls == 2:
# Covers some lesser used code paths
ws.state.closed = True
ws.session._sock.close()
async def connect(self, uri):
websocket = lomond.WebSocket(uri)
for header, value in self.headers.items():
websocket.add_header(str.encode(header), str.encode(value))
for event in websocket.connect(ping_rate=5):
if event.name == 'text':
message = json.loads(event.text)
self.logger.debug(message)
if 'error' in message and message['error'] == 'Auth not valid':
raise ConnectionRefusedError('User ID/Bearer invalid. Please check your settings.ini.')
elif message['type'] == 'interaction' and self.show_chat and not self.block_chat:
self.logger.info(f'{message["metadata"]["username"]}: {message["metadata"]["message"]}')
elif message['type'] == 'question':
question = unidecode(message['question'])
choices = [unidecode(choice['text']) for choice in message['answers']]
self.logger.info('\n' * 5)
self.logger.info(f'Question {message["questionNumber"]} out of {message["questionCount"]}')
self.logger.info(question, extra={"pre": colorama.Fore.BLUE})
self.logger.info(f'Choices: {", ".join(choices)}', extra={'pre': colorama.Fore.BLUE})
await self.question_handler.answer_question(question, choices)
self.block_chat = True
elif self.show_question_summary and message['type'] == 'questionSummary':
question = unidecode(message['question'])
self.logger.info(f'Question summary: {question}', extra={'pre': colorama.Fore.BLUE})
for answer in message['answerCounts']:
ans_str = unidecode(answer['answer'])
self.logger.info(f'{ans_str}:{answer["count"]}:{answer["correct"]}',
extra={'pre': colorama.Fore.GREEN if answer['correct'] else colorama.Fore.RED})
self.logger.info(f'{message["advancingPlayersCount"]} players advancing')
self.logger.info(f'{message["eliminatedPlayersCount"]} players eliminated\n')
elif self.show_chat and self.block_chat and message['type'] == 'questionClosed':
self.block_chat = False
self.logger.info('\n' * 5)
self.logger.info('Disconnected.')
def test_echo():
"""Test against public echo server."""
# TODO: host our own echo server
ws = lomond.WebSocket('wss://echo.websocket.org')
events = []
for event in ws.connect(poll=60, ping_rate=0, auto_pong=False):
events.append(event)
if event.name == 'ready':
ws.send_text(u'foo')
ws.send_binary(b'bar')
ws.close()
assert len(events) == 8
assert events[0].name == 'connecting'
assert events[1].name == 'connected'
assert events[2].name == 'ready'
assert events[3].name == 'poll'
assert events[4].name == 'text'
assert events[4].text == u'foo'
assert events[5].name == 'binary'
assert events[5].data == b'bar'
assert events[6].name == 'closed'
assert events[7].name == 'disconnected'
assert events[7].graceful
def send_and_die(lock_request_url: str) -> None:
with lomond.WebSocket(lock_request_url) as socket:
for event in socket.connect():
if isinstance(event, lomond.events.Text):
return
def __init__(self, ws_addr):
self.ws = lomond.WebSocket(ws_addr)
self.sendQ = list()
self.recvQ = list()
run_forever(self.run_in_bg)
'--remote-debugging-port=%s' % port, 'http://example.com/5543'
],
stderr=open(os.devnull, 'w'))
try:
while True:
try:
instances = get_json('http://localhost:%s/json' % port)
break
except:
pass
for instance in instances:
if instance['url'] == 'http://example.com/5543':
debugger_url = instance['webSocketDebuggerUrl']
break
else:
raise Exception('Could not find browser')
websocket = lomond.WebSocket(debugger_url)
from lomond.persist import persist
for event in persist(websocket):
print event.name
if event.name == 'ready':
websocket.send_text(
u'{"id":122,"method":"Page.navigate","params":{"url":"http://bocoup.com"}}'
)
finally:
chrome.terminate()
shutil.rmtree(profile_dir)
def __init__(self, ws_addr):
self.ws = lomond.persist.persist(lomond.WebSocket(self.ws_addr))
self.ws_iter = None
def connect(self):
self._ws = lomond.WebSocket("ws://%s/%s" % (self.endpoint, self._ws_params()['url_path']))
async def connect(self, uri):
websocket = lomond.WebSocket(uri)
for header, value in self.headers.items():
websocket.add_header(str.encode(header), str.encode(value))
for event in websocket.connect(ping_rate=5):
if event.name == "text":
message = json.loads(event.text)
self.logger.debug(message)
if "error" in message and message["error"] == "Auth not valid":
raise ConnectionRefusedError(
"User ID/Bearer invalid. Please check your settings.ini."
)
elif message[
"type"] == "interaction" and self.show_chat and not self.block_chat:
self.logger.info(
f"{message['metadata']['username']}: {message['metadata']['message']}"
)
elif message["type"] == "question":
question = unidecode(message["question"])
choices = [
unidecode(choice["text"])
for choice in message["answers"]
]
self.logger.info("\n" * 5)
self.logger.info(
f"Question {message['questionNumber']} out of {message['questionCount']}"
)
self.logger.info(question,
extra={"pre": colorama.Fore.BLUE})
self.logger.info(f"Choices: {', '.join(choices)}",
extra={"pre": colorama.Fore.BLUE})
await self.question_handler.answer_question(
question, choices)
self.block_chat = True
elif self.show_question_summary and message[
"type"] == "questionSummary":
question = unidecode(message["question"])
self.logger.info(f"Question summary: {question}",
extra={"pre": colorama.Fore.BLUE})
for answer in message["answerCounts"]:
ans_str = unidecode(answer["answer"])
self.logger.info(
f"{ans_str}:{answer['count']}:{answer['correct']}",
extra={
"pre":
colorama.Fore.GREEN
if answer['correct'] else colorama.Fore.RED
})
self.logger.info(
f"{message['advancingPlayersCount']} players advancing"
)
self.logger.info(
f"{message['eliminatedPlayersCount']} players eliminated\n"
)
elif self.show_chat and self.block_chat and message[
"type"] == "questionClosed":
self.block_chat = False
self.logger.info("\n" * 5)
self.logger.info("Disconnected.")
