def connect(self):
factory = WebSocketClientFactory(self.endpoint)
factory.protocol = self.protocol
factory.client = self
factory.kwargs = self.kwargs
factory.headers["X-Host-ID"] = self.host_id
factory.headers["X-Client-Type"] = self.type
if self.persistent:
factory.headers["X-Persistence-Policy"] = "Persistent"
else:
factory.headers["X-Persistence-Policy"] = "DeleteOnDisconnect"
if self.username:
authorization = base64.b64encode(
b"%s:%s" % (self.username, self.password)).decode("ascii")
factory.headers["Authorization"] = 'Basic %s' % authorization
if self.filter:
factory.headers["X-Gremlin-Filter"] = self.filter
if self.cookies:
factory.headers['Cookie'] = ';'.join(self.cookies)
self.loop = asyncio.get_event_loop()
u = urlparse(self.endpoint)
coro = self.loop.create_connection(factory, u.hostname, u.port)
(transport, protocol) = self.loop.run_until_complete(coro)
LOG.debug('transport, protocol: %r, %r', transport, protocol)
def run_monitoring(type, host, port, user, passwd):
log.info('Starting witness websocket monitoring on {}:{}'.format(host, port))
while True:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
_event_loops[(host, port)] = loop
log.debug('new event loop: {}'.format(loop))
log.debug('in thread {}'.format(threading.current_thread().name))
factory = WebSocketClientFactory("ws://{}:{:d}".format(host, port))
factory.protocol = partial(MonitoringProtocol, type, host, port, user, passwd)
try:
coro = loop.create_connection(factory, host, port)
loop.run_until_complete(coro)
log.info('Successfully connected to witness on {}:{}'.format(host, port))
loop.run_forever()
log.warning('Lost connection to witness node on {}:{}'.format(host, port))
except KeyboardInterrupt:
log.info('Run loop exited manually (ctrl-C)')
except OSError:
log.debug('WebSocket connection refused to {}:{}'.format(host, port))
finally:
loop.close()
with suppress(KeyError):
del _monitoring_protocols[(host, port)]
del _event_loops[(host, port)]
nseconds = core.config['monitoring']['monitor_time_interval']
time.sleep(nseconds) # wait some time before trying to reconnect
def init_app(app):
from autobahn.asyncio.websocket import WebSocketClientProtocol
from autobahn.asyncio.websocket import WebSocketClientFactory
from ws import host, port
class Client(WebSocketClientProtocol):
def __init__(self, *args):
WebSocketClientProtocol.__init__(self, *args)
self.opened = asyncio.Future()
def notify(self, **kwargs):
kwargs.setdefault('_created', datetime.utcnow().isoformat())
self.sendMessage(json.dumps(kwargs).encode('utf8'))
def onConnect(self, response):
self.opened.set_result(None)
factory = WebSocketClientFactory()
factory.protocol = Client
try:
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, host, port)
_transport, client = loop.run_until_complete(coro)
loop.run_until_complete(client.opened)
app.notification_client = client
except OSError: # no ws server running
pass
def connect(self):
factory = WebSocketClientFactory(self.endpoint)
factory.protocol = self.protocol
factory.client = self
factory.kwargs = self.kwargs
factory.headers["X-Host-ID"] = self.host_id
factory.headers["X-Client-Type"] = self.type
factory.headers["X-Client-Protocol"] = "json"
if self.persistent:
factory.headers["X-Persistence-Policy"] = "Persistent"
else:
factory.headers["X-Persistence-Policy"] = "DeleteOnDisconnect"
if self.username:
if self.auth.login():
cookie = "authtoken={}".format(self.auth.token)
if self.cookies:
self.cookies.append(cookie)
else:
self.cookies = [
cookie,
]
if self.filter:
factory.headers["X-Gremlin-Filter"] = self.filter
if self.cookies:
factory.headers["Cookie"] = ";".join(self.cookies)
coro = self.loop.create_connection(factory,
self.url.hostname,
self.url.port,
ssl=self.ssl_context)
(transport, protocol) = self.loop.run_until_complete(coro)
LOG.debug("transport, protocol: %r, %r", transport, protocol)
def run_monitoring(type, host, port, user, passwd):
log.info('Starting witness websocket monitoring on {}:{}'.format(host, port))
while True:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
_event_loops[(host, port)] = loop
log.debug('new event loop: {}'.format(loop))
log.debug('in thread {}'.format(threading.current_thread().name))
factory = WebSocketClientFactory("ws://{}:{:d}".format(host, port))
factory.protocol = partial(MonitoringProtocol, type, host, port, user, passwd)
try:
coro = loop.create_connection(factory, host, port)
loop.run_until_complete(coro)
log.info('Successfully connected to witness on {}:{}'.format(host, port))
loop.run_forever()
log.warning('Lost connection to witness node on {}:{}'.format(host, port))
except KeyboardInterrupt:
log.info('Run loop exited manually (ctrl-C)')
except OSError:
log.debug('WebSocket connection refused to {}:{}'.format(host, port))
finally:
loop.close()
with suppress(KeyError):
del _monitoring_protocols[(host, port)]
del _event_loops[(host, port)]
nseconds = core.config['monitoring']['monitor_time_interval']
time.sleep(nseconds) # wait some time before trying to reconnect
def wsfactory(address, directory, resolution, keep_old_data):
loop = asyncio.get_event_loop()
gracefully_exit_handler = functools.partial(gracefully_exit, loop)
loop.add_signal_handler(signal.SIGTERM, gracefully_exit_handler)
loop.add_signal_handler(signal.SIGINT, gracefully_exit_handler)
directory = create_directory_if_not_exists(directory)
if not keep_old_data:
remove_all_data(directory)
factory = WebSocketClientFactory("ws://{0}".format(address))
factory.protocol = STFRecordProtocol
factory.protocol.img_directory = directory
factory.protocol.address = address
factory.protocol.resolution = resolution
coro = loop.create_connection(factory,
address.split(":")[0],
address.split(":")[1])
log.info("Connecting to {0} ...".format(address))
loop.run_until_complete(coro)
try:
loop.run_forever()
finally:
loop.close()
def main():
parser = argparse.ArgumentParser(description='DAO Curator Bot')
parser.add_argument('config',
nargs='?',
help='Config module',
default='config.development')
args = parser.parse_args()
config_mod = __import__(args.config, globals(), locals(), ['AppConfig'])
appconfig = config_mod.AppConfig
factory = WebSocketClientFactory(appconfig.ETHERSCAN_WEBSOCKET_URL)
factory.protocol = EtherscanClientProtocol
factory.appconfig = appconfig
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory,
factory.host,
factory.port,
ssl=factory.isSecure)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def connect(self):
factory = WebSocketClientFactory(self.endpoint)
factory.protocol = self.protocol
factory.client = self
factory.kwargs = self.kwargs
factory.headers["X-Host-ID"] = self.host_id
factory.headers["X-Client-Type"] = self.type
if self.persistent:
factory.headers["X-Persistence-Policy"] = "Persistent"
else:
factory.headers["X-Persistence-Policy"] = "DeleteOnDisconnect"
if self.username:
authorization = base64.b64encode(
b"%s:%s" % (self.username, self.password)).decode("ascii")
factory.headers["Authorization"] = 'Basic %s' % authorization
if self.filter:
factory.headers["X-Gremlin-Filter"] = self.filter
self.loop = asyncio.get_event_loop()
u = urlparse(self.endpoint)
coro = self.loop.create_connection(factory, u.hostname, u.port)
self.loop.run_until_complete(coro)
try:
self.loop.run_forever()
except KeyboardInterrupt:
self.loop.close()
finally:
pass
def start_client(address, port):
# see http://autobahn.ws/python/websocket/programming.html
# because starting a client requires an integer port,
# while starting a server requires a string port, accept both.
if isinstance(port, str):
port = int(port)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop = asyncio.get_event_loop()
global client_loop
client_loop = loop
composite_address = 'ws://' + address + ':' + str(port)
info('client connecting to {}'.format(composite_address), INFO_ID)
factory = WebSocketClientFactory(composite_address)
factory.protocol = GameClientProtocol
info("client creating connection to address {} and port {}".format(
address, str(port)), INFO_ID)
coro = loop.create_connection(factory, address, port)
global client_protocol
transport, client_protocol = loop.run_until_complete(coro)
loop.run_forever()
def wsfactory(address, directory, resolution, keep_old_data):
loop = asyncio.get_event_loop()
gracefully_exit_handler = functools.partial(gracefully_exit, loop)
loop.add_signal_handler(signal.SIGTERM, gracefully_exit_handler)
loop.add_signal_handler(signal.SIGINT, gracefully_exit_handler)
directory = create_directory_if_not_exists(directory)
if not keep_old_data:
remove_all_data(directory)
factory = WebSocketClientFactory("ws://{0}".format(address))
factory.protocol = STFRecordProtocol
factory.protocol.img_directory = directory
factory.protocol.address = address
factory.protocol.resolution = resolution
coro = loop.create_connection(
factory, address.split(":")[0], address.split(":")[1]
)
log.info("Connecting to {0} ...".format(address))
loop.run_until_complete(coro)
try:
loop.run_forever()
finally:
loop.close()
def init_app(app):
from autobahn.asyncio.websocket import WebSocketClientProtocol
from autobahn.asyncio.websocket import WebSocketClientFactory
from ws import host, port
class Client(WebSocketClientProtocol):
def __init__(self, *args):
WebSocketClientProtocol.__init__(self, *args)
self.opened = asyncio.Future()
def notify(self, **kwargs):
kwargs.setdefault('_created', datetime.utcnow().isoformat())
self.sendMessage(json.dumps(kwargs).encode('utf8'))
def onConnect(self, response):
self.opened.set_result(None)
factory = WebSocketClientFactory()
factory.protocol = Client
try:
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, host, port)
_transport, client = loop.run_until_complete(coro)
loop.run_until_complete(client.opened)
app.notification_client = client
except OSError: # no ws server running
pass
async def connect(self):
if (self.client
is not None) and (self.client.state
== WebSocketClientProtocol.STATE_OPEN):
# return self.client.future
await self.client.future
elif (self.client
is not None) and (self.client.state
== WebSocketClientProtocol.STATE_CONNECTING):
# return self.client.future
await self.client.future
else:
future = asyncio.Future(loop=self.loop)
try:
url_parsed = urlparse(self.options['url'])
ssl = True if url_parsed.scheme == 'wss' else False
port = url_parsed.port if url_parsed.port is not None else 443 if ssl else 80
client = MyClientProtocol(self, future, self.loop,
self.options['verbose'])
if 'proxies' in list(self.options.keys()):
if url_parsed.scheme == 'wss':
proxy_url_parsed = urlparse(
self.options['proxies']['https'])
else:
proxy_url_parsed = urlparse(
self.options['proxies']['http'])
proxy = {
'host': proxy_url_parsed.hostname,
'port': proxy_url_parsed.port
}
factory = WebSocketClientFactory(self.options['url'],
proxy=proxy)
else:
factory = WebSocketClientFactory(self.options['url'] +
self.urlParam)
factory.protocol = lambda: client
fut = self.loop.create_connection(factory,
url_parsed.hostname,
port,
ssl=ssl)
self.loop.call_later(
self.timeout / 1000,
lambda: future.done() or future.set_exception(TimeoutError(
)))
await fut
# self.loop.run_until_complete(fut)
self.client = client
if ('wait-after-connect' in self.options):
await asyncio.sleep(self.options['wait-after-connect'] /
1000)
self.emit('open')
except Exception as ex:
future.done() or future.set_exception(ex)
self.emit('err', ex)
# return future
await future
def _get_connection_task(self):
"""
Create the connection task that will connect to the websocket server
:return:
"""
factory = WebSocketClientFactory(u"ws://" + str(self._address) + ":" +
str(self._port) + self._path)
factory.protocol = AgentClientProtocol
task = self._loop.create_connection(factory, self._address, self._port)
return task
def run():
import asyncio
from autobahn.asyncio.websocket import WebSocketClientFactory
factory = WebSocketClientFactory()
factory.protocol = LineClient
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 9000)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def init_app(app):
factory = WebSocketClientFactory()
factory.protocol = Client
try:
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, host, port)
_transport, client = loop.run_until_complete(coro)
loop.run_until_complete(client.opened)
app.notification_client = client
except OSError: # no ws server running
pass
def main():
factory = WebSocketClientFactory(config.WebserverConfig.server_uri)
factory.protocol = DCSSProtocol
#channel_id = DCSSProtocol.get_channel_id()
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, config.WebserverConfig.server_ip,
config.WebserverConfig.server_port)
client = loop.run_until_complete(coro)
#client[1].load_ai_agent()
loop.run_forever()
def init_app(app):
factory = WebSocketClientFactory()
factory.protocol = Client
try:
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, host, port)
_transport, client = loop.run_until_complete(coro)
loop.run_until_complete(client.opened)
app.notification_client = client
except OSError: # no ws server running
pass
def start(self):
factory = WebSocketClientFactory(config.WebserverConfig.server_uri)
factory.protocol = DCSSProtocol
#channel_id = DCSSProtocol.get_channel_id()
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory,
config.WebserverConfig.server_ip,
config.WebserverConfig.server_port)
self.client = loop.run_until_complete(coro)
self.has_started = True
loop.run_forever()
def init():
try:
factory = WebSocketClientFactory('ws://{}:{}'.format(HOST, PORT))
factory.protocol = MyClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, HOST, PORT)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
except Exception as err:
print('Error while trying to start socket client:')
print(err)
def create_connection(self, room, ws_url, agent):
"""Creates a new connection"""
factory = WebSocketClientFactory(ws_url)
factory.useragent = agent
factory.protocol = lambda: room
ws_url = urlsplit(ws_url)
conn = self.loop.create_connection(factory,
host=ws_url.netloc,
port=ws_url.port or 443,
ssl=ws_url.scheme == "wss"
)
asyncio.async(conn, loop=self.loop)
def main(argv):
# loads JSON from a file.
parametros = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', 'appOmsApi.ini'))
with open(parametros, 'r') as f:
conArgs = json.load(f)
showConf(conArgs)
# serviceUrl = 'ws://localhost:8765'
serviceUrl = 'wss://' + conArgs['login']['host'] + ':' + conArgs['stomp'][
'port'] + conArgs['stomp']['service']
print('serviceUrl: ', serviceUrl)
print()
token = 'a5a1dd5d-3dad-4949-8439-bff0ad2179b5'
wssHeader = {'Authorization': 'Bearer ' + token}
factory = WebSocketClientFactory(serviceUrl, headers=wssHeader)
factory.protocol = MyClientProtocol(conArgs)
# SSL client context: default
if factory.isSecure:
print('Secure Server')
print()
contextFactory = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
contextFactory.check_hostname = False
contextFactory.verify_mode = ssl.CERT_NONE
else:
print('WARNING!!!! NOT Secure Server')
print()
contextFactory = False
loop = asyncio.get_event_loop()
# cliente = loop.create_connection(factory, 'localhost', 8765)
cliente = loop.create_connection(factory,
host=conArgs['login']['host'],
port=conArgs['stomp']['port'],
ssl=contextFactory)
loop.run_until_complete(cliente)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
print()
print('closind cliente ....')
print()
cliente.close()
loop.close()
def run():
import asyncio
from autobahn.asyncio.websocket import WebSocketClientFactory
global ser
ser = serial.Serial(PORT, BAUD, timeout=0.5) # Open named port
factory = WebSocketClientFactory()
factory.protocol = ArduinoClient
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 9000)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def main():
executor = ProcessPoolExecutor(2)
factory = WebSocketClientFactory(config.WebserverConfig.server_uri)
factory.protocol = DCSSProtocol
#channel_id = DCSSProtocol.get_channel_id()
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, config.WebserverConfig.server_ip,
config.WebserverConfig.server_port)
client = loop.run_until_complete(coro)
client[1].load_ai_agent_from_config()
gameconnection = asyncio.create_task(loop.run_in_executor(executor, ))
loop.run_forever()
def main():
args = _parse_args()
_set_up_logging(args)
factory = WebSocketClientFactory(u"ws://%s:%s/%s" %
(args.host, args.port, args.venue))
factory.protocol = SnakebotProtocol
while True:
coro = loop.create_connection(factory, args.host, args.port)
loop.run_until_complete(coro)
loop.run_forever()
async def client():
factory = WebSocketClientFactory(URI)
factory.protocol = ClientProtocol
loop = asyncio.get_running_loop()
transport, proto = await loop.create_connection(factory, IP, PORT)
# await proto.is_open
try:
await proto.is_closed
print("Connection was closed")
finally:
transport.close()
t = normalize_t(proto.t)
print_statistics(t, len(DATA), N)
plot_statistics(t)
def run_agent(ids, interval):
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
numb = np.random.randint(0, 1000)
server_num = np.random.randint(0, 200)
randstr = str(uuid.uuid1())[:8]
url = f"wss://stream{server_num}.forexpros.com/echo/{numb}/{randstr}/websocket"
host = f"stream{server_num}.forexpros.com"
factory = WebSocketClientFactory(url)
factory.setProtocolOptions(autoPingInterval=1)
factory.protocol = BaselineExecAgent.make_subids(ids).set_timeout(interval)
return factory, host, 445, ctx
def __init__(self, url, event_handlers):
self._event_handlers = event_handlers
self._ws = asyncio.Future()
self._pendingFutures = {}
class ProxyWebSocketProtocol(WebSocketClientProtocol):
def onConnect(this, response):
self._ws.set_result(this)
def onMessage(this, message, isBinary):
result = RpcTunnel.parse_response(message)
result_id = result.get('id', None)
if result_id is None:
return
if isinstance(result_id, int):
return_type = self._pendingFutures[result_id]['return_type']
if return_type == bytearray:
result['result'] = base64.b64decode(result['result'])
RpcTunnel.set_or_raise(self._pendingFutures[result_id]['future'], result, return_type)
else:
# This is an event:
for callback_info in self._event_handlers[result_id]:
callback = callback_info['callback']
return_type = callback_info['return_type']
result = result.get('result', None)
if return_type is not None:
if return_type == bytearray:
result = base64.b64decode(result)
callback(RpcTunnel.convert(result, return_type))
else:
callback(result)
parsed_url = urlparse(url)
# TODO: generate the websocket url nicely:
self._url = url.replace('http', 'ws')
factory = WebSocketClientFactory(self._url, debug = False)
factory.protocol = ProxyWebSocketProtocol
asyncio.Task(asyncio.get_event_loop().create_connection(factory, parsed_url.hostname, parsed_url.port))
def __init__(self, loop, url, debug=False):
super(DDPClient, self).__init__()
ids = build_id_generator()
self._board = board = pubsub.MessageBoard(loop)
self._caller = pubsub.MethodCaller(board, MethodMessageFactory(ids))
factory = WebSocketClientFactory(url=url, loop=loop)
factory.protocol = pubsub.SocketPublisherFactory(board)
subscribers = [
self._caller,
pubsub.DDPConnector(board),
pubsub.Ponger(board),
pubsub.Outbox(board),
pubsub.SocketReconnector(board),
pubsub.SocketConnector(board, loop, factory),
pubsub.MessageParser(board, AddedBeforeMessageParser()),
pubsub.MessageParser(board, AddedMessageParser()),
pubsub.MessageParser(board, ChangedMessageParser()),
pubsub.MessageParser(board, ConnectedMessageParser()),
pubsub.MessageParser(board, ErrorMessageParser()),
pubsub.MessageParser(board, FailedMessageParser()),
pubsub.MessageParser(board, MovedBeforeMessageParser()),
pubsub.MessageParser(board, NosubMessageParser()),
pubsub.MessageParser(board, PingMessageParser()),
pubsub.MessageParser(board, PongMessageParser()),
pubsub.MessageParser(board, ReadyMessageParser()),
pubsub.MessageParser(board, RemovedMessageParser()),
pubsub.MessageParser(board, ResultMessageParser()),
pubsub.MessageParser(board, UpdatedMessageParser()),
pubsub.MessageSerializer(board, ConnectMessageSerializer()),
pubsub.MessageSerializer(board, MethodMessageSerializer()),
pubsub.MessageSerializer(board, PingMessageSerializer()),
pubsub.MessageSerializer(board, PongMessageSerializer()),
pubsub.MessageSerializer(board, SubMessageSerializer()),
pubsub.MessageSerializer(board, UnsubMessageSerializer()),
pubsub.PodMessageFilter(board, PodMessageFilter()),
pubsub.PodMessageParser(board, PodMessageParser()),
pubsub.PodMessageSerializer(board, PodMessageSerializer()),
]
if debug:
subscribers.append(pubsub.Logger(board))
for subscriber in subscribers:
subscriber.subscribe()
def run_simulation(args):
host, port, venue, snake = args
factory = WebSocketClientFactory(u"ws://%s:%s/%s" % (host, port, venue))
factory.protocol = SnakebotProtocol
SnakebotProtocol.snake = snake
# https://stackoverflow.com/a/51089229/2209243
connection_coro = loop.create_connection(factory, host, port)
transport, protocol = loop.run_until_complete(connection_coro)
loop.run_until_complete(protocol.wait_connection_lost())
protocol.dropConnection(abort=True)
transport.close()
return snake.result
def connect(self):
factory = WebSocketClientFactory(self.endpoint)
factory.protocol = self.protocol
factory.headers["X-Host-ID"] = self.host_id
factory.headers["X-Client-Type"] = self.type
loop = asyncio.get_event_loop()
u = urlparse(self.endpoint)
coro = loop.create_connection(factory, u.hostname, u.port)
loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
loop.close()
def join_and_run_forever(self, roomid):
session = self
#yes, I'm putting a class definition inside a method definition. I acknowledge that this is weird.
#this has to go here because I don't see any other way for the class' methods to refer to `self` properly.
class SoClient(WebSocketClientProtocol):
def onConnect(self, response): session.onConnect(response)
def onOpen(self): session.onOpen()
def onMessage(self, payload, is_binary): session.onMessage(payload)
def onClose(self, was_clean, code, reason): session.onClose(was_clean, code, reason)
url = self.join(roomid)
host = "chat.sockets.stackexchange.com"
factory = WebSocketClientFactory(url, headers={"Origin":"http://chat.stackoverflow.com"})
factory.protocol = SoClient
self.loop = asyncio.get_event_loop()
coro = self.loop.create_connection(factory, host, 80)
self.loop.run_until_complete(coro)
self.loop.run_forever()
self.loop.close()
def build_client_factory(self):
"""
Setup a cloudgatewayclientfactory object before a connection is established to Cloudgateway. Configures
things like the uri to connect on, auth headers, websocket protocol options, etc.
Returns: CloudgatewayClientFactory object
"""
headers = {'Authorization': sb_auth_header(self.encryption_context)}
if self.shard_id:
headers[constants.HEADER_SHARD_ID] = self.shard_id
self.logger.info("Using shard_id={}".format(self.shard_id))
ws_url = "wss://{0}/deployment".format(
self.config.get_spacebridge_server())
proxy, auth = self.config.get_ws_https_proxy_settings()
if auth:
headers['Proxy-Authorization'] = 'Basic ' + auth
if sys.version_info < (3, 0):
factory = cloudgateway_client_protocol.CloudgatewayClientFactory(
ws_url, headers=headers, proxy=proxy)
factory.configure(
cloudgateway_client_protocol.SpacebridgeWebsocketProtocol,
self.max_reconnect_delay)
factory.setProtocolOptions(autoFragmentSize=65536)
else:
factory = WebSocketClientFactory(ws_url, headers=headers)
factory.protocol = aio_client_protocol.AioSpacebridgeServerProtocol
factory.autoFragmentSize = 65536
factory.protocol.encryption_context = self.encryption_context
factory.protocol.system_auth_header = SplunkAuthHeader(
self.system_session_key)
factory.protocol.parent_process_monitor = self.parent_process_monitor
factory.protocol.logger = self.logger
factory.protocol.mode = self.mode
factory.protocol.cluster_monitor = self.cluster_monitor
factory.protocol.websocket_context = self.websocket_context
return factory
def test_wss(self, loop):
ws_url = "wss://{}/echo".format(config.get_spacebridge_server())
headers = {'Authorization': "f00d"}
use_proxy = self.useProxy
proxy, auth = config.get_ws_https_proxy_settings()
if use_proxy:
# Proxy setup
if auth:
headers['Proxy-Authorization'] = 'Basic ' + auth
else:
proxy = None
factory = WebSocketClientFactory(ws_url, headers=headers)
factory.protocol = CheckMobileWssProtocol
factory.state = self.echo_state
factory.loop = loop
context = ssl.create_default_context(cafile=certifi.where())
coro = loop.create_connection(factory,
config.get_spacebridge_server(),
443,
ssl=context)
self.timeout_id = loop.call_later(10, self.timeout)
try:
loop.run_until_complete(coro)
loop.run_forever()
except asyncio.TimeoutError:
self.echo_state.message = 'Timeout'
except Exception as e:
self.echo_state.message = str(e)
record = {
'websocket': self.echo_state.ok,
'message': self.echo_state.message
}
return record
def start(self, **kwargs):
host = 'www.bitsgap.com'
port = 443
ssl = True
conn_str = f'wss://{host}/ws/?wsguid={self.public_key}'
factory = WebSocketClientFactory(conn_str)
factory.protocol = MyClientProtocol
if 'callback' in kwargs:
factory.callback = kwargs['callback']
factory.base_client = self
loop = asyncio.get_event_loop()
try:
coro = loop.create_connection(factory, host, port, ssl=ssl)
loop.run_until_complete(coro)
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
loop.close()
def connect(self):
factory = WebSocketClientFactory(self.endpoint)
factory.protocol = self.protocol
factory.client = self
factory.kwargs = self.kwargs
factory.headers["X-Host-ID"] = self.host_id
factory.headers["X-Client-Type"] = self.type
factory.headers["X-Client-Protocol"] = "json"
if self.persistent:
factory.headers["X-Persistence-Policy"] = "Persistent"
else:
factory.headers["X-Persistence-Policy"] = "DeleteOnDisconnect"
if self.username:
if self.auth.login():
cookie = 'authtok={}'.format(self.auth.authtok)
if self.cookies:
self.cookies.append(cookie)
else:
self.cookies = [
cookie,
]
if self.filter:
factory.headers["X-Gremlin-Filter"] = self.filter
if self.cookies:
factory.headers['Cookie'] = ';'.join(self.cookies)
context = None
if self.url.scheme == "wss":
if self.insecure:
context = ssl._create_unverified_context()
else:
context = ssl._create_default_context()
coro = self.loop.create_connection(factory,
self.url.hostname,
self.url.port,
ssl=context)
(transport, protocol) = self.loop.run_until_complete(coro)
LOG.debug('transport, protocol: %r, %r', transport, protocol)
def run(config, botname, log_level, server_port):
logging.basicConfig(level=getattr(logging, log_level.upper()))
cfg = load_config(config, botname)
host = cfg['base-url']
group = cfg["group"]
apikey = cfg['apikey']
secret = cfg['secret']
wss_endpoint = cfg['wss-endpoint']
ssl = cfg['ssl']
port = int(cfg.get('wss-port')) or 443
global risk_engine, api
risk_engine = FuturesRiskEngine(host, apikey, secret).initialize()
api = risk_engine.api
if ssl:
connect_str = f"wss://{wss_endpoint}:{port}/{group}/api/pro/v2/stream"
else:
connect_str = f"ws://{wss_endpoint}:{port}/{group}/api/pro/v2/stream"
print("Connection string " + connect_str)
factory = WebSocketClientFactory(connect_str)
factory.protocol = create_protocol(apikey, secret)
loop = asyncio.get_event_loop()
coro_wss = loop.create_connection(factory, wss_endpoint, port, ssl=ssl)
coro_server = app.run_task(port=server_port)
async def multitask():
# Assign a single task
task1 = loop.create_task(coro_wss)
task2 = loop.create_task(coro_server)
# Run the task asynchronously
await asyncio.wait([task1, task2])
# loop.run_until_complete(coro_wss)
loop.run_until_complete(multitask())
loop.run_forever()
loop.close()
def worker(queue, send_queue, config):
host = config.get('host', DEFAULT_HOST)
port = config.get('port', DEFAULT_PORT)
encoding = config.get('encoding', DEFAULT_ENCODING)
if 0:
# debug asyncio
logging.basicConfig(level=logging.DEBUG)
else:
formatter = logging.Formatter('%(asctime)s %(name)s [%(levelname)s] %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
handler.setLevel(logging.DEBUG)
logger.setLevel(logging.DEBUG)
logger.addHandler(handler)
logger.info("Start main")
import asyncio
factory = WebSocketClientFactory('ws://{}:{}'.format(host, port))
factory.nick = config.get('nick', DEFAULT_NICK)
factory.client = None
factory.protocol = WSChatClientProtocol
factory.queue = queue
factory.encoding = encoding
factory.send_queue = send_queue
def ws_send_worker(queue, factory):
for payload in queue_loop(queue):
if __debug__:
logger.debug("payload-length: {}".format(len(payload)))
if factory.client:
factory.client.sendMessage(payload)
thread = Thread(target=ws_send_worker, args=(send_queue, factory), daemon=True)
thread.start()
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, host, port)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def create_connection(self, room, ws_url, agent, cookies):
"""Creates a new connection"""
urlparts = urlsplit(ws_url)
req = Request("GET", ws_url)
cookies = get_cookie_header(cookies, req)
if cookies:
headers = dict(Cookie=cookies)
else:
headers = None
factory = WebSocketClientFactory(ws_url, headers=headers, loop=self.loop)
factory.useragent = agent
factory.protocol = lambda: room
conn = self.loop.create_connection(
factory,
host=urlparts.netloc,
port=urlparts.port or 443,
ssl=urlparts.scheme == "wss",
)
asyncio.ensure_future(conn, loop=self.loop)
def main():
parser = argparse.ArgumentParser(description='DAO Curator Bot')
parser.add_argument('config', nargs='?', help='Config module',
default='config.development')
args = parser.parse_args()
config_mod = __import__(args.config, globals(), locals(), ['AppConfig'])
appconfig = config_mod.AppConfig
factory = WebSocketClientFactory(appconfig.ETHERSCAN_WEBSOCKET_URL)
factory.protocol = EtherscanClientProtocol
factory.appconfig = appconfig
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, factory.host, factory.port,
ssl=factory.isSecure)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def connect(self):
factory = WebSocketClientFactory(self.endpoint)
factory.protocol = self.protocol
factory.client = self
factory.kwargs = self.kwargs
factory.headers["X-Host-ID"] = self.host_id
factory.headers["X-Client-Type"] = self.type
factory.headers["X-Client-Protocol"] = "json"
if self.persistent:
factory.headers["X-Persistence-Policy"] = "Persistent"
else:
factory.headers["X-Persistence-Policy"] = "DeleteOnDisconnect"
if self.username:
if self.auth.login():
cookie = 'authtok={}'.format(self.auth.authtok)
if self.cookies:
self.cookies.append(cookie)
else:
self.cookies = [cookie, ]
if self.filter:
factory.headers["X-Gremlin-Filter"] = self.filter
if self.cookies:
factory.headers['Cookie'] = ';'.join(self.cookies)
context = None
if self.url.scheme == "wss":
if self.insecure:
context = ssl._create_unverified_context()
else:
context = ssl._create_default_context()
coro = self.loop.create_connection(factory,
self.url.hostname, self.url.port,
ssl=context)
(transport, protocol) = self.loop.run_until_complete(coro)
LOG.debug('transport, protocol: %r, %r', transport, protocol)
def run_client(client_class):
"""
Runs the given client until the client himself calls close or an exception is thrown.
Is non blocking to allow the interaction of the gis and app client.
"""
result = None
try:
pathparts = urllib.parse.urlparse(config.LISTEN_PATH)
adrparts = pathparts.netloc.split(':')
factory = WebSocketClientFactory(config.LISTEN_PATH)
factory.protocol = client_class
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, adrparts[0], adrparts[1])
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
except Exception as ex:
result = ex
return result
def execute(self, symbol):
try:
base_url = 'ws://ff.sinajs.cn/wskt'
token = yield from self.get_token(symbol)
url = base_url + '?' + 'token=' + token + '&' + 'list=' + ','.join(symbol)
logging.debug('start {}'.format(url))
factory = WebSocketClientFactory(url, debug=False)
factory.protocol = create_protocal(self, symbol)
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, self.host, 80)
asyncio.async(coro)
except requests.RequestException:
logging.warning('requests error, don"t worry')
yield from asyncio.sleep(3)
yield from self.execute(symbol)
except NotLoginException:
logging.warning('not login error, try again')
yield from asyncio.sleep(3)
yield from self.execute(symbol)
except:
traceback.print_exc()
logging.warning('unexpected error')
replaced = True
string = new_text
break
if replaced:
tag.string.replace_with(BeautifulSoup(string))
self.text = str(item)
break
if replaced:
self.msg({"action":"set_text", "text":self.text})
else:
self.msg({"action":"set_text", "text": self.text+"<h1>EASY!</h1>"})
self.text = None
def onClose(self, wasClean, code, reason):
loop.stop()
if __name__ == '__main__':
import asyncio
factory = WebSocketClientFactory(u"ws://localhost:9000")
factory.protocol = LuegenpresseCensorClientProtocoll
loop = asyncio.get_event_loop()
connection = loop.create_connection(factory, 'localhost', 9000)
loop.run_until_complete(connection)
loop.run_forever()
loop.close()
def play(self, acc):
self.acc = acc
self.loop = asyncio.get_event_loop()
Coliseum.userid = acc.getID()
time.sleep(random.uniform(1, 2))
self.check = False
self.tried = 0
while not self.check:
if (self.tried < 3):
try:
html = self.acc.get('/main.php',
param={
'p': 'coliseum',
},
referer='/main.php?p=coliseum')
self.check = True
except (requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout):
print('[' + str(datetime.datetime.now().time())[:-3] + '] ' + 'Coli_1_error')
self.tried += 1
time.sleep(random.uniform(1, 2))
pass
else:
print('[' + str(datetime.datetime.now().time())[:-3] + '] ' + 'Bad network. Try again later.')
sys.exit()
time.sleep(random.uniform(1, 2))
# print('lenhtml:', len(html.text))
# print('test')
self.check = False
self.tried = 0
while not self.check:
if (self.tried < 3):
try:
html2 = self.acc.get('http://207.58.158.212:4231/coliseum0/socket.io/1/',
param={
't': str(int(time.time() * 1000)),
},
head={
'Accept': '*/*',
'Origin': 'http://flightrising.com',
},
referer='/main.php?p=coliseum'
)
self.check = True
except (requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout):
print('[' + str(datetime.datetime.now().time())[:-3] + '] ' + 'Coli_2_error')
self.tried += 1
time.sleep(random.uniform(1, 2))
pass
else:
print('[' + str(datetime.datetime.now().time())[:-3] + '] ' + 'Bad network. Try again later.')
sys.exit()
# print('lenhtml2:', len(html2.text))
# print('test2')
if (html2.status_code == requests.codes.ok):
temp = re.search('(.*):60:60:websocket', html2.text)
# print('test3')
self.wskey = temp.group(1)
# print('test4')
self.connection = re.search('(\w+) = io\.connect', html.text).group(1)
# print('test5')
self.thing = re.search('(\w+) = \'JMxc-w-wd2DQ\'', html.text).group(1)
# print('test6')
Coliseum.longthing = re.search(self.connection + "\.emit\(" + self.thing + "\, \'(.*?)\'\)\;", html.text).group(1)
# print('test7')
if self.debuglog:
with open(Coliseum.userid + '.log', 'a') as p:
p.write('\n' + "Beginning WebSocket operations" + '\n')
p.write(self.wskey + '\n')
p.write(self.connection + '\n')
p.write(self.thing + '\n')
p.write(Coliseum.longthing + '\n')
factory = WebSocketClientFactory("ws://207.58.158.212:4231/coliseum0/socket.io/1/websocket/" + self.wskey,
debug=False,
headers=self.headers,
useragent=self.useragent
)
factory.protocol = Coliseum
coro = self.loop.create_connection(factory, '207.58.158.212', 4231)
try:
self.loop.run_until_complete(coro)
self.loop.run_forever()
except KeyboardInterrupt:
if self.debuglog:
with open(Coliseum.userid + '.log', 'a') as p:
p.write("----- {}".format("KeyboardInterrupt") + '\n')
sys.exit()
finally:
self.loop.stop()
# self.loop.close()
return
elif not (html2.status_code == requests.codes.ok):
# print('Not 200.')
print(html2.status_code)
else:
print("Derp.")
def test(self):
factory = WebSocketClientFactory(url='ws://127.0.0.1:29757/websocket')
factory.protocol = self.protocol
coro = self.loop.create_connection(factory, '127.0.0.1', 29757)
self.loop.run_until_complete(coro)
self.loop.run_forever()
print("Request to square {} sent.".format(x))
def onMessage(self, payload, isBinary):
if not isBinary:
res = json.loads(payload.decode('utf8'))
print("Result received: {}".format(res))
self.sendClose()
def onClose(self, wasClean, code, reason):
if reason:
print(reason)
loop.stop()
if __name__ == '__main__':
try:
import asyncio
except ImportError:
# Trollius >= 0.3 was renamed
import trollius as asyncio
factory = WebSocketClientFactory(u"ws://127.0.0.1:9000")
factory.protocol = SlowSquareClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 9000)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
if test.validateResponse(msg):
print("Test passed: {}".format(test.__class__.__name__))
self.tests.pop(index)
if len(self.tests) == 0:
print("Run tests")
sys.exit(0)
else:
self.sendTest()
def sendTest(self):
test = self.tests[-1]
self.sendMessage(test.getPayload())
def onClose(self, wasClean, code, reason):
print("Connection to {url} closed: {error_message}".format(url=self.factory.url, error_message=reason))
if __name__ == '__main__':
import asyncio
factory = WebSocketClientFactory(u"ws://127.0.0.1:9000", useragent="Kommandozentrale TestClient 0.1")
factory.protocol = TestClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 9000)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def onConnect(self, response):
print("Server connected: {0}".format(response.peer))
def onOpen(self):
print("WebSocket connection open.")
def onMessage(self, payload, isBinary):
if isBinary:
print("Binary message received: {0} bytes".format(len(payload)))
else:
result = json.loads(payload.decode('utf8'))
print("Result received: {}".format(result))
message = u"JSON received by Python client at {}".format(strftime("%Y-%m-%d %H:%M:%S"))
self.sendMessage(message.encode('utf8'), isBinary=False)
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == '__main__':
factory = WebSocketClientFactory(u"ws://127.0.0.1:9000")
factory.protocol = EsriJsonClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 9000)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
s = ser.read() # größe anpassen
#print (s);
if s == b'1': # prüfen ob button gedrückt
self.sendMessage(json.dumps({"action":"censor_single"}).encode())
thread = threading.Thread(target=self.turnOnPresse, args=(ser,))
thread.start()
def onClose(self, wasClean, code, reason):
loop.stop()
def onMessage(self, payload, isBinary):
if not isBinary:
res = json.loads(payload.decode())
if res["action"] == b'1': # nachrichten filtern
with serial.Serial(self.port, self.baud) as ser:
ser.write("1\n".encode())
if __name__ == '__main__':
import asyncio
factory = WebSocketClientFactory(u"ws://localhost:9000")
factory.protocol = CensorClientProtocol
loop = asyncio.get_event_loop()
connection = loop.create_connection(factory, 'localhost', 9000)
loop.run_until_complete(connection)
loop.run_forever()
loop.close()
# Save orientation data for future
if data[1]["type"] == "orientation":
accelerometer.append(data[1]["accelerometer"])
gyroscope.append(data[1]["gyroscope"])
orientation.append(data[1]["orientation"])
# Push out any detected poses
elif data[1]["type"] == "pose":
poses.append(data[1]["pose"])
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
def get_factory(loop):
# Create a factory
myo_factory = WebSocketClientFactory("ws://127.0.0.1:10138/myo/1", debug=False)
myo_factory.protocol = MyoProtocol
return loop.create_connection(myo_factory, "127.0.0.1", 10138)
if __name__ == "__main__":
factory = WebSocketClientFactory("ws://127.0.0.1:10138/myo/1", debug=False)
factory.protocol = MyoProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, "127.0.0.1", 10138)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def onMessage(self, payload, isBinary):
if not isBinary:
res = json.loads(payload.decode('utf8'))
if res["result"] == "state":
print("State of {switch}: {state}".format(**res))
elif res["result"] == "config":
print(res)
self.sendClose()
elif res["result"] == "error":
print("An error occured: {0}".format(res["error"]))
else:
print(res)
def onClose(self, wasClean, code, reason):
loop.stop()
if __name__ == '__main__':
import asyncio
factory = WebSocketClientFactory(u"ws://localhost:9000")
factory.protocol = KommandozentraleClientProtocol
loop = asyncio.get_event_loop()
connection = loop.create_connection(factory, 'localhost', 9000)
loop.run_until_complete(connection)
loop.run_forever()
loop.close()
def get_factory(loop):
# Create a factory
myo_factory = WebSocketClientFactory("ws://127.0.0.1:10138/myo/1", debug=False)
myo_factory.protocol = MyoProtocol
return loop.create_connection(myo_factory, "127.0.0.1", 10138)
from autobahn.asyncio.websocket import WebSocketClientProtocol, \
WebSocketClientFactory
import json
import random
class DebugClientProtocol(WebSocketClientProtocol):
def onMessage(self, payload, isBinary):
if not isBinary:
print(payload)
def onClose(self, wasClean, code, reason):
loop.stop()
if __name__ == '__main__':
import asyncio
factory = WebSocketClientFactory(u"ws://localhost:9000")
factory.protocol = DebugClientProtocol
loop = asyncio.get_event_loop()
connection = loop.create_connection(factory, 'localhost', 9000)
loop.run_until_complete(connection)
loop.run_forever()
loop.close()
'url': '/auth/login',
'args': {
'username': '******',
'password': '******',
}
}
self.sendMessage(json.dumps(request).encode('utf8'))
def onMessage(self, payload, isBinary):
message = json.loads(payload.decode('utf8'))
print("Result: {0}".format(message))
if 'request' in message and message['request']['url'] == "/auth/login":
# log out
request = {
'method': 'POST',
'url': '/auth/logout',
'token': message['data']['token']
}
self.sendMessage(json.dumps(request).encode('utf8'))
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:8080", debug=False)
factory.protocol = AuthAPIClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 8080)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
# hello username
request = {
'method': 'GET',
'url': '/hello/'
}
self.sendMessage(json.dumps(request).encode('utf8'))
# sum endpoint with arg in URL path (two random digits)
for _ in range(0, 10):
digit_1 = str(randint(1, 100))
digit_2 = str(randint(1, 100))
request = {
'method': 'GET',
'url': '/sum/{0}/{1}'.format(digit_1, digit_2)
}
self.sendMessage(json.dumps(request).encode('utf8'))
def onMessage(self, payload, isBinary):
print("Result: {0}".format(payload.decode('utf8')))
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:8080")
factory.protocol = HelloClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 8080)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
self.sendMessage(u"Hello, world!".encode("utf8"))
self.sendMessage(b"\x00\x01\x03\x04", isBinary=True)
yield from asyncio.sleep(1)
def onMessage(self, payload, isBinary):
if isBinary:
print("Binary message received: {0} bytes".format(len(payload)))
else:
print("Text message received: {0}".format(payload.decode("utf8")))
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == "__main__":
try:
import asyncio
except ImportError:
## Trollius >= 0.3 was renamed
import trollius as asyncio
factory = WebSocketClientFactory("ws://localhost:9000", debug=False)
factory.protocol = MyClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, "127.0.0.1", 9000)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
def onOpen(self):
# request SO questions
# (use 155-questions-active) for ALL SE sites)
# (also should be able to put '1-questions-active-tag-python*' or similar)
self.sendMessage(b'1-questions-active')
# ^^^ might want to `call_later` this for a few seconds...
def onMessage(self, payload, is_binary):
# not sure if binary should technically happen?
if not is_binary:
event = json.loads(payload.decode('utf-8'))
data = json.loads(event['data'])
# it's a question, so subscribe to its events...
if event['action'] == '1-questions-active':
self.sendMessage('1-question-{}'.format(data['id']).encode('utf-8'))
pprint(data)
def onClose(self, was_clean, code, reason):
print('Closed:', reason)
factory = WebSocketClientFactory('ws://qa.sockets.stackexchange.com')
factory.protocol = StackActivity
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, 'qa.sockets.stackexchange.com', 80)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
