157 lines
4.0 KiB
Python
157 lines
4.0 KiB
Python
import socket
|
|
import threading
|
|
import logging
|
|
import queue
|
|
import contextlib
|
|
import time
|
|
|
|
DEFAULT_TIMEOUT = 0.5
|
|
|
|
|
|
class TimeoutException(Exception):
|
|
pass
|
|
|
|
|
|
class VortexConnection(object):
|
|
def __init__(self, ip, port):
|
|
self.logger = logging.getLogger(self.__class__.__name__)
|
|
self.handlers = [self.on_message]
|
|
|
|
self.queues = []
|
|
|
|
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
self.socket.connect((ip, port))
|
|
self.fd = self.socket.makefile("rw")
|
|
|
|
def loop_start(self):
|
|
self.th = threading.Thread(target=self.loop)
|
|
self.th.daemon = True
|
|
self.th.start()
|
|
|
|
def loop(self):
|
|
print("Looping...")
|
|
|
|
for line in self.readlines():
|
|
for h in self.handlers:
|
|
h(line.strip())
|
|
|
|
def send(self, cmd):
|
|
self.logger.debug(">> %r", cmd)
|
|
self.fd.write(cmd + "\r")
|
|
self.fd.flush()
|
|
|
|
def readlines(self):
|
|
buf = b""
|
|
data = True
|
|
|
|
while data:
|
|
try:
|
|
data = self.socket.recv(512)
|
|
except KeyboardInterrupt:
|
|
raise
|
|
except:
|
|
time.sleep(0.1)
|
|
self.logger.warning("Recv failed")
|
|
continue
|
|
|
|
if not data:
|
|
raise Exception("Connection closed")
|
|
|
|
buf += data
|
|
|
|
while buf.find(b"\r") != -1:
|
|
line, buf = buf.split(b"\r", 1)
|
|
yield line
|
|
|
|
def on_message(self, msg):
|
|
self.logger.debug("<< %r", msg)
|
|
for q in self.queues:
|
|
q.put_nowait(msg)
|
|
|
|
@contextlib.contextmanager
|
|
def client(self):
|
|
q = queue.Queue()
|
|
self.queues.append(q)
|
|
self.logger.debug("Adding queue...")
|
|
try:
|
|
yield q
|
|
finally:
|
|
self.logger.debug("Removing queue...")
|
|
self.queues.remove(q)
|
|
|
|
def call(self, cmd, timeout=DEFAULT_TIMEOUT, wait=True):
|
|
with self.client() as q:
|
|
self.send(cmd)
|
|
if not wait:
|
|
return
|
|
|
|
start = time.time()
|
|
while time.time() - start < timeout:
|
|
try:
|
|
m = q.get(timeout=timeout - (time.time() - start))
|
|
except queue.Empty:
|
|
self.logger.debug("Request timeout")
|
|
return
|
|
|
|
yield m
|
|
|
|
def discover(self, timeout=DEFAULT_TIMEOUT):
|
|
return {
|
|
resp[:3].decode(): VortexDevice(self, resp[:3].decode())
|
|
for resp in self.call("***PING", timeout=timeout)
|
|
if resp[3:].decode() == "PONG"
|
|
}
|
|
|
|
def __getitem__(self, key):
|
|
return VortexDevice(self, key)
|
|
|
|
|
|
class VortexDevice(object):
|
|
def __init__(self, connection, device_id):
|
|
self.conn = connection
|
|
self.device_id = device_id
|
|
self.logger = logging.getLogger("vortex.%s" % (self.device_id,))
|
|
|
|
def __repr__(self):
|
|
return "<VortexDevice {}>".format(self.device_id)
|
|
|
|
def mute(self):
|
|
self.call_single("GMUTEO1")
|
|
|
|
def unmute(self):
|
|
self.call_single("GMUTEO0")
|
|
|
|
def call_single(self, *args, **kwargs):
|
|
return next(self.call(*args, **kwargs), None)
|
|
|
|
def call(self, cmd, expect=None, *args, **kwargs):
|
|
if expect is None:
|
|
expect = cmd.replace("?", "")
|
|
|
|
for resp in self.conn.call(self.device_id + cmd, *args, **kwargs):
|
|
self.logger.debug("Received: %r (%r)", resp, self.device_id)
|
|
if resp[: len(self.device_id)] != self.device_id.encode():
|
|
continue
|
|
|
|
resp = resp[len(self.device_id) :]
|
|
|
|
if expect is None or resp[: len(expect)] == expect.encode():
|
|
yield resp
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import logging
|
|
|
|
logging.basicConfig(level=logging.DEBUG)
|
|
|
|
c = VortexConnection("127.0.0.1", 10001)
|
|
c.loop_start()
|
|
d = c.discover()
|
|
print(d)
|
|
|
|
d["F00"].call_single("PING", "PONG")
|
|
|
|
# for n in range(1000):
|
|
# c['T00'].call_single('SSTEXT0,1,XD {}'.format(n), expect=False, timeout=0)
|
|
# time.sleep(0.1)
|