WebSVN – HomeAutomation – Diff – /branches/modules/PcSoftware/pyCanDaemon/TCPServer1.py


###########################################################
#
# Implements the TCP server interface to administrative
# or monitoring apps
#
###########################################################
 
from TCPServerBase import TCPServerBase
 
from threading import Thread
from threading import Lock
import logging as log
import time
from TCPServer import TCPServer
 
class TCPServer1Thread(Thread):
    ownerNotifier = None
    terminated = False
    serverListener = None
    tcpServer = None
    port = None
 
    def __init__ (self, ownerNotifier, serverListener, port):
        Thread.__init__(self)
        self.ownerNotifier = ownerNotifier
        self.serverListener = serverListener
        self.port = port
       
    def cleanup(self):
        if self.tcpServer.running():
            self.tcpServer.stop()
        self.ownerNotifier.notify(self.ownerNotifier.TERMINATE)
 
    def run(self):
        try:
            log.debug('TCPServer1Thread.run')
            self.tcpServer = TCPServer(self.port, self.ownerNotifier)
            self.tcpServer.start()
 
            while not self.terminated:
                while not self.serverListener.empty():
                    data = self.serverListener.read() + '\n'
                    self.tcpServer.writeAll(data)
                time.sleep(0.01)
            self.cleanup()
        except: # sys.excepthook does not work in threads
            import traceback
            traceback.print_exc()
            self.terminated = True
            self.cleanup()
   
    def terminate(self):
        log.debug('TCPServer1Thread.terminate')
        self.terminated = True
 
class TCPServer1(TCPServerBase):
   
    DEFAULT_CONFIG = {'ethif':'any',
                      'port':1200,
                      'compat_1': True,
                      'canif': None,
                      }
   
    pktHandler = None
    serverThread = None
    ownerNotifier = None
   
    pktBuffer = []
    pktBufferLock = None
   
    class ServerListener():
       
        parent = None
       
        def __init__(self, parent):
            self.parent = parent
       
        def empty(self):
            if len(self.parent.pktBuffer) > 0:
                return False
            return True
       
        def full(self):
            return False
       
        def lock(self):
            self.parent.pktBufferLock.acquire()
           
        def unlock(self):
            self.parent.pktBufferLock.release()
       
        def write(self, data):
            self.lock()
            self.parent.pktBuffer.append(data)
            self.unlock()
           
        def read(self):
            self.lock()
            data = self.parent.pktBuffer.pop(0)
            self.unlock()
            return data
           
   
    def __init__(self, pktHandler, cfg = None):
        if cfg is None:
            self.config = self.DEFAULT_CONFIG
        else:
            self.config = cfg
        self.pktBufferLock = Lock()
        self.pktHandler = pktHandler
        log.debug('Creating tcpd server, config: ' + str(self.config))
 
    def setPktHandler(self, pktHandler):
        self.pktHandler = pktHandler
       
    def setIfNotifier(self, ifNotifier):
        self.ownerNotifier = ifNotifier
   
    def start(self):
        ethif = self.config['ethif']
        port = self.config['port']
        compat_1 = self.config['compat_1']
        canif = self.config['canif']
       
        serverListener = self.ServerListener(self)
        self.pktHandler.addServerListener(serverListener)
       
        self.serverThread = TCPServer1Thread(self.ownerNotifier, serverListener, port)
#        self.serverThread = TCPServer(port, self.ownerNotifier)
        self.serverThread.start()
        return True
 
    def stop(self):
        if self.running():
            self.serverThread.terminate()
        else:
            log.debug('TCP interface not started, or already stopped')
   
    def running(self):
        if self.serverThread is not None:
            return not self.serverThread.terminated
        else:
            return False
 

Rev 752	Rev 800
1	###########################################################	1	###########################################################
2	#	2	#
3	# Implements the TCP server interface to administrative	3	# Implements the TCP server interface to administrative
4	# or monitoring apps	4	# or monitoring apps
5	#	5	#
6	###########################################################	6	###########################################################
7		7
8	from TCPServerBase import TCPServerBase	8	from TCPServerBase import TCPServerBase
9		9
10	from threading import Thread	10	from threading import Thread
11	from threading import Lock	11	from threading import Lock
12	import logging as log	12	import logging as log
13	import time	13	import time
14	from TCPServer import TCPServer	14	from TCPServer import TCPServer
15		15
16	class TCPServer1Thread(Thread):	16	class TCPServer1Thread(Thread):
17	ownerNotifier = None	17	ownerNotifier = None
18	terminated = False	18	terminated = False
19	serverListener = None	19	serverListener = None
20	tcpServer = None	20	tcpServer = None
21	port = None	21	port = None
22		22
23	def __init__ (self, ownerNotifier, serverListener, port):	23	def __init__ (self, ownerNotifier, serverListener, port):
24	Thread.__init__(self)	24	Thread.__init__(self)
25	self.ownerNotifier = ownerNotifier	25	self.ownerNotifier = ownerNotifier
26	self.serverListener = serverListener	26	self.serverListener = serverListener
27	self.port = port	27	self.port = port
28		28
29	def cleanup(self):	29	def cleanup(self):
30	if self.tcpServer.running():	30	if self.tcpServer.running():
31	self.tcpServer.stop()	31	self.tcpServer.stop()
32	self.ownerNotifier.notify(self.ownerNotifier.TERMINATE)	32	self.ownerNotifier.notify(self.ownerNotifier.TERMINATE)
33		33
34	def run(self):	34	def run(self):
35	try:	35	try:
36	log.debug('TCPServer1Thread.run')	36	log.debug('TCPServer1Thread.run')
37	self.tcpServer = TCPServer(self.port, self.ownerNotifier)	37	self.tcpServer = TCPServer(self.port, self.ownerNotifier)
38	self.tcpServer.start()	38	self.tcpServer.start()
39		39
40	while not self.terminated:	40	while not self.terminated:
41	while not self.serverListener.empty():	41	while not self.serverListener.empty():
42	data = self.serverListener.read() + '\n'	42	data = self.serverListener.read() + '\n'
43	self.tcpServer.writeAll(data)	43	self.tcpServer.writeAll(data)
44	time.sleep(0.01)	44	time.sleep(0.01)
45	self.cleanup()	45	self.cleanup()
46	except: # sys.excepthook does not work in threads	46	except: # sys.excepthook does not work in threads
47	import traceback	47	import traceback
48	traceback.print_exc()	48	traceback.print_exc()
49	self.terminated = True	49	self.terminated = True
50	self.cleanup()	50	self.cleanup()
51		51
52	def terminate(self):	52	def terminate(self):
53	log.debug('TCPServer1Thread.terminate')	53	log.debug('TCPServer1Thread.terminate')
54	self.terminated = True	54	self.terminated = True
55		55
56	class TCPServer1(TCPServerBase):	56	class TCPServer1(TCPServerBase):
57		57
58	DEFAULT_CONFIG = {'ethif':'any',	58	DEFAULT_CONFIG = {'ethif':'any',
59	'port':1200,	59	'port':1200,
60	'compat_1': True,	60	'compat_1': True,
61	'canif': None,	61	'canif': None,
62	}	62	}
63		63
64	pktHandler = None	64	pktHandler = None
65	serverThread = None	65	serverThread = None
66	ownerNotifier = None	66	ownerNotifier = None
67		67
68	pktBuffer = []	68	pktBuffer = []
69	pktBufferLock = None	69	pktBufferLock = None
70		70
71	class ServerListener():	71	class ServerListener():
72		72
73	parent = None	73	parent = None
74		74
75	def __init__(self, parent):	75	def __init__(self, parent):
76	self.parent = parent	76	self.parent = parent
77		77
78	def empty(self):	78	def empty(self):
79	if len(self.parent.pktBuffer) > 0:	79	if len(self.parent.pktBuffer) > 0:
80	return False	80	return False
81	return True	81	return True
82		82
83	def full(self):	83	def full(self):
84	return False	84	return False
85		85
86	def lock(self):	86	def lock(self):
87	self.parent.pktBufferLock.acquire()	87	self.parent.pktBufferLock.acquire()
88		88
89	def unlock(self):	89	def unlock(self):
90	self.parent.pktBufferLock.release()	90	self.parent.pktBufferLock.release()
91		91
92	def write(self, data):	92	def write(self, data):
93	self.lock()	93	self.lock()
94	self.parent.pktBuffer.append(data)	94	self.parent.pktBuffer.append(data)
95	self.unlock()	95	self.unlock()
96		96
97	def read(self):	97	def read(self):
98	self.lock()	98	self.lock()
99	data = self.parent.pktBuffer.pop(0)	99	data = self.parent.pktBuffer.pop(0)
100	self.unlock()	100	self.unlock()
101	return data	101	return data
102		102
103		103
104	def __init__(self, pktHandler, cfg = None):	104	def __init__(self, pktHandler, cfg = None):
105	if cfg is None:	105	if cfg is None:
106	self.config = self.DEFAULT_CONFIG	106	self.config = self.DEFAULT_CONFIG
107	else:	107	else:
108	self.config = cfg	108	self.config = cfg
109	self.pktBufferLock = Lock()	109	self.pktBufferLock = Lock()
110	self.pktHandler = pktHandler	110	self.pktHandler = pktHandler
111	log.debug('Creating tcpd server, config: ' + str(self.config))	111	log.debug('Creating tcpd server, config: ' + str(self.config))
112		112
113	def setPktHandler(self, pktHandler):	113	def setPktHandler(self, pktHandler):
114	self.pktHandler = pktHandler	114	self.pktHandler = pktHandler
115		115
116	def setIfNotifier(self, ifNotifier):	116	def setIfNotifier(self, ifNotifier):
117	self.ownerNotifier = ifNotifier	117	self.ownerNotifier = ifNotifier
118		118
119	def start(self):	119	def start(self):
120	ethif = self.config['ethif']	120	ethif = self.config['ethif']
121	port = self.config['port']	121	port = self.config['port']
122	compat_1 = self.config['compat_1']	122	compat_1 = self.config['compat_1']
123	canif = self.config['canif']	123	canif = self.config['canif']
124		124
125	serverListener = self.ServerListener(self)	125	serverListener = self.ServerListener(self)
126	self.pktHandler.addServerListener(serverListener)	126	self.pktHandler.addServerListener(serverListener)
127		127
128	self.serverThread = TCPServer1Thread(self.ownerNotifier, serverListener, port)	128	self.serverThread = TCPServer1Thread(self.ownerNotifier, serverListener, port)
129	# self.serverThread = TCPServer(port, self.ownerNotifier)	129	# self.serverThread = TCPServer(port, self.ownerNotifier)
130	self.serverThread.start()	130	self.serverThread.start()
131	return True	131	return True
132		132
133	def stop(self):	133	def stop(self):
134	if self.running():	134	if self.running():
135	self.serverThread.terminate()	135	self.serverThread.terminate()
136	else:	136	else:
137	log.debug('TCP interface not started, or already stopped')	137	log.debug('TCP interface not started, or already stopped')
138		138
139	def running(self):	139	def running(self):
140	if self.serverThread is not None:	140	if self.serverThread is not None:
141	return not self.serverThread.terminated	141	return not self.serverThread.terminated
142	else:	142	else:
143	return False	143	return False
144		144

Subversion Repositories HomeAutomation

(root)/branches/modules/PcSoftware/pyCanDaemon/TCPServer1.py – Rev 752 → 800