A lot of threading progress

This commit is contained in:
dandaedre 2021-09-30 17:05:23 +02:00
parent 7777a02d97
commit 5a8d327586
1 changed files with 174 additions and 102 deletions

View File

@ -4,9 +4,9 @@
# IMPORTS # IMPORTS
# import socketserver # import socketserver
import socket, threading import socket, threading
import sys import sys,time
import re import re
from _thread import start_new_thread
################################ ################################
# CONFIG VARIABLES # CONFIG VARIABLES
_IPSELF = "192.168.0.140" # Could be usefull for multi IP networks _IPSELF = "192.168.0.140" # Could be usefull for multi IP networks
@ -15,12 +15,46 @@ _HOSTS = [("192.168.0.140",10500)]
_VERBOSE=True _VERBOSE=True
_MSGSIZE=4096 _MSGSIZE=4096
_TIMEOUT=0.5
_MSG_ENDING=b"\r\n"
################################
# BIG DEFINES
_NO_FUNCT=lambda x:None
_SYS_EXIT=lambda x:sys.exit()
if _VERBOSE: if _VERBOSE:
def dprint(*args): def dprint(*args):
print(*args) print(*args)
def spec_print(spec,*args):
dprint("[pAW:{}]".format(spec),*args) #(line@{}) ,sys._getframe().f_lineno
def iprint(*args):
spec_print("INFO",*args)
def wprint(*args):
spec_print("WARNING",*args)
def eprint(*args):
spec_print("ERROR",*args)
else: else:
dprint=lambda x:None dprint=_NO_FUNCT
wprint=_NO_FUNCT
eprint=_NO_FUNCT
iprint=_NO_FUNCT
class pyNope(object):
def __init__(self):
pass
def __call__(self,*args,**kwargs):
return self
def __repr__(self,*args,**kwargs):
return ''
def __getattr__(self,*args,**kwargs):
return self
################################ ################################
# VARIABLES # VARIABLES
@ -86,6 +120,20 @@ _WAIT_DEVICE =re.compile('DEV(?P<device>\d*)')
_WAIT_VERSION=re.compile('VEvar(?P<version>\d*)') _WAIT_VERSION=re.compile('VEvar(?P<version>\d*)')
_WAIT_STATUS=re.compile('#(?P<status>\d*)') _WAIT_STATUS=re.compile('#(?P<status>\d*)')
_WAIT_KPALIVE=re.compile('SYpig(?P<ping>\d*)') _WAIT_KPALIVE=re.compile('SYpig(?P<ping>\d*)')
# PROGRESS "PSprg99"
# GCfrl ?
# GCply
_MESSAGE_REGEX=re.compile("(?P<preargs>(\d)*(,\d)*)(?P<msg>\D*)(?P<postargs>(\d)*(,\d)*)")
_MATCHS={
"*":"CONNECT",
"DEV":"DEVICE",
"VEvar":"VERSION",
"#":"STATUS",
"SYpig":"KPALIVE",
"n":""
}
################################ ################################
# CLASS DEFINITIONS # CLASS DEFINITIONS
@ -93,15 +141,27 @@ _WAIT_KPALIVE=re.compile('SYpig(?P<ping>\d*)')
class analogController(object): class analogController(object):
"AnalogWay Controller, controls one AnalogWay device" "AnalogWay Controller, controls one AnalogWay device"
def __init__(self,ip,port): def __init__(self,ip,port,feedbackInterface=pyNope()):
self.sck=None self.sck=None
self.ip=ip self.ip=ip
self.port=port self.port=port
self.running=True
self.listening=False
# Last received match messages
self.messages={i:None for i in ["CONNECT","DEVICE","VERSION","STATUS","KPALIVE","REGEX"]}
#
self.feedback=feedbackInterface # Feedback interface gui or midiRebind
self._LOCKS={i:threading.Lock() for i in [
"CONNECT","DEVICE","VERSION","STATUS","KPALIVE","changeLayer",
"takeAvailable","take","takeAll","loadMM","quickFrame","quickFrameAll"
]}
try: try:
dprint('[pAW:INFO] Creating socket') iprint('Creating socket')
self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
dprint('[pAW:INFO] Getting remote IP address') iprint('Getting remote IP address')
host=_IPSELF host=_IPSELF
remote_ip = socket.gethostbyname( host ) remote_ip = socket.gethostbyname( host )
@ -112,25 +172,71 @@ class analogController(object):
print('[pAW:ERROR] Hostname could not be resolved. Exiting') print('[pAW:ERROR] Hostname could not be resolved. Exiting')
sys.exit() sys.exit()
################################
# MESSAGE RECEIVE
# def receive_CONNECT(self,match):
# "We received a connect message"
# self.messages["CONNECT"]=match
# self._LOCKS["connect"].release()
# self.feedback.messageReceived("CONNECT",match)
def receive_GENERIC(self,match):
"We received a connect message, all the logic will be on the feedback side"
# self.messages["CONNECT"]=match
# self._LOCKS["connect"].release()
# self.feedback.messageReceived("CONNECT",match)
typ=_MATCHS[match.group("msg")]
self.messages[typ]=match #why not, not very clever tho
self._LOCKS[typ].release()
self.feedback.messageReceived("typ",match)
##############################################
# LOCKS
def waitLock(self,lockname,function_success=_NO_FUNCT,args_succes=(),function_error=_NO_FUNCT,args_error=()):
"""Wait for the lock <lockname> to be released, non blocking"""
thd=threading.Thread(target=self._initLockWait,args=(lockname,function_success,args_succes,function_error,args_error))
thd.start()
return thd
def _initLockWait(self,lockname,function_success=_NO_FUNCT,args_succes=(),function_error=_NO_FUNCT,args_error=()):
"""Thread waiting for a lock"""
print(function_success,args_succes,function_error,args_error)
iprint("Checking for [{}] lock avaivability".format(lockname))
if not self._LOCKS[lockname].locked(): #The state it's supposed to be in, but let's not be too sure
self._LOCKS[lockname].acquire(timeout=0.01)
# Now wait for the lock to be released
iprint("Acquired [{}] : Locking".format(lockname))
status=self._LOCKS[lockname].acquire(timeout=_TIMEOUT)
if status:
iprint("Lock [{}] passed succesfully".format(lockname))
function_success(args_success)
else:
iprint("Failed to aquire [{}]".format(lockname))
function_error(args_error)
return status
################################
# MESSAGES SUBROUTINS
def connect(self): def connect(self):
"""The device acts as a server. Once the TCP connection is established, the controller shall """The device acts as a server. Once the TCP connection is established, the controller shall
check that the device is ready, by reading the READY status, until it returns the value 1. check that the device is ready, by reading the READY status, until it returns the value 1.
[*] (* <value>) The controller shall wait and retry until it receives the value 1 [*] (* <value>) The controller shall wait and retry until it receives the value 1
""" """
dprint('[pAW:INFO] Connecting to server, {self.ip}:{self.port}'.format(self=self)) iprint('Connecting to server, {self.ip}:{self.port}'.format(self=self))
self.sck.connect((self.ip,self.port)) self.sck.connect((self.ip,self.port))
dprint('[pAW:INFO] Sending data to server')
wait=self.waitLock("CONNECT",function_error=_SYS_EXIT)
self.sendData("*\r\n") self.sendData("*\r\n")
ret=self.waitfor(_WAIT_CONNECT) iprint("Waiting for",wait)
print(ret) wait.join()
iprint("Finished wait for",wait)
def getDevice(self): def getDevice(self):
"""This read only command gives the device type """This read only command gives the device type
[?] (DEV <value>) <values>:_DEVICES_VALUES [?] (DEV <value>) <values>:_DEVICES_VALUES
""" """
self.sendData("?") self.sendData("?")
ret=self.waitfor(_WAIT_DEVICE,"device")
print(ret)
def getVersion(self): def getVersion(self):
"""his read only command gives the version number of the command set. """his read only command gives the version number of the command set.
@ -138,8 +244,6 @@ class analogController(object):
[VEvar] (VEvar<version>) [VEvar] (VEvar<version>)
""" """
self.sendData("VEvar") self.sendData("VEvar")
ret=self.waitfor(_WAIT_VERSION,"version")
print(ret)
def getStatus(self,value=3): def getStatus(self,value=3):
"""Reading a change of values """Reading a change of values
@ -147,16 +251,12 @@ class analogController(object):
<value>:1 All register values 3: Only non default values <value>:1 All register values 3: Only non default values
""" """
self.sendData('#{}'.format(value)) self.sendData('#{}'.format(value))
ret=self.waitfor(_WAIT_STATUS)
print(ret)
def _keepAlive(self,val=1): def _keepAlive(self,val=1):
"""Send a keepalive to check (and ensure) the connection is still up """Send a keepalive to check (and ensure) the connection is still up
[<val1>SYpig] Will return the invert of the value sent: 0x0000 0000 will return 0xFFFF FFFF [<val1>SYpig] Will return the invert of the value sent: 0x0000 0000 will return 0xFFFF FFFF
""" """
self.sendData("{}SYpig".format(val)) self.sendData("{}SYpig".format(val))
ret=self.waitfor(_WAIT_KPALIVE)
print(ret)
def changeLayer(self,screen,ProgPrev,layer,src): def changeLayer(self,screen,ProgPrev,layer,src):
"""Change the layer of selected """Change the layer of selected
@ -199,7 +299,6 @@ class analogController(object):
(GCtak<scrn>,1) : Take is available (GCtak<scrn>,1) : Take is available
(GCtak<scrn>,1) : Take is available (GCtak<scrn>,1) : Take is available
""" """
pass pass
def loadMM(screenF,memory,screenT,ProgPrev,filter): def loadMM(screenF,memory,screenT,ProgPrev,filter):
@ -231,31 +330,62 @@ class analogController(object):
def connectionSequence(self): def connectionSequence(self):
"Execute the full connection sequence" "Execute the full connection sequence"
self.start_listening()
self.connect() self.connect()
self.getDevice() # self.getDevice()
self.getVersion() # self.getVersion()
self.getStatus() # self.getStatus()
def waitfor(self,value,*matchgroups):
"""Wait for a specific return value, blocking"""
notfound=True
returndict={} #########################################
while notfound: # SOCKET METHODS
def start_listening(self):
"""Start the loop listener"""
if self.listening:
return
start_new_thread(self.socketLoop,())
def cleanReceive(self):
"Yield only clean messages"
self.running=True
reply_bytes=b""
while self.running:
try: try:
reply=self.sck.recv(_MSGSIZE) reply_bytes+=self.sck.recv(_MSGSIZE)
dprint ("[pAW:INFO] Received:",reply) if reply_bytes.find(_MSG_ENDING)==-1: # Message is not finished
RX_MTCH=value.match(reply.decode()) continue
for grp in matchgroups: else:
returndict[grp]=RX_MTCH.group(grp) reply,reply_bytes=reply_bytes.rsplit(_MSG_ENDING,1)
reply=(reply+_MSG_ENDING).decode().split("\r\n")
for r in reply[:-1]: # iprint("Yielding:",r)
yield r
except AttributeError as e:
dprint(e)
def socketLoop(self):
"""Loop on the socket and create an event for every message received"""
self.listening=True
for message in self.cleanReceive():
try:
iprint ("Received:",message)
RX_MTCH=_MESSAGE_REGEX.match(message)
iprint("preargs:{} - msg:{} - postargs:{}".format(RX_MTCH.group("preargs"),RX_MTCH.group("msg"),RX_MTCH.group("postargs")))
start_new_thread(self.processMatch,(RX_MTCH,))
except AttributeError as e: except AttributeError as e:
dprint("[pAW:ERROR] Regex couldn't find a match") dprint("[pAW:ERROR] Regex couldn't find a match")
dprint(e) dprint(e)
except Exception as e:
print(e)
return returndict def processMatch(self,match):
# except: """Process a match with a message, should only be called by the socketLoop funciton"""
# pass try:
name=_MATCHS[match.group("msg")]
# self.__getattr__("connect_{}".format(name),"GENERIC")(match)
except KeyError as e:
dprint("[pAW:ERROR] Can't find matched key:",match)
print(e)
def sendData(self,data): def sendData(self,data):
"Send data through the socket" "Send data through the socket"
@ -265,73 +395,15 @@ class analogController(object):
print ('[pAW:ERROR] Send failed of data :',data) print ('[pAW:ERROR] Send failed of data :',data)
sys.exit() sys.exit()
def limbowait(self):
"Testing state, only usefull when not on a remote gui/midiRebind"
while True:
time.sleep(10)
##################### #####################
# TESTING # TESTING
if __name__ == '__main__': if __name__ == '__main__':
ctrl1=analogController(*_HOSTS[0]) ctrl1=analogController(*_HOSTS[0])
ctrl1.connectionSequence() ctrl1.connectionSequence()
ctrl1.limbowait()
ctrl1.waitfor("")
# except ConnectionRefusedError:
# # Receive data
# print('# Receive data from server')
# while True:
# reply = s.recv(4096)
#
# print (reply)
# # thread function
# def threaded(c):
# while True:
#
# # data received from client
# data = c.recv(1024)
# if not data:
# print('Bye')
#
# # lock released on exit
# print_lock.release()
# break
#
# # reverse the given string from client
# data = data[::-1]
#
# # send back reversed string to client
# c.send(data)
#
# # connection closed
# c.close()
#
#
# def Main():
# host = ""
#
# # reverse a port on your computer
# # in our case it is 12345 but it
# # can be anything
# port = 12345
# s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# s.bind((host, port))
# print("socket binded to port", port)
#
# # put the socket into listening mode
# s.listen(5)
# print("socket is listening")
#
# # a forever loop until client wants to exit
# while True:
#
# # establish connection with client
# c, addr = s.accept()
#
# # lock acquired by client
# print_lock.acquire()
# print('Connected to :', addr[0], ':', addr[1])
#
# # Start a new thread and return its identifier
# start_new_thread(threaded, (c,))
# s.close()
#
#
# if __name__ == '__main__':
# Main()