class DatagramTransfer :
def __init__(self, localPort, servHost, servPort) :
self.serv = None
self.client = None
self.startServ(localPort)
self.startClient(servHost, servPort)
def startServ(self, port = 6000) :
self.serv = TCPServThread('0.0.0.0', port)
self.serv.setDaemon(True)
self.serv.start()
pass
def startClient(self, host, port) :
self.client = TCPClient(host, port)
pass
def sendMsg(self,msg) :
self.client.send(msg)
log('D', "[%s]"%msg)
pass
def sendMsgWaitForReply(self, msg) :
self.client.send(msg)
while self.serv.recvBuffer == "" :
pass
return self.serv.flashRecvBuffer()
def recvMsg(self) :
if self.serv.recvBuffer != "" :
return self.serv.flashRecvBuffer()
else :
return ""
# 设置报文格式并结构化报文
def setDatagram(self, transtype, datagramIn) :
self.dgParser = DatagramParser(transtype)
self.dgParser.datagramIn.parser(datagramIn)
# 发送报文,并等待获取结果报文,并格式化
def sendDatagramAndGetReply(self) :
self.client.send(self.dgParser.datagramIn.msg)
while self.serv.recvBuffer == "" :
pass
reply = self.serv.flashRecvBuffer()
self.dgParser.datagramOut.parser(reply)
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
from TCPServ import TCPServThread
from TCPClient import TCPClient
from log import log
if __name__=="__main__" :
serv = TCPServThread('0.0.0.0', 12345)
serv.setDaemon(True)
serv.start()
while serv.recvBuffer == "" :
pass
client = TCPClient('127.0.0.1', 6000)
#recvMsg = serv.flashRecvBuffer()
while True :
if serv.recvBuffer != "" :
recvMsg = serv.flashRecvBuffer()
log('M','[RECV] %s'%recvMsg)
ret = "014040230090847054CT1234564000010000004942360010001676 霞編001 000000000000A2T00000000000000201404176666666666666666 "
log('D', '[SEND] LEN %d'%len(ret))
log('D','[SEND] [%s]'%ret)
client.send(ret)
class LayerPhy(object):
'''
classdocs
'''
def __init__(self, upperLayerCallbackFunction, masterHost='127.0.0.1', baseport=10000):
'''
Constructor
'''
self.__masterHost=masterHost
self.__controlPort=baseport-1
self.__interfaceSendPort=[0, 0]
self.__interfaceRecvPort=[0, 0]
self.__incomingTcpServer=[None, None]
self.__outgoingTcpClient=[None, None]
self.__callLinkLayer=upperLayerCallbackFunction
self.__debugOut=DebugOut()
self.__openControl_connection();
self.API_enter()
def API_enter(self):
self.__debugOut.out("Sending ENTER")
self.controlTcpClient.send("ENTER\n");
def API_leave(self):
self.__debugOut.out("Sending ENTER")
self.controlTcpClient.send("LEAVE\n");
def API_sendData(self, interfaceNumber=0, data=""):
if self.__outgoingTcpClient[interfaceNumber] is not None:
self.__debugOut.out("PHY - PhysicalLayer, Interface %d, sending %s" % (interfaceNumber, data))
self.__outgoingTcpClient[interfaceNumber].send(data)
def __listenControl_connection(self, tcpClient, __connection, clientAddr, data):
while data:
(line, separator, data)=data.partition("\n")
self.__debugOut.out("PHY %s - __listenControl_connection - received %s" % (clientAddr,line))
(command, separator, line)=line.partition(",")
if command == "ADDINTERFACE":
(interfacenumber, separator, line)=line.partition(",")
(listenport, separator, line)=line.partition(",")
self.__addInterface(int(interfacenumber), int(listenport))
self.__debugOut.out("PHY %s done __addInterface" % (clientAddr,))
elif command == "DELINTERFACE":
(interfacenumber, separator, line)=line.partition(",")
self.__delInterface(int(interfacenumber))
elif command == "CONNECT":
(interfacenumber, separator, line)=line.partition(",")
(ipAddress, separator, line)=line.partition(",")
(listenport, separator, line)=line.partition(",")
self.__connect(int(interfacenumber), ipAddress, int(listenport))
elif command == "DISCONNECT":
(interfacenumber, separator, line)=line.partition(",")
self.__disconnect(int(interfacenumber))
else:
self.__debugOut.out("PHY %s - listenControl_connection - Received unknown command %s." % (clientAddr,command))
def __openControl_connection(self):
self.controlTcpClient= TCPClient(self.__masterHost, self.__controlPort, self.__listenControl_connection)
def __incomingData_connectionInterface0(self, tcpServer, __connection, clientAddr, data):
self.__debugOut.out("PHY %s - ListenData_connection on interface 0 received %s" % (clientAddr,data))
self.__callLinkLayer(0,data)
def __incomingData_connectionInterface1(self, tcpServer, __connection, clientAddr, data):
self.__debugOut.out("PHY %s - ListenData_connection on interface 1 received %s" % (clientAddr,data))
self.__callLinkLayer(1,data)
def __sendControl(self,data):
self.controlTcpClient.send(data)
def __addInterface(self, interfaceNumber=0, listenport=0):
self.__debugOut.out("PHY - Adding interface number %d with listenport %d" % (interfaceNumber, listenport))
if self.__incomingTcpServer[interfaceNumber] is None:
self.__interfaceRecvPort[interfaceNumber]=listenport
if interfaceNumber==0:
self.__incomingTcpServer[0]=TCPServer('127.0.0.1',self.__interfaceRecvPort[0],self.__incomingData_connectionInterface0)
else:
self.__incomingTcpServer[1]=TCPServer('127.0.0.1',self.__interfaceRecvPort[1],self.__incomingData_connectionInterface1)
self.__debugOut.out('PHY - Tried to add interface, isServing is : %d' % self.__incomingTcpServer[interfaceNumber].isServing())
if self.__incomingTcpServer[interfaceNumber].isServing():
self.__sendControl("STATUS,ACK\n")
else:
self.__sendControl("STATUS,NACK,Interface open failed\n")
self.__incomingTcpServer[interfaceNumber]=None
else:
self.__sendControl("STATUS,NACK,Interface is already __connected\n")
def __delInterface(self, interfaceNumber):
self.__debugOut.out("Removing interface number %d with listenport %d" % (interfaceNumber, self.__interfaceRecvPort[interfaceNumber]))
if self.__incomingTcpServer[interfaceNumber] is None:
self.__sendControl("STATUS,NACK,Interface is not active\n")
else:
self.__incomingTcpServer[interfaceNumber].stopServer()
self.__incomingTcpServer[interfaceNumber]=None
self.__sendControl("STATUS,ACK\n")
def __connect(self, interfaceNumber=0, ipAddress="127.0.0.1",sendport=0):
self.__debugOut.out("PHY - __connecting interface %d to ip %s port %d" % (interfaceNumber, ipAddress, sendport))
if self.__outgoingTcpClient[interfaceNumber] is None:
self.__interfaceSendPort[interfaceNumber]=sendport
self.__outgoingTcpClient[interfaceNumber]=TCPClient(ipAddress,self.__interfaceSendPort[interfaceNumber],None)
if self.__outgoingTcpClient[interfaceNumber].isConnected():
self.__sendControl("STATUS,ACK\n")
else:
self.__sendControl("STATUS,NACK,Interface open failed\n")
else:
self.__sendControl("STATUS,NACK,Interface is already __connected\n")
def __disconnect(self, interfaceNumber=0):
self.__debugOut.out("PHY - disconnecting interface %d from port %d" % (interfaceNumber, self.__interfaceSendPort[interfaceNumber]))
if self.__outgoingTcpClient[interfaceNumber] is None:
self.__sendControl("STATUS,NACK,Interface is not __connected\n")
else:
self.__outgoingTcpClient[interfaceNumber].stopClient()
self.__outgoingTcpClient[interfaceNumber]=None
self.__sendControl("STATUS,ACK\n")
from TCPClient import TCPClient
import time
app = TCPClient() # Create new class object
app.address = ('localhost', 5000) # Set up ip and port for connection
app.start() # Start connection and running forever
time.sleep(5) # Delay 5 secs
app.send("test1") # Send message
time.sleep(2) # Delay 2 secs
print(app.rcvmsg) # Print out to see receive message
time.sleep(1) # Delay 2 secs
app.stop() # Stop running
