def echo(server, ha_ip, pwd, idx, loc_name):
websocket = yield from asyncws.connect(
'ws://%s:8123/api/websocket?api_password=%s' % (ha_ip, pwd))
objects = server.get_objects_node()
yield from websocket.send(
json.dumps({
'id': 1,
'type': 'subscribe_events',
'event_type': 'state_changed'
}))
while True:
message = yield from websocket.recv()
if message is None:
break
msgobj = json.loads(message)
if (msgobj['type'] == 'event'):
entity_id = msgobj['event']['data']['entity_id']
new_state = msgobj['event']['data']['new_state']['state']
old_state = msgobj['event']['data']['old_state']['state']
if new_state != old_state:
print(entity_id + ": " + old_state + " -> " + new_state)
var_node = objects.get_child([
"%d:%s" % (idx, loc_name),
"%d:%s" % (idx, entity_id),
"%d:state" % idx
])
var_node.set_value(new_state)
def echo():
websocket = yield from asyncws.connect('ws://localhost:8000')
while True:
yield from websocket.send('hello')
echo = yield from websocket.recv()
if echo is None:
break
print(echo)
def echo():
""" Connect to Home Assistant Websocket and save all messages """
websocket = yield from asyncws.connect(settings.HOME_ASSISTANT_WS_URL)
yield from websocket.send(
json.dumps({
'id': 1,
'type': 'subscribe_events',
'event_type': 'state_changed'
}))
while True:
message = yield from websocket.recv()
if message is None:
break
message = json.loads(message)
df = json_normalize(message)
if df.type[0] == 'event':
for _, row in df.iterrows():
entity_id = row['event.data.entity_id']
domain_name, _ = entity_id.split(".")
domain, created = Domain.objects.get_or_create(
name=domain_name)
friendly_name = ''
if hasattr(row,
'event.data.new_state.attributes.friendly_name '):
friendly_name = row[
'event.data.new_state.attributes.friendly_name']
entity, _ = Entity.objects.update_or_create(
entity_id=entity_id,
domain=domain,
defaults={
'friendly_name': friendly_name,
})
Attribute.objects.filter(entity=entity).update(
is_current=False)
for index, value in df.iteritems():
new_state = False
old_state = False
is_current = False
title = ''
if 'new_state' in index:
new_state = True
is_current = True
title = index.split('new_state.')[1]
elif 'old_state' in index:
old_state = True
title = index.split('old_state.')[1]
elif 'event' in index:
title = index.split('event.')[1]
Attribute.objects.create(
entity=entity,
title=title,
status=str(value[0]),
is_current=is_current,
is_old_state=old_state,
is_new_state=new_state,
)
def echo():
ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
ssl_context.check_hostname = False
ssl_context.load_verify_locations('example.crt')
websocket = yield from asyncws.connect('wss://localhost:8000', ssl = ssl_context)
while True:
yield from websocket.send('hello')
echo = yield from websocket.recv()
if echo is None:
break
print (echo)
def test_server(self):
global server, serverthread, wsocket
loop = asyncio.get_event_loop()
websocket = loop.run_until_complete(asyncws.connect(self.url))
loop.run_until_complete(self.non_ssl_server(websocket))
# Send stop signal to server
wsocket.send(b"stop")
serverthread.join()
serverthread = None
server = None
def echo():
ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
ssl_context.check_hostname = False
ssl_context.load_verify_locations('example.crt')
websocket = yield from asyncws.connect('wss://localhost:8000',
ssl=ssl_context)
while True:
yield from websocket.send('hello')
echo = yield from websocket.recv()
if echo is None:
break
print(echo)
def __init__(self):
self._authenticated = False
self._connection = None
self._iden = 0
self._subs = {}
self._loop = asyncio.get_event_loop()
self._connection = self._loop.run_until_complete(
asyncws.connect('ws://localhost:8123/api/websocket'))
try:
self._loop.run_until_complete(self.auth_phase())
except Exception as e:
_LOGGER.error(e)
self._loop.run_until_complete(self._connection.close())
def echo():
websocket = yield from asyncws.connect(
'ws://172.16.230.225:8123/api/websocket')
yield from websocket.send(
json.dumps({
"type": "auth",
"api_password": "******"
}))
yield from websocket.send(
json.dumps({
'id': 1,
'type': 'subscribe_events',
}))
while True:
message = yield from websocket.recv()
if message is None:
break
# print(message)
parse_state_json(message)
def chat_send(websocket):
reader = yield from stdin()
print("Welcome, type some text!")
while True:
msg = yield from reader.readline()
yield from websocket.send(
msg.decode('utf-8').strip('\r\n'), True)
@asyncio.coroutine
def chat(websocket):
send_task = asyncio.Task(chat_send(websocket))
recv_task = asyncio.Task(chat_recv(websocket, send_task))
return [recv_task, send_task]
loop = asyncio.get_event_loop()
websocket = loop.run_until_complete(
asyncws.connect('ws://localhost:8000'))
try:
chat_tasks = loop.run_until_complete(chat(websocket))
loop.run_until_complete(asyncio.wait(chat_tasks))
except KeyboardInterrupt as e:
loop.run_until_complete(websocket.close())
loop.run_until_complete(websocket.wait_closed())
for task in chat_tasks:
task.cancel()
loop.run_until_complete(asyncio.wait(chat_tasks))
finally:
loop.close()
try:
print ('连接转发服务器')
while True:
messageFromServer = yield from websocketFromServer.recv()
if messageFromServer is None:
raise Exception;
if messageFromServer == '':
continue
messageFromServerObj = json.loads(messageFromServer)
if messageFromServerObj is not None and messageFromServerObj['code'] == 0:
if websocket is not None:
print("Rev Command:" + messageFromServer)
yield from websocket.send(json.dumps(messageFromServerObj['command']))
except Exception as inst:
print(inst)
raise Exception
while True:
try:
loop = asyncio.get_event_loop()
websocket = loop.run_until_complete(asyncws.connect(wslocalAdd))
websocketFromServer = loop.run_until_complete(asyncws.connect(wsServerAdd))
tasks = [asyncio.Task(wslocal(websocket,websocketFromServer)), asyncio.Task(wsServer(websocket,websocketFromServer))]
loop.run_until_complete(asyncio.gather(*tasks))
except Exception as inst:
print('开始重连')
sleep(5)
import asyncio
import asyncws
@asyncio.coroutine
def echo(websocket):
while True:
yield from websocket.send('hello')
msg = yield from websocket.recv()
if msg is None:
break
print(msg)
loop = asyncio.get_event_loop()
websocket = loop.run_until_complete(asyncws.connect('ws://localhost:8000'))
try:
loop.run_until_complete(echo(websocket))
except KeyboardInterrupt as e:
loop.run_until_complete(websocket.close())
loop.run_until_complete(websocket.wait_closed())
finally:
loop.close()
def chat():
websocket = yield from asyncws.connect('ws://localhost:8000')
tasks = [chat_recv(websocket), chat_send(websocket)]
yield from asyncio.wait(tasks)
def chat():
websocket = yield from asyncws.connect('ws://localhost:8000')
tasks = [chat_recv(websocket), chat_send(websocket)]
yield from asyncio.wait(tasks)
import asyncio
import asyncws
import ssl
@asyncio.coroutine
def echo(websocket):
while True:
yield from websocket.send('hello')
echo = yield from websocket.recv()
if echo is None:
break
print(echo)
ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
ssl_context.load_verify_locations('example.crt')
loop = asyncio.get_event_loop()
websocket = loop.run_until_complete(
asyncws.connect('wss://localhost:8000', ssl=ssl_context))
try:
loop.run_until_complete(echo(websocket))
except KeyboardInterrupt as e:
loop.run_until_complete(websocket.close())
loop.run_until_complete(websocket.wait_closed())
finally:
loop.close()
