def start(self): if self.port: self.stop() if config.setting["browser_integration_localhost_only"]: self.host_address = QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHost) else: self.host_address = QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any) for port in range(config.setting["browser_integration_port"], 65535): if self.listen(self.host_address, port): log.debug("Starting the browser integration (%s:%d)", self.host_address.toString(), port) self.port = port self.tagger.listen_port_changed.emit(self.port) break
def sendSDP(self, flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray): """ You know, the detail experiment with sendSDP() see mySDPinger.py the bArray can be constructed simply by using type casting. Ex: elements = [0, 200, 50, 25, 10, 255] bArray = bytearray(elements) # byte must be in range(0, 256) Something wrong with bArray -> try to use list instead """ da = (dax << 8) + day dpc = (dp << 5) + dc sa = 0 spc = 255 pad = struct.pack('2B', 0, 0) hdr = struct.pack('4B2H', flags, tag, dpc, spc, da, sa) scp = struct.pack('2H3I', cmd, seq, arg1, arg2, arg3) sdp = pad + hdr + scp """ if bArray is not None: sdp = pad + hdr + scp + bArray else: sdp = pad + hdr + scp """ if bArray is not None: for b in bArray: sdp += struct.pack('<B', b) #sdp += b CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT) time.sleep(DEF_SDP_TIMEOUT) return sdp
def __init__(self, parent=None): QtGui.QWidget.__init__(self, parent) self.blockSize = 0 self.tcpSocket = QtNetwork.QTcpSocket(self) self.tcpSocket.readyRead.connect(self.readSig) self.tcpSocket.connectToHost(QtNetwork.QHostAddress('127.0.0.1'), 5000)
def __init__(self, argv): QtGui.QApplication.__init__(self, argv) settings = utils.Settings() # Prepare socket for sending notifications self.socketTo = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.socketTo.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) self.socketTo.connect(('255.255.255.255', settings.notificationPort)) # Prepare socket for receiving notifications self.socketFrom = QtNetwork.QUdpSocket() anyAddress = QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any) self.socketFrom.bind(anyAddress, settings.notificationPort) self.connect(self.socketFrom, SIGNAL("readyRead()"), self.onNotification) # Prepare the ping agent self.pingAgent = PingAgent(self, settings.dbHost) # Run the timer which checks the connection periodically self.connectionTimer = QTimer(self) self.connect(self.connectionTimer, SIGNAL("timeout()"), self.checkConnection) # Check the connection every 16 seconds if the connection is lost # or every 5 minutes if the connection is here self.connectionTimer.start(16 * 1000) # Check it at the very beginning QtCore.QTimer.singleShot(1000, self.checkConnection)
def Do_DownloadData(strFile, isFin=False): strData = 'GET /userRpm/' + strFile + ' HTTP/1.1\r\n' \ 'Cookie: ' + conf__strCookie + '\r\n' \ 'Referer: ' + conf__strLinkPrefix + 'MenuRpm.htm\r\n\r\n' print strData cachedData = [] def on_ready_read(): if client.bytesAvailable(): print '-' * 50 print 'on_ready_read()' print client.bytesAvailable(), 'read.' data = str(client.readAll()) cachedData.append(data) print len(data), client.bytesAvailable() #print data def on_connected(): client.writeData(strData) print 'connected.' def on_disconnect(): print '-' * 50 print 'on_disconnect()' print len(cachedData) print ''.join(cachedData) if isFin: exit(0) client = QtNetwork.QTcpSocket() client.readyRead.connect(on_ready_read) client.connected.connect(on_connected) client.disconnected.connect(on_disconnect) client.connectToHost(QtNetwork.QHostAddress('192.168.1.1'), 80)
def send_server_invite_option(self, invite_client_ids, channel_id): # for each client_id find the socket on which to send the # server_invite option for invite_client_id in invite_client_ids: for _, client_sockets in self.channels.items(): for (client_id, socket) in client_sockets: if invite_client_id == client_id: #Hier kann es auch sein, dass nur eine Id gebraucht #wird und nicht eine Liste... option_data = Container(channel_id=channel_id, client_id=invite_client_ids) option = Container(option_id="SERVER_INVITE_OPTION", option_data=option_data) pdu = Container(id=self.id, option=[option]) ip_to_invite = QtNetwork.QHostAddress( socket.peerAddress()) udpSocket_for_invites = QtNetwork.QUdpSocket(self) udpSocket_for_invites.bind( ip_to_invite, broadcast_port, QtNetwork.QUdpSocket.ShareAddress) udpSocket_for_invites.writeDatagram( InstantSoupData.peer_pdu.build(pdu), ip_to_invite, broadcast_port) log.debug('PDU: SERVER_INVITE_OPTION - id: %i - SENT' % self.pdu_number)
def __init__(self, parent): QtCore.QObject.__init__(self, parent) self.host2ip = {} self.ip2host = {} self.last_calc = time.time() self.pilotsHistory = {} self.timer = QtCore.QTimer(self) self.connect(self.timer, QtCore.SIGNAL("timeout()"), self.on_timer) self.dnsLookupThread = DnsLookupThread(self) self.connect(self.dnsLookupThread, QtCore.SIGNAL("domain_found"), self.on_domain_found) #def run(self): self.dnsLookupThread.start() self.timer.start(1000) self.telnetString = {} self.telnetTimer = {} self.telnetSocket = {} self.lastUpdate = None self.server = QtNetwork.QTcpServer(self) self.connect(self.server, QtCore.SIGNAL("newConnection()"), self.on_websocket_connection) self.server.listen(QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any), 5050) self.clientSockets = {} self.increment = 0
def __init__(self, send_port, targetIP, parent=None): super(UDP_sendStatus, self).__init__(parent) self.sendPort = num(send_port) self.target_IP = QtNetwork.QHostAddress(targetIP) try: self.ss = QtNetwork.QUdpSocket(self) except: print "Trouble opening UDP on socket %d" % (self.sendPort)
def start(self): if self.port: self.stop() for port in range(config.setting["browser_integration_port"], 65535): if self.listen(QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any), port): log.debug("Starting the browser integration (port %d)", port) self.port = port self.tagger.listen_port_changed.emit(self.port) break
def start(self): self.port = 8000 while self.port < 65535: self.log.debug("Starting the browser integration (port %d)", self.port) if self.listen(QtNetwork.QHostAddress(QtNetwork.QHostAddress.Any), self.port): self.tagger.emit(QtCore.SIGNAL("listen_port_changed"), self.port) break self.port += 1
def start(self): self.messageEmited.emit("NGQ Manager", "Initialization" + "...", QtGui.QSystemTrayIcon.Information, 100) self.tcpServer = QtNetwork.QTcpServer() self.tcpServer.listen(QtNetwork.QHostAddress(self.__host), self.__port) self.tcpServer.newConnection.connect(self.__newConnectionHandle) self.configure() self.ngqListChanged.connect(self.__chooseWaitingTasksForProject) self.__putToWaitingTasks(partial(self.executeArgs, self.__argString), None, self.__initializationTime)
def start(self): self.startButton.setEnabled(False) QtGui.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) self.bytesWritten = 0 self.bytesReceived = 0 self.clientStatusLabel.setText("Connecting") self.tcpClient.connectToHost( QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHost), 9112)
def sendImgInfo(self, cmd, data_type): dpc = (SDP_RECV_JPG_INFO_PORT << 5) + SDP_RECV_CORE_ID #destination port and core pad = struct.pack('2B', 0, 0) hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0) scp = struct.pack('2H3I', cmd, data_type, self.szImgFile, 0, 0) sdp = pad + hdr + scp CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn), SPINN_PORT) CmdSock.flush() # then give a break, otherwise spinnaker will collapse self.delay()
def sendChunk(ch_port, ba): da = 0 dpc = (ch_port << 5) + 1 sa = 0 spc = 255 pad = struct.pack('<2B', 0, 0) hdr = struct.pack('<4B2H', 7, 0, dpc, spc, da, sa) sdp = pad + hdr + ba CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT) CmdSock.flush()
def sendImgInfo(self): dpc = (SDP_RECV_RAW_INFO_PORT << 5) + SDP_RECV_CORE_ID # destination port and core pad = struct.pack('2B', 0, 0) hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0) scp = struct.pack('2H3I', SDP_CMD_INIT_SIZE, 0, len(self.orgImg), self.wImg, self.hImg) sdp = pad + hdr + scp CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn), SPINN_PORT) CmdSock.flush() # then give a break, otherwise spinnaker might collapse self.delay()
def __init__(self, port=9500, server_name = "default", address = QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHost), parent = None, verbose = False): QtCore.QObject.__init__(self) # Initialize internal attributes self.address = address self.port = port self.server_name = server_name self.socket = None self.verbose = verbose
def sendImgPerChip(self, chipIdx, nChip): """ Send image data to a specific chip, where chipIdx = 0,1,2,3 for spin3. This function assume rmap0, gmap0, and bmap0 are ready! """ # first, send image configuration # for spin3: x = spin3[chipIdx][0] y = spin3[chipIdx][1] da = (x << 8) + y # send image information through SDP_PORT_CONFIG dpcc = (sdpImgConfigPort << 5) + sdpCore hdrc = struct.pack('4B2H', 0x07, 1, dpcc, 255, da, 0) cmd = SDP_CMD_CONFIG if self.isGray is True: isGray = 1 else: isGray = 0 if self.cbMode.currentIndex( ) == 0 and self.cbFilter.isChecked() is False: opt = 1 elif self.cbMode.currentIndex( ) == 0 and self.cbFilter.isChecked() is True: opt = 2 elif self.cbMode.currentIndex( ) == 1 and self.cbFilter.isChecked() is False: opt = 3 else: opt = 4 seq = (isGray << 8) + opt arg1 = (self.w << 16) + self.h arg2 = (chipIdx << 16) + nChip # arg2.high = nodeBlockID, arg2.low = maxBlock arg3 = ASK_BLOCK_REPORT scp = struct.pack('2H3I', cmd, seq, arg1, arg2, arg3) # arg3 is not used sdp = pad + hdrc + scp self.sdpSender.writeDatagram(sdp, QtNetwork.QHostAddress(self.DEF_HOST), DEF_SEND_PORT) # this time, no need for reply time.sleep(1) # wait a second print "Sending image..." self.sendImg(x, y)
def sendChunk(ch_port, core, seq, ba): da = 0 dpc = (ch_port << 5) + core sa = seq spc = 255 pad = struct.pack('<2B',0,0) hdr = struct.pack('<4B2H',7,0,dpc,spc,da,sa) if ba is not None: sdp = pad + hdr + ba else: sdp = pad + hdr CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT) CmdSock.flush()
def __init__(self, parent): QtCore.QObject.__init__(self, parent) self.connections = [] self.threads = [] self.count = 0 self.server = QtNetwork.QTcpServer(self) #FIXME #tcp_address = QtNetwork.QHostAddress.Any tcp_address = QtNetwork.QHostAddress("192.168.0.146") tcp_port = 1137 self.connect(self.server, QtCore.SIGNAL("newConnection()"), self.socket_connected) self.server.listen(tcp_address, tcp_port) parent.txtSocket.setPlainText( "RiiFS Python Server is now ready for connections on 1137")
def sendSDP(flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray): da = (dax << 8) + day dpc = (dp << 5) + dc sa = 0 spc = 255 pad = struct.pack('<2B', 0, 0) hdr = struct.pack('<4B2H', flags, tag, dpc, spc, da, sa) scp = struct.pack('<2H3I', cmd, seq, arg1, arg2, arg3) if bArray is not None: sdp = pad + hdr + scp + bArray else: sdp = pad + hdr + scp CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF_HOST), DEF_SEND_PORT) CmdSock.flush() return sdp
def __init__(self, parent=None, port=9500, server_name="default", address=QtNetwork.QHostAddress( QtNetwork.QHostAddress.LocalHost), verbose=False): tcpCommunications.TCPCommunications.__init__(self, parent=parent, port=port, server_name=server_name, address=address, verbose=verbose) # Create instance of TCP socket self.socket = QtNetwork.QTcpSocket() self.socket.disconnected.connect(self.handleDisconnect) self.socket.readyRead.connect(self.handleReadyRead)
def sendChunk(self, chunk): # based on sendSDP() # will be sent to chip <0,0>, no SCP dpc = (SDP_RECV_RAW_DATA_PORT << 5) + SDP_RECV_CORE_ID # destination port and core pad = struct.pack('2B', 0, 0) hdr = struct.pack('4B2H', 7, 0, dpc, 255, 0, 0) if chunk is not None: sdp = pad + hdr + chunk else: # empty sdp means end of image transmission sdp = pad + hdr CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(self.spinn), SPINN_PORT) CmdSock.flush() # then give a break, otherwise spinnaker will collapse self.delay()
def func_connect(self): retStatus = False if self.listen(QtNetwork.QHostAddress(self.host), self.port): if __package__ == None: print 'server is awake :: %s:%s' % (str( self.host), str(self.port)) else: try: self.messageSignal.emit( u'TCP/IP 서버를 열었습니다. :: %s:%s' % (str(self.host), str(self.serverPort())), self.id) except: pass retStatus = True else: if __package__ == None: print "server couldn't wake up" else: try:
def configureNetwork(self): #self.blockSize = 0 self.socket = QtNetwork.QTcpServer() self.socket.name = 'ThinkGear Server' if self.DEBUG: print "<---- [%s] Initializing server on %s:%i" % \ (self.socket.name, self.server_interface, self.server_port) if ((self.server_interface == '') or \ (self.server_interface == '*')): address = QtNetwork.QHostAddress.Any else: #address=self.server_interface address = QtNetwork.QHostAddress(self.server_interface) result = self.socket.listen(address, self.server_port) if not result: try: QtGui.QMessageBox.information( \ self.parent, \ self.socket.name, \ "Unable to start the server on %s:%i" % \ (self.server_interface, self.server_port)) except: pass if self.DEBUG: print "ERROR [%s] Unable to start the server:" % self.socket.name, print self.socket.errorString() #self.parent.stopThinkGearConnectServer() #self.parent.pushButtonThinkGearConnect.nextCheckState() #self.parent.pushButtonThinkGearConnect.toggle() #self.parent.pushButtonThinkGearConnect.test.emit(QtCore.SIGNAL("clicked()")) self.socket.close() return self.socket.newConnection.connect(self.processConnection)
def sendFreqReq(self, freq, dax, day): #def sendFreqReq(self,flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray): """ The detail experiment with sendSDP() see mySDPinger.py """ da = (dax << 8) + day dpc = (DEF.SDP_PORT << 5) + DEF.SDP_CORE sa = 0 spc = 255 pad = struct.pack('2B', 0, 0) hdr = struct.pack('4B2H', DEF.NO_REPLY, DEF.SEND_IPTAG, dpc, spc, da, sa) scp = struct.pack('2H3I', DEF.HOST_SET_FREQ_VALUE, freq, 0, 0, 0) sdp = pad + hdr + scp CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF.HOST), DEF.SEND_PORT) return sdp
def ctrlServer(self): if not self._running: self._server = Server(self) #FIXME #if not self._server.listen(QtNetwork.QHostAddress.Any, self.specPort.text().toInt()[0]): if not self._server.listen(QtNetwork.QHostAddress(self.specAddr.text()), self.specPort.text().toInt()[0]): print "Listen ERROR!" self.close() return else: print "Server Running" self.serverCtrl.setText('Stop Server') self._running=True else: for thread in self._server.threadList: thread.exit() self._server.close() self.close()
def sendSDP(self,flags, tag, dp, dc, dax, day, cmd, seq, arg1, arg2, arg3, bArray): """ The detail experiment with sendSDP() see mySDPinger.py """ da = (dax << 8) + day dpc = (dp << 5) + dc sa = 0 spc = 255 pad = struct.pack('2B',0,0) hdr = struct.pack('4B2H',flags,tag,dpc,spc,da,sa) scp = struct.pack('2H3I',cmd,seq,arg1,arg2,arg3) if bArray is not None: sdp = pad + hdr + scp + bArray else: sdp = pad + hdr + scp CmdSock = QtNetwork.QUdpSocket() CmdSock.writeDatagram(sdp, QtNetwork.QHostAddress(DEF.HOST), DEF.SEND_PORT) return sdp
def __init__(self, port=9500, server_name="default", address=QtNetwork.QHostAddress( QtNetwork.QHostAddress.LocalHost), parent=None, verbose=False): QtNetwork.QTcpServer.__init__(self, parent) tcpCommunications.TCPCommunications.__init__(self, parent=parent, port=port, server_name=server_name, address=address, verbose=verbose) # Connect new connection signal self.newConnection.connect(self.handleClientConnection) # Listen for new connections self.connectToNewClients()
def configureNetwork(self): #self.blockSize = 0 self.socket = QtNetwork.QTcpSocket() self.socket.name = 'ThinkGear Client' if self.server_host == '*': self.server_host = '127.0.0.1' self.server_host = QtNetwork.QHostAddress(self.server_host) self.socket.readyRead.connect(self.printReply) self.socket.error.connect(self.displayError) # Perform ThinkGear authorization if enabled if ENABLE_THINKGEAR_AUTHORIZATION: self.sendCommand(AUTHORIZATION_REQUEST) self.socket.waitForReadyRead() self.socket.disconnectFromHost() self.sendCommand(THINKGEAR_CONFIGURATION_PARAMETERS)
def Do_DownloadData(strFile): print 'strFile=', strFile strData = 'GET /userRpm/' + strFile + ' HTTP/1.1\r\n' \ 'Cookie: ' + conf__strCookie + '\r\n' \ 'Referer: ' + conf__strLinkPrefix + 'MenuRpm.htm\r\n\r\n' print strData client = QtNetwork.QTcpSocket() client.connectToHost(QtNetwork.QHostAddress('192.168.1.1'), 80) client.writeData(strData) cachedData = [] while True: client.waitForReadyRead(30000) nBytesAvailable = client.bytesAvailable() if nBytesAvailable == 0: break print nBytesAvailable, 'read.' print '-' * 60 cachedData.append(str(client.readAll())) client.close() return ''.join(cachedData)