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 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 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 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 __init__(self, url, agent):
self.agent = agent
WebSocketClientFactory.__init__(self, url, useragent=agent)
self.setProtocolOptions(failByDrop=False) # spec conformance
# enable permessage-deflate WebSocket protocol extension
offers = [PerMessageDeflateOffer()]
self.setProtocolOptions(perMessageCompressionOffers=offers)
def accept(response):
if isinstance(response, PerMessageDeflateResponse):
return PerMessageDeflateResponseAccept(response)
self.setProtocolOptions(perMessageCompressionAccept=accept)
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 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 connect(self, url, host, port):
try:
import asyncio
except ImportError:
# Trollius >= 0.3 was renamed
import trollius as asyncio
proto = [ "camctrl-protobuf/1.0" ]
self.loop = asyncio.new_event_loop()
self.factory = WebSocketClientFactory(url, protocols=proto, loop=self.loop)
self.factory.protocol = SocketProtocol
self.factory.setProtocolOptions(autoPingInterval=5, autoPingTimeout=5)
#self.loop = asyncio.get_event_loop()
coro = self.loop.create_connection(self.factory, host, port)
self.loop.run_until_complete(coro)
self.thread = threading.Thread(target=self._poll, name="Poll Camera")
self.thread.daemon = True
self.thread.start()
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 __init__(self, url):
self.agent = autobahn.asyncio.__ident__
WebSocketClientFactory.__init__(self, url, useragent=self.agent)
self.setProtocolOptions(failByDrop=False) # spec conformance
# enable permessage-deflate WebSocket protocol extension
offers = [PerMessageDeflateOffer()]
self.setProtocolOptions(perMessageCompressionOffers=offers)
def accept(response):
if isinstance(response, PerMessageDeflateResponse):
return PerMessageDeflateResponseAccept(response)
self.setProtocolOptions(perMessageCompressionAccept=accept)
# setup client testee stuff
self.endCaseId = None
self.currentCaseId = 0
self.updateReports = True
self.resource = "/getCaseCount"
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 __init__(self, url):
self.agent = autobahn.asyncio.__ident__
WebSocketClientFactory.__init__(self, url, useragent=self.agent)
self.setProtocolOptions(failByDrop=False) # spec conformance
# enable permessage-deflate WebSocket protocol extension
offers = [PerMessageDeflateOffer()]
self.setProtocolOptions(perMessageCompressionOffers=offers)
def accept(response):
if isinstance(response, PerMessageDeflateResponse):
return PerMessageDeflateResponseAccept(response)
self.setProtocolOptions(perMessageCompressionAccept=accept)
# setup client testee stuff
self.endCaseId = None
self.currentCaseId = 0
self.updateReports = True
self.resource = "/getCaseCount"
def connect(self):
url = 'ws://{0}:{1}/datalink'.format(self.address, str(self.port))
log.info(url)
self.factory = WebSocketClientFactory(url, debug=False)
self.factory.protocol = TelemachusProtocol
coro = self.loop.create_connection(self.factory,
self.address,
self.port)
#Notes about events:
#The UI waits on the connect_event to know if the connection has either
#failed or succeeded; the UI will clear this event.
#self.connected differentiates between success and failure
#Success -> self.connected=True ; Failure -> self.connected = False
### MAKING the connection
try:
self.loop.run_until_complete(coro)
#TODO: Add in some informative messages to send back to the UI
except: # Failure, shut down and abort
self.connect_event.set() # Connection resolved
self.connected = False # Connection resolved badly
#Tear down the loop
self.loop.stop()
self.loop.close()
self.loop = None
self.make_connection.clear() # Clear so we can wait for it again
return
else:
self.connect_event.set() # Connection resolved
self.connected = True # Connection resolved well
### MAINTAINING the connection
try:
self.loop.run_forever()
except Exception as e:
log.exception(e)
finally:
#Tear down the loop
self.loop.close()
self.loop = None
self.make_connection.clear() # Clear so we can wait for it again
self.connected = False
#Reset important connection state variables
global MSG_QUEUE
self.subscription_manager = SubscriptionManager(MSG_QUEUE)
self.data_log_vars = OrderedSetWithSubscriptionHook(self.subscription_manager,
['t.universalTime',
'v.missionTime',
'sys.time'])
def testing_main():
import asyncio
import ssl
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=5)
factory.protocol = InvestingdotcomProtocol.make_subids([1, 2])
loop = asyncio.get_event_loop()
# {"cert_reqs": ssl.CERT_NONE})
coro = loop.create_connection(factory, host, 443, ssl=ctx)
loop.run_until_complete(coro)
loop.run_forever()
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 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')
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 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 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')
def run(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
if self.mode == settings.NetworkEngineMode.HOST:
self.factory = WebSocketServerFactory()
self.factory.protocol = ConnectFourServerProtocol
self.coro = self.loop.create_server(self.factory, self.ip, 80)
elif self.mode == settings.NetworkEngineMode.JOIN:
self.factory = WebSocketClientFactory()
self.factory.protocol = ConnectFourClientProtocol
self.coro = self.loop.create_connection(self.factory, self.ip, 80)
self.connection = self.loop.run_until_complete(self.coro)
self.loop.run_forever()
def __init__(self, user, pwd, ip, port, lang, loop):
super().__init__()
self.user = user
self.lang = lang
self.pwd = pwd
self.req_no = 0
self.req_map = dict()
self.closed = True
ws_url = str.format("ws://{0}:{1}/vqservice/vq/socket", ip, str(port))
self.ws_url = ws_url
self.ip = ip
self.port = port
self.factory = WebSocketClientFactory(ws_url)
self.factory.protocol = lambda: self
self.loop = loop
self.push_future = None
self.group_agent_service_list = list(
) # list of tuple (group_gid, agent_service) //all the group that is arleady joined
self.recommand_groups = list() #
self.state_vars = dict() # {group:{agent_servic:{var_name:var_value}}}
self.node_caches = dict() # gid->(date, nodeInfo)
self.joined_group_and_agent_service = list()
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 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
factory.headers["X-Gremlin-Filter"] = self.filter
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 listen_for_events(callback):
try:
while True:
print("Attempting to open websocket connection")
factory = WebSocketClientFactory(u"wss://certstream.calidog.io")
factory.setProtocolOptions(openHandshakeTimeout=10,
tcpNoDelay=True)
factory.protocol = MyClientProtocol
factory.callback = callback
ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
ssl_context.check_hostname = True
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory,
'certstream.calidog.io',
443,
ssl=ssl_context)
loop.run_until_complete(coro)
loop.run_forever()
except KeyboardInterrupt:
loop.stop()
loop.close()
text=str(random.randint(36, 38)))
if randNum2 == 1:
self.heartrate1.configure(text=str(random.randint(60, 63)))
except Exception as e:
print e
self.window.update()
if __name__ == '__main__':
root = logging.getLogger()
root.setLevel(logging.DEBUG)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.DEBUG)
root.addHandler(ch)
factory = WebSocketClientFactory(u"ws://127.0.0.1:8888/get")
proto = MyClientProtocol
factory.protocol = proto
factory.setProtocolOptions(autoPingInterval=10,
autoPingTimeout=60,
openHandshakeTimeout=30)
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '127.0.0.1', 8888)
loop.run_until_complete(coro)
loop.run_forever()
def hello():
self.sendMessage(u"Hello, world!".encode('utf8'))
self.sendMessage(b"\x00\x01\x03\x04", isBinary=True)
self.factory.loop.call_later(1, hello)
## start sending messages every second ..
hello()
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__':
import 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()
#s.send(password + b'\r\n')
#answer = s.recv(1024)
#self.sendMessage(answer,1)
#s.close()
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
async def heartbeat(self):
while True:
await asyncio.sleep(29)
msg = u"--- MARK ---"
self.sendMessage(msg.encode('utf-8'))
if __name__ == '__main__':
factory = WebSocketClientFactory(u"ws://192.168.165.20:80")
factory.protocol = MyClientProtocol
loop = asyncio.get_event_loop()
coro = loop.create_connection(factory, '192.168.165.20', 80)
loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyBoardInterrupt:
pass
finally:
loop.close()
def connect(self):
""" Create websocket factory by Autobahn
"""
self.factory = WebSocketClientFactory(self.url)
self.factory.protocol = self.proto
import logging
from os import environ
from autobahn.asyncio.websocket import WebSocketClientFactory
from loxone_websocket_client import ClientProtocol
_LOGGER = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
MINISERVER_HOST = environ.get('MINISERVER_HOST', '127.0.0.1')
MINISERVER_PORT = environ.get('MINISERVER_PORT', 80)
MINISERVER_USERNAME = environ.get('MINISERVER_USERNAME', 'admin')
MINISERVER_PASSWORD = environ.get('MINISERVER_PASSWORD', 'admin')
if __name__ == '__main__':
_LOGGER.info('Start WebSocket connection')
ws_factory = WebSocketClientFactory('ws://{host}:{port}/ws/rfc6455'.format(
host=MINISERVER_HOST, port=MINISERVER_PORT),
protocols=['remotecontrol'])
ws_factory.protocol = ClientProtocol
ws_factory.username = MINISERVER_USERNAME
ws_factory.password = MINISERVER_PASSWORD
loop = asyncio.get_event_loop()
coro = loop.create_connection(ws_factory, MINISERVER_HOST, MINISERVER_PORT)
loop.run_until_complete(coro)
loop.run_forever()
loop.close()
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()
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)
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()
parser = argparse.ArgumentParser()
parser.add_argument('--host',
dest='host',
default='127.0.0.1',
help="ip of the API (default: 127.0.0.1)")
parser.add_argument('--port',
dest='port',
default=8080,
help="port of the API (default: 8080)")
parser.add_argument('--clients',
dest='clients',
default=100,
type=int,
help="number of clients to add each cycle")
parser.add_argument('--duration',
dest='duration',
default=10,
type=int,
help="duration of each cycle")
args = parser.parse_args()
loop = asyncio.get_event_loop()
factory = WebSocketClientFactory()
factory.protocol = APIClientProtocol
async def connect():
print("Connecting...")
await loop.create_connection(factory, args.host, args.port)
loop.run_until_complete(run(connect, args.clients, args.duration))
'url': '/auth/login',
'data': {
'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")
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()
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 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)
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()
async def onOpen(self):
print("WebSocket connection open.")
# start sending messages every second ..
while True:
self.sendMessage("Hello, world!".encode('utf8'))
self.sendMessage(b"\x00\x01\x03\x04", isBinary=True)
await 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__':
factory = WebSocketClientFactory("ws://127.0.0.1:9000")
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()
payload = json.dumps({
"pid": object['pid'],
"card": card,
"usr": object["usr"],
"t": object["t"]
}).encode('utf8')
self.sendMessage(payload)
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {0}".format(reason))
if __name__ == '__main__':
print(sys.argv)
if len(sys.argv) == 2:
factory = WebSocketClientFactory(sys.argv[1])
else:
print(
'pass the url like "ws://127.0.0.1:6789/key=bot1&Room=0&seatN0=2" it should pass in qute'
)
quit()
factory = WebSocketClientFactory("ws://127.0.0.1:6789/key=" +
sys.argv[1] + "&Room=0")
factory.protocol = MyClientProtocol
loop = asyncio.get_event_loop()
async def main():
coro = loop.create_connection(factory, "3.128.89.158", 6789)
print("running {}".format(coro))
transport, proto = await coro
print("proto {}".format(proto))
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()
# 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()
@asyncio.coroutine
def onOpen(self):
print("WebSocket connection open.")
# start sending messages every second ..
while True:
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__':
factory = WebSocketClientFactory(u"ws://127.0.0.1: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()
class TestClientProtocol(WebSocketClientProtocol):
def onOpen(self):
self.sendMessage(
json.dumps({
"action": "get_votes",
"event_name": "jhsued2016"
}).encode())
#self.sendClose()
def onMessage(self, payload, inBinary):
print(payload)
def onClose(self, wasClean, code, reason):
loop.stop()
if __name__ == '__main__':
import asyncio
factory = WebSocketClientFactory(u"ws://localhost:9000")
factory.protocol = TestClientProtocol
loop = asyncio.get_event_loop()
connection = loop.create_connection(factory, 'localhost', 9000)
loop.run_until_complete(connection)
loop.run_forever()
loop.close()
def connect(self):
self.factory = WebSocketClientFactory("ws://{}:{:d}".format(
self.host, self.port),
debug=False)
self.factory.protocol = self.proto
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()
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()
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()
'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()
def __init__(self, url, callbacks, debug=False, debugCodePaths=False):
WebSocketClientFactory.__init__(self, url, debug=debug, debugCodePaths=debugCodePaths)
self.__clients = []
self.__callbacks = callbacks
message = await async_input('SL >>> ', self)
print(message)
if message == b'messages':
for response in self.responses:
print(response[0].isoformat, response[1])
continue
elif message:
self.sendMessage(message, isBinary=True)
def onMessage(self, payload, isBinary):
print(self.responses)
self.responses.append((datetime.datetime.now(), payload))
def onClose(self, wasClean, code, reason):
print("WebSocket connection closed: {}; {}".format(code, reason))
if __name__ == '__main__':
factory = WebSocketClientFactory('handlers://127.0.0.1:8080/push')
factory.protocol = MyClientProtocol
coro = loop.create_connection(factory, '127.0.0.1', 8080)
loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
loop.shutdown_asyncgens()
loop.close()
print('Bye')
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)
# 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()
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()
if isBinary:
print("onMessage: Binary payload message", payload)
else:
print("onMessage: Text payload message", payload.decode('utf8'))
print()
def onClose(self, wasClean, code, reason):
print("onClose - WebSocket connection closed:", reason)
print()
# Running Client
if __name__ == '__main__':
factory = WebSocketClientFactory("ws://localhost:8765")
factory.protocol = MyClientProtocol
loop = asyncio.get_event_loop()
cliente = loop.create_connection(factory, 'localhost', 8765)
loop.run_until_complete(cliente)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
finally:
print()
print('closind cliente ....')
print()
cliente.close()
