Example #1
0
 def _accept_client(self):
     # 使用非阻塞方式等待連線,逾時時間為 1 秒
     self._socket.settimeout(1)
     while not self._stop:
         try:
             client, addr = self._socket.accept()
         except socket.timeout:
             # 等待連線逾時,再重新等待
             continue
         except:
             # except (socket.error, IOError) as ex:
             # 先攔截並顯示,待未來確定可能會發生的錯誤再進行處理
             print(traceback.format_exc())
             break
         if self._stop:
             try:
                 client.close()
             except:
                 pass
             break
         clk = TcpClient.TcpClient(client)
         clk.bind(key=EventTypes.RECEIVED, evt=self._events[EventTypes.RECEIVED])
         clk.bind(key=EventTypes.DISCONNECT, evt=self._onClientDisconnect)
         clk.bind(key=EventTypes.SENDED, evt=self._events[EventTypes.SENDED])
         clk.bind(key=EventTypes.SENDFAIL, evt=self._events[EventTypes.SENDFAIL])
         self._clients[addr] = clk
         if self._events[EventTypes.CONNECTED] is not None:
             self._events[EventTypes.CONNECTED](clk, self._host, addr)
     if self._events[EventTypes.STOPED] is not None:
         self._events[EventTypes.STOPED](self)
 def __init__(self, ip, port, filePath):
     super(FileTransferClient, self).__init__()
     self.messageQueue = Queue.Queue()
     self.tcpClient = TcpClient(0, ip, port, self.messageQueue)
     self.transferType = FileTransferContext.TRANSFER_TYPE_SEND
     self.filePath = filePath
     self.fileBaseName = os.path.basename(self.filePath)
     self.fileChunkSize = COMMON.PACKET_BODY_SIZE
     pass
Example #3
0
 def __init__(self):
     threading.Thread.__init__(self)
     self.client = TcpClient.SocketClientThread()
     self.client.start()
     self.handlers = {
         TaskCommand.TAKEPICTURE: self.handle_TAKEPICTURE,
         TaskCommand.PROFILENAME: self.handle_PROFILENAME,
         TaskCommand.IMAGE: self.handle_IMAGE,
         TaskCommand.POINTS: self.handle_POINTS,
         TaskCommand.RESULT: self.handle_RESULT,
     }
     self.profilename=""
Example #4
0
def run_client(args):
    print "Starting as client"
    if args.tcp:
        client = TcpClient.TcpClient(args.destination, args.port, args.size,
                                     args.timeout)
    elif args.udp:
        client = UdpClient.UdpClient(args.destination, args.port, args.size,
                                     args.timeout)
    else:
        print "Error - please specify tcp or udp"
        return -1

    res = client.send_ping()
    if res:
        print "Received response from server"
    else:
        print "Server is not responding"
Example #5
0
# -*- coding: utf-8 -*-
#Give wisdom to the machine,By ChangShouMeng

from TcpClient import *
from protocol_push import *

tcpClient = TcpClient(0, "127.0.0.1", 1989, None)


def main():
    global tcpClient
    if not tcpClient.start():
        print "tcpClient start failed"
        return
    print "start succ"
    req = HTTP_POST_METHOD_PUSH_GROUP_OFFLINEMSG()
    req.m_uMainCmd = 1
    req.muGroupID = 11
    req.muSenderID = 22
    req.muDeviceType = 2
    text = "HELLOWORLD"
    req.muFieldSize1 = len(text)
    ids = "11,22"
    req.muFieldSize2 = len(ids)
    req.message = text
    req.memberid = ids
    req.m_uPacketSize = req.getSize()
    tcpClient.sendPacket(req)
    print "send req"

Example #6
0
			res = walktree(pathname, prn)
			outlist += res
		elif S_ISREG(mode):
			# 숫자로 이루어진 전화 번호만.
			if f[0].isdigit() and f[-1].isdigit():
				outlist.append(pathname)
	outlist.sort()
	return outlist
		
if __name__ == "__main__":
	if len(sys.argv) < 5:
		print "Usage: dump_file_or_dir pas_addr pas_port cpwebserver_port [begin] [how_many]"
		sys.exit()

	if sys.argv[1][-1] != "/":
		cli = TcpClient.TcpClient()
		cli.conn(sys.argv[2], int(sys.argv[3]))
		cli.start()
		
		cpsvr = TcpServer.MyServer(int(sys.argv[4]))
		cpsvr.start()
		
		proc = DumpProc(cli, cpsvr)
		
		proc.see(sys.argv[1])
		time.sleep(1)
		cli.stop()
		cpsvr.stop()
	
	else:
		
Example #7
0
import socket
import TcpClient
import ClientConfig
import os

CONFIG_FILE = os.path.join(os.path.dirname(__file__), 'client_config.json')

if __name__ == '__main__':
    client_configuration = ClientConfig.ClientConfig(CONFIG_FILE)
    port = client_configuration.port
    host = client_configuration.host
    client = TcpClient.TcpClient(port, host)
    print 'Client connected.....'
    client.connect()
Example #8
0
 def _createTestApikey(self):
     import TcpClient
     return TcpClient.newApikey()
class FileTransferClient(FileTransferContext):
    def __init__(self, ip, port, filePath):
        super(FileTransferClient, self).__init__()
        self.messageQueue = Queue.Queue()
        self.tcpClient = TcpClient(0, ip, port, self.messageQueue)
        self.transferType = FileTransferContext.TRANSFER_TYPE_SEND
        self.filePath = filePath
        self.fileBaseName = os.path.basename(self.filePath)
        self.fileChunkSize = COMMON.PACKET_BODY_SIZE
        pass

    def start(self):
        if not self.initTransferInfo():
            return False
        isOK = self.tcpClient.start()
        if isOK:
            self.sendFileUploadReq()
            return True
        else:
            print "fileClient start filed:", self.filePath
            return False

    def stop(self):
        self.tcpClient.disconnect()
        self.finiTransInfo()

    def isRunOk(self):
        return self.tcpClient.isConnected()

    # >>REQ
    def sendFileUploadReq(self):
        req = FILE_TRANSFER_PACKET()
        req.muCmd = FILE_CMD.CMD_FILE_UPLOAD_REQ
        req.mu32BitField = CONFIG.max_body_size
        body = dict()
        body["fileName"] = self.fileBaseName
        body["fileSize"] = self.fileTotalSize
        body_str = json.dumps(body)
        req.body = body_str
        req.muSize = req.getSize()
        self.tcpClient.sendPacket(req)
        print ">>will upload {0}".format(body_str)

    # <<RSP
    def onFileUploadRsp(self, rsp):
        # rsp = FILE_TRANSFER_PACKET()
        if rsp.muMsgId == 0:
            print "<<onFileUploadRsp ,rsp failed: cmd:{0} size:{1}".format(rsp.muCmd, rsp.muSize)
            return
        self.transferMsgId = rsp.muMsgId
        self.transferSeqNum = 1
        self.transferedSize = 0
        self.sendFileSegmentUploadReq()

    # >>REQ
    def sendFileSegmentUploadReq(self):
        buffer = self.readBuffer()
        if len(buffer) == 0:
            return
        req = FILE_TRANSFER_PACKET()
        req.muCmd = FILE_CMD.CMD_FILE_SEGMENT_UPLOAD_REQ
        req.muMsgId = self.transferMsgId
        req.mu32BitField = len(buffer)
        req.muSeqnum = self.transferSeqNum
        req.body = buffer
        req.muSize = req.getSize()
        self.tcpClient.sendPacket(req)

    # <<RSP
    def onFileSegmentUploadRsp(self, rsp):
        if rsp.muMsgId != self.transferMsgId:
            print "uploadrsp error msgid_no_math cli-msgid:{0} svr-msgid:{1}".format(self.transferMsgId, rsp.muMsgId)
            return
        if rsp.muSeqnum != self.transferSeqNum:
            print "uploadrsp error seqN_no_math cli_seq:{0} svr_seq:{1}".format(self.transferSeqNum, rsp.muSeqnum)
            return
        self.transferedSize += rsp.mu32BitField
        self.transferSeqNum += 1
        self.traceTransferInfo()
        self.sendFileSegmentUploadReq()

    def serve_once(self):
        try:
            self.tcpClient.serve_once()
            next_msg = self.messageQueue.get_nowait()
            self.OnProcessPacket(next_msg)
        except Queue.Empty:
            # print 'queue empty'
            pass
        pass

    def OnProcessPacket(self, packet_data):
        rsp = FILE_TRANSFER_PACKET()
        rsp.unpack(packet_data)
        if rsp.muCmd == FILE_CMD.CMD_FILE_UPLOAD_RSP:
            self.onFileUploadRsp(rsp)
            return
        if rsp.muCmd == FILE_CMD.CMD_FILE_SEGMENT_UPLOAD_RSP:
            self.onFileSegmentUploadRsp(rsp)
class FileTransferClient(FileTransferContext):
    def __init__(self,ip,port,filePath):
        super(FileTransferClient, self).__init__()
        self.messageQueue=Queue.Queue()
        self.tcpClient = TcpClient(0, ip,port, self.messageQueue)
        self.transferType = FileTransferContext.TRANSFER_TYPE_RECV
        self.filePath = filePath
        self.fileBaseName = os.path.basename(self.filePath)
        self.fileChunkSize = COMMON.PACKET_BODY_SIZE
        self.tmpdir=CONFIG.client_tmpdir
        pass

    def start(self):
        mkdir(self.tmpdir)
        isOK = self.tcpClient.start()
        if isOK :
            self.sendFileDownloadReq()
            return True
        else:
            print "fileClient start filed:",self.filePath
            return False

    def stop(self):
        self.tcpClient.disconnect()
        self.finiTransInfo()

    def isRunOk(self):
         return self.tcpClient.isConnected()


   #>>REQ
    def sendFileDownloadReq(self):
        req = FILE_TRANSFER_PACKET()
        req.muCmd = FILE_CMD.CMD_FILE_DOWNLOAD_REQ
        req.mu32BitField = CONFIG.max_body_size
        body = dict()
        body["fileName"] = self.filePath
        body_str = json.dumps(body)
        req.body = body_str
        req.muSize = req.getSize()
        self.tcpClient.sendPacket(req)
        print ">>will download {0}".format(body_str)

    #<<RSP
    def onFileDownloadRsp(self,rsp):
        #rsp = FILE_TRANSFER_PACKET()
        if rsp.muMsgId == 0:
            print "<<onFileDownloadRsp ,rsp failed: cmd:{0} size:{1}".format(rsp.muCmd,rsp.muSize)
            return
        self.transferMsgId=rsp.muMsgId
        self.fileTotalSize=rsp.mu32BitField
        if self.fileTotalSize == 0:
            print "cannot find file:{0} from server".format(self.filePath)
            return
        self.fileBaseName=os.path.basename(self.filePath)
        self.initTransferInfo()
        self.transferSeqNum=0
        self.transferedSize=0
        self.sendFileDownReceipt()

    # >>REQ
    def sendFileDownReceipt(self):
        req = FILE_TRANSFER_PACKET()
        req.muCmd = FILE_CMD.CMD_FILE_SEGMENT_DOWNLOAD_RECIPT
        req.muSeqnum=self.transferSeqNum
        req.muMsgId = self.transferMsgId
        req.muSize = req.getSize()
        self.tcpClient.sendPacket(req)

    # <<RSP
    def onFileSegmentDownloadRsp(self,rsp):
        if rsp.muMsgId != self.transferMsgId:
            print "uploadrsp error msgid_no_math cli-msgid:{0} svr-msgid:{1}".format(self.transferMsgId,rsp.muMsgId)
            return
        self.writeBuffer(rsp.body)
        self.transferSeqNum = rsp.muSeqnum
        self.traceTransferInfo()
        if self.isFinished():
            print "finished"
            pass
        else:
            self.sendFileDownReceipt()

    def serve_once(self):
        try:
            self.tcpClient.serve_once()
            next_msg = self.messageQueue.get_nowait()
            self.OnProcessPacket(next_msg)
        except Queue.Empty:
            #print 'queue empty'
            pass
        pass

    def OnProcessPacket(self,packet_data):
        rsp = FILE_TRANSFER_PACKET()
        rsp.unpack(packet_data)
        if rsp.muCmd == FILE_CMD.CMD_FILE_DOWNLOAD_RSP:
            self.onFileDownloadRsp(rsp)
            return
        if rsp.muCmd == FILE_CMD.CMD_FILE_SEGMENT_DOWNLOAD_NOTIFY:
            self.onFileSegmentDownloadRsp(rsp)
Example #11
0
    # 通过不断循环来侦听事件
    while True:
        # 给屏幕填充淡蓝色
        screen.fill((135, 206, 250))

        # get():获取事件的返回值
        for event in pygame.event.get():
            # 判断事件是否是退出事件,是则退出
            if event.type == pygame.QUIT:
                # 先退出pygame窗口,再退出程序
                pygame.quit()
                sys.exit()
            # 单击鼠标窗口颜色变为粉红色
            if event.type == pygame.MOUSEBUTTONDOWN:
                screen.fill((255, 192, 203))

            # 更新整个待显示的 Surface 对象到屏幕上
            pygame.display.flip()


if __name__ == '__main__':
    # 创建新线程
    thread1 = TcpClient.SocketHelper()
    # 开启新线程
    thread1.start()
    ui('PyCharm')
    thread1.join()


Example #12
0
def main():
    # create window
    pygame.init()
    screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.display.set_caption('JOYSTICK')
    pygame.display.flip()
    run = 0
    speedUpDown = 0
    commInterval = 0.03  # Communication Interval (s)
    commTimer = time.time()

    while True:
        #event
        for event in pygame.event.get():
            if event.type == QUIT:
                sys.exit()

        ShowPad(screen)

        if joy.get_button(8) == 1:
            run = 0

        if joy.get_button(9) == 1 and run == 0:

            readdata = ModbusTCP.ReadInputRegisters(7001, 12)
            setBasePos(readdata[9:])
            ModbusTCP.WriteRegisters(9000, readdata[9:])
            ModbusTCP.WriteRegisters(9012, readdata[9:])

            Pos.clear()
            commTimer = time.time()
            run = 1

        if run == 1:
            clamp = 0
            if joy.get_button(1) == 1:  #A
                clamp = 2
            elif joy.get_button(2) == 1:  #B
                clamp = 1

            if clamp == 0:
                setPosition()

            commElapsedtime = time.time() - commTimer
            if commElapsedtime > commInterval:
                starttime = time.time()

                #data = setCommMemory(clamp)
                #ModbusTCP.WriteRegisters(9012, data)

                SendStr = setSendStr(clamp)
                TcpClient.sendString(SendStr.encode())

                commTimer = time.time()
                elapsedtime = time.time() - starttime
                print("Elapsed Time = %sms" % (str(elapsedtime * 1000)))
                if elapsedtime > 0.1:
                    print("##### Over 100ms #####")

        # Speed
        global SPEED
        hat = joy.get_hat(0)
        if hat[1] > 0 and speedUpDown == 0:
            if SPEED < 4.95:
                SPEED += 0.1
                speedUpDown = 1
        elif hat[1] < 0 and speedUpDown == 0:
            if SPEED > 0.15:
                SPEED -= 0.1
                speedUpDown = 1
        elif hat[1] == 0:
            speedUpDown = 0

        pygame.time.wait(10)