def __init__(self, sock_type='TCP Client', ip='127.0.0.1', port=2007):
'''打开网络设备，建立连接
## sock_type:
- 'TCP Client'
- 'TCP Server'
- 'UDP'
'''
self.sock_type = sock_type
# self.ip = ip
self.port = port
if sock_type == 'TCP Client':
tcp_client = QTcpSocket()
tcp_client.connectToHost(ip, port)
self.sock = tcp_client
elif sock_type == 'TCP Server':
tcp_server = QTcpServer()
tcp_server.listen(QHostAddress(ip), port)
self.sock = tcp_server
elif sock_type == 'UDP':
udp = QUdpSocket()
udp.bind(QHostAddress(ip), port)
self.sock = udp
else:
print('Unkonw sock_type=%r' % sock_type)
def __init__(self, parent=None):
super().__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.main = parent
self.background_tex = QImage("Ground.png")
self.ups = 60
self.uc = 0
self.gamesecond = 0
self.players_tex = [QImage("panzer_0.png"), QImage("panzer_1.png"), QImage("panzer_2.png")]
self.explosion_sprites = [QImage("000" + str(i) + ".png") for i in range(1,10)] + [QImage("00"+str(i)+".png") for i in range(10,51)]
self.players = [Player(self.ups, (0.5, 0.5)),Player(self.ups, (0.7, 0.7))]
self.controls = [False, False, False, False, False]
self.controls2 = [False, False, False, False, False]
self.inputs = [self.controls,self.controls2]
self.timer = QTimer()
# Wir richten einen Server ein, zu dem Clients einen Kommunikationskanal
# öffnen können.
self.tcpServer = QTcpServer(self)
# Der Server akzeptiert jeden Client, der auf der angegebenen Port-Nummer
# sendet.
self.tcpServer.listen(QHostAddress.Any, 40890)
# self.tcpServer.listen(QHostAddress('127.0.0.1'), 40890)
# Falls beim Server eine Verbindungsanfrage von einem Client eingeht,
# soll die eigene Memberfunktion connectToClient aufgerufen werden.
self.tcpServer.newConnection.connect(self.connectToClient)
def __init__(self):
super().__init__()
self.config = Config("config.ini")
# INIT Controls
self.wheels = Wheels(self.config.steeringMid, self.config.steeringLeft,
self.config.steeringRight)
self.accelerator = Accelerator(self.config, self)
self.__initUI()
self.statusBar().showMessage("Board not connected")
# Init uds listener
self._log("Init udp at {}:{}".format(
get_ip(), self.config.getOption('udp_port')))
self.udpSocket = QUdpSocket()
self.udpSocket.setLocalAddress(QHostAddress(get_ip()))
self.udpSocket.bind(self.config.getOption('udp_port'))
self.udpSocket.readyRead.connect(self.udpHandler)
# Init tcp server
self.tcpServer = QTcpServer(self)
self._log("Starting TCP at {}:{} ".format(
get_ip(), str(self.config.getOption('tcp_port'))))
self.tcpServer.listen(QHostAddress(get_ip()),
self.config.getOption('tcp_port'))
self.tcpServer.newConnection.connect(self.establishBoardConnection)
self.show()
class QTServerThread(QWidget):
server = None
players = []
def __init__(self, _parent):
super().__init__(_parent)
self.setLayout(QHBoxLayout())
self.server = QTcpServer(self)
if self.server.listen(port=4223) is False:
print("Error starting the server!")
return
self.server.newConnection.connect(self.handleNewConnection)
def getIDFromSocket(self, socket):
ipadd = socket.peerAddress().toString()
splited = ipadd.split(".")
return int(splited[len(splited)-1])
@pyqtSlot()
def handleNewConnection(self):
newSock = self.server.nextPendingConnection()
if(newSock is not None):
newID = self.getIDFromSocket(newSock)
for player in self.players:
if self.getIDFromSocket(player.client.sock) == newID:
player.client.attachSock(newSock)
return
newPlayer = GPlayer(newSock, newID)
self.players.append(newPlayer)
self.layout().addWidget(newPlayer)
def __init__(self):
super().__init__()
self.tcpServer = QTcpServer(self)
address = QHostAddress('127.0.0.1')
self.tcpServer.listen(address, PORT)
self.tcpServer.newConnection.connect(self.dealCommunication)
print("[SERVER] Listening on port-", PORT, "...")
class Server(QObject):
def __init__(self, parent: QObject = None):
super().__init__(parent)
self.m_server = QTcpServer()
self.m_server.newConnection.connect(self.handleNewConnection)
@pyqtSlot()
def run(self):
if not self.m_server.listen(QHostAddress.LocalHost, 5555):
print(
f"Could not start the server -> http/proxy authentication dialog will not work. Error:{self.m_server.errorString()}"
)
@pyqtSlot()
def handleNewConnection(self):
socket = self.m_server.nextPendingConnection()
socket.disconnected.connect(socket.deleteLater)
socket.readyRead.connect(self.handleReadReady)
@pyqtSlot()
def handleReadReady(self):
socket = self.sender()
assert socket
msg = socket.readAll()
if msg.contains(b"OPEN_AUTH"):
socket.write(b"HTTP/1.1 401 Unauthorized\nWWW-Authenticate: "
b'Basic realm="Very Restricted Area"\r\n\r\n')
if msg.contains(b"OPEN_PROXY"):
socket.write(
b"HTTP/1.1 407 Proxy Auth Required\nProxy-Authenticate: "
b'Basic realm="Proxy requires authentication"\r\n\r\n')
class cServer(QTcpSocket):
finished = QtCore.pyqtSignal()
newData = QtCore.pyqtSignal(str)
running = False
def __init__(self):
super().__init__()
self.tcpServer = QTcpServer(self)
PORT = 9999
address = QHostAddress('127.0.0.1')
self.tcpServer.listen(address, PORT)
self.tcpServer.newConnection.connect(self.dealCommunication)
print("[SERVER] Listening on port-", PORT, "...")
def dealCommunication(self):
print("[SERVER] Client is connecting...")
client = self.tcpServer.nextPendingConnection()
msg = str(client.readAll(),encoding='utf-8')
self.newData.emit(msg)
def run(self):
self.running = True
while self.running:
QtCore.QCoreApplication.processEvents()
print("[SERVER] Terminated!")
def stop(self):
self.running = False
self.finished.emit()
def __init__(self):
self.local_server = QTcpServer()
self.local_server.newConnection.connect(self._handle_connection)
increment = 0
while (available := self.local_server.listen(port=DEFAULT_LOCAL_PORT +
increment)) is False:
increment += 1
def __init__(self, parent=None):
super(ListenPipe, self).__init__(parent=parent)
self.tcpServer = QTcpServer()
self.socketClients = []
self.tcpServer.newConnection.connect(self.on_newconnection)
class TcpServer():
def __init__(self):
self.tcp_server = QTcpServer()
self.tcp_server.listen(QHostAddress(SERVER_ADDRESS), SERVER_PORT)
self.tcp_server.newConnection.connect(self.connect_client)
self.clients = []
def connect_client(self):
client_socket = self.tcp_server.nextPendingConnection()
self.clients.append(client_socket)
client_socket.readyRead.connect(self.read_data)
def read_data(self):
for client_id, client_socket in enumerate(self.clients):
if client_socket.bytesAvailable() > 0:
stream = QDataStream(client_socket)
stream.setVersion(QDataStream.Qt_5_9)
stream.readUInt32()
client_data = stream.readQString()
self.return_data_to_clients(client_id, client_data)
def return_data_to_clients(self, client_id, data):
for client_socket in self.clients:
return_data_string = 'Client {} sent: {}'.format(client_id, data)
data_byte_array = QByteArray()
stream = QDataStream(data_byte_array, QIODevice.WriteOnly)
stream.setVersion(QDataStream.Qt_5_9)
stream.writeUInt32(0)
stream.writeQString(return_data_string)
client_socket.write(data_byte_array)
class MainApp(QCoreApplication):
def __init__(self, argv):
super().__init__(argv)
self.server = QTcpServer(self)
self.server.setMaxPendingConnections(1)
self.server.newConnection.connect(self.onNewConnection)
self.server.listen(QHostAddress.Any, 6666)
self.client = QTcpSocket(self)
self.cap = cv2.VideoCapture(0)
@pyqtSlot()
def onNewConnection(self):
self.client = self.server.nextPendingConnection()
self.client.disconnected.connect(self.onClientDisconnected)
self.client.readyRead.connect(self.onClientReadyRead)
print('connected')
@pyqtSlot()
def onClientDisconnected(self):
print('disconnected')
@pyqtSlot()
def onClientReadyRead(self):
while self.client.canReadLine():
line = self.client.readLine()[:-1]
if 'get' == line:
ret, frame = self.cap.read()
data = cv2.imencode('.jpg', frame)[1]
self.client.writeData((str(len(data)) + '\n').encode())
self.client.writeData(data)
class Server(QDialog):
def __init__(self):
super().__init__()
self.tcpServer = None
self.signals = ServerSignals()
self.clientConnection = None
def sessionOpened(self):
self.tcpServer = QTcpServer(self)
PORT = 65432
address = QHostAddress('127.0.0.1')
if not self.tcpServer.listen(address, PORT):
print("cant listen!")
self.close()
return
self.tcpServer.newConnection.connect(self.dealCommunication)
@pyqtSlot()
def dealCommunication(self):
# Get a QTcpSocket from the QTcpServer
self.clientConnection = self.tcpServer.nextPendingConnection()
# wait until the connection is ready to read
self.clientConnection.waitForReadyRead()
# read incomming data
instr = self.clientConnection.readAll()
# raise signal with message
tomaingui = str(instr, encoding='utf-8')
self.signals.msg.emit(tomaingui)
# def sendtoclient(self, msg):
# # OLD Might be deleted in next version
#
# # instantiate a QByteArray
# block = QByteArray()
# out = QDataStream(block, QIODevice.ReadWrite)
# out.setVersion(QDataStream.Qt_5_0)
#
# # this is the message we will send it could come from a widget.
# message = msg + '\n'
# # message = msg
# message = bytes(message, encoding='utf-8')
# # now use the QDataStream and write the byte array to it.
# out.writeString(message)
# out.device().seek(0)
# out.writeUInt16(block.size() - 2)
#
# # get the connection ready for clean up
# self.clientConnection.disconnected.connect(self.clientConnection.deleteLater)
# # now send the QByteArray.
# self.clientConnection.write(block)
# # now disconnect connection.
# self.clientConnection.disconnectFromHost()
def sendeasy(self, msg):
message = msg + '\n'
out = bytes(message, 'utf-8')
self.clientConnection.write(out)
self.clientConnection.disconnectFromHost()
def __init__(self, argv):
super().__init__(argv)
self.server = QTcpServer(self)
self.server.setMaxPendingConnections(1)
self.server.newConnection.connect(self.onNewConnection)
self.server.listen(QHostAddress.Any, 6666)
self.client = QTcpSocket(self)
self.cap = cv2.VideoCapture(0)
def __init__(self, _parent):
super().__init__(_parent)
self.setLayout(QHBoxLayout())
self.server = QTcpServer(self)
if self.server.listen(port=4223) is False:
print("Error starting the server!")
return
self.server.newConnection.connect(self.handleNewConnection)
def openController(self):
self.isUp = True
self.ui.btClose.setText('关机')
self.timer.start(self.req_sta_inter)
self.server = QTcpServer()
self.server.listen(self.serverIP, self.port)
self.server.newConnection.connect(self.addClient2List)
class Server(QWidget):
def __init__(self, model, prediction, vocabulary):
super(Server, self).__init__()
self.model = model
self.prediction = prediction
self.vocabulary = vocabulary
self.resize(500, 450)
# 1
self.browser = QTextBrowser(self)
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.browser)
self.setLayout(self.v_layout)
# 2
self.server = QTcpServer(self)
if not self.server.listen(QHostAddress.LocalHost, 8080):
self.browser.append(self.server.errorString())
self.server.newConnection.connect(self.new_socket_slot)
def new_socket_slot(self):
sock = self.server.nextPendingConnection()
peer_address = sock.peerAddress().toString()
peer_port = sock.peerPort()
news = 'Connected with address {}, port{}'.format(
peer_address, str(peer_port))
self.browser.append(news)
sock.readyRead.connect(lambda: self.read_data_slot(sock))
sock.disconnected.connect(lambda: self.disconnected_slot(sock))
# 3
def read_data_slot(self, sock):
while sock.bytesAvailable():
datagram = sock.read(sock.bytesAvailable())
message = datagram.decode()
answer = self.get_answer(message).encode()
sock.write(bytes(answer))
def get_answer(self, message):
sentence = pre_dosegment(message)
sentence = ' '.join(sentence)
prediction1 = self.model.test(str(sentence), self.vocabulary)
query = match_question(prediction1, str(message))
answer = self.prediction.run(query, prediction1)
return answer
# 4
def disconnected_slot(self, sock):
peer_address = sock.peerAddress().toString()
peer_port = sock.peerPort()
news = 'Disconnected with address {}, port {}'.format(
peer_address, str(peer_port))
self.browser.append(news)
sock.close()
def sessionOpened(self):
self.tcpServer = QTcpServer(self)
PORT = 65432
address = QHostAddress('127.0.0.1')
if not self.tcpServer.listen(address, PORT):
print("cant listen!")
self.close()
return
self.tcpServer.newConnection.connect(self.dealCommunication)
def __init__(self):
"""Constructor."""
QObject.__init__(self)
self.__tcpServer = QTcpServer()
self.__active_sockets = []
self.__tcpServer.newConnection.connect(self.__new_connection)
def __init__(self, parent=None):
super(Server, self).__init__(parent)
self.proxy_server = QTcpServer(self)
self.proxy_server.listen(QHostAddress.Any, 8000)
self.proxy_server.newConnection.connect(self.manage_request)
if self.debug:
self.log.write('Server running on localhost port %s\n\n' %
self.port())
def sessionOpened(self, port=8000):
self.tcpServer = QTcpServer(self)
address = QHostAddress('127.0.0.1')
if not self.tcpServer.listen(address, port):
print("cant listen!")
self.close()
return
print("Server Ready")
self.tcpServer.newConnection.connect(self.dealCommunication)
def sessionOpened(self):
self.tcpServer = QTcpServer(self)
PORT = 8000
address = QHostAddress(
self.ip) # e.g. use your server ip 192.144.178.26
if not self.tcpServer.listen(address, PORT):
print("cant listen!")
self.close()
return
self.tcpServer.newConnection.connect(self.serverInputCommunication)
def openRoom(self):
self.ui.openBtn.setText('Close Chat Room')
self.isUp = True
self.ui.serverIPLineEdit.setEnabled(False)
self.ui.portLineEdit.setEnabled(False)
self.tcpServer = QTcpServer()
self.tcpServer.listen(self.serverIP, self.port)
msg = '[*] Server is listening on {}:{} ........'.format(self.serverIP.toString(), self.port)
self.ui.contentListWidget.addItem(msg)
self.tcpServer.newConnection.connect(self.addClient2List)
def __init__(self, port, shell_variables=None):
self.logger = logging.getLogger(self.__class__.__name__)
self.tcp_server = QTcpServer()
self.sockets = []
self.stack_trace = None
if not self.tcp_server.listen(port=port):
self.logger.error("Unable to start code execution socket! Error: %s", self.tcp_server.errorString())
else:
connect(self.tcp_server.newConnection, self._on_new_connection)
self.shell = Console(locals=shell_variables or {}, logger=self.logger)
def __init__(self):
super(TcpServer, self).__init__()
self.ui = Ui_Form()
self.ui.setupUi(self)
self.tcpServer = QTcpServer(self) #指定父对象自动回收空间 监听套接字
self.tcpSocket = QTcpSocket(self) #通信套接字
self.tcpServer.listen(QHostAddress.Any, 8888) #any默认绑定当前网卡的所有IP
self.tcpServer.newConnection.connect(self.handleNewConnection)
self.ui.sendButton.clicked.connect(self.sendMessage)
self.ui.closeButton.clicked.connect(self.closeConnect)
def __init__(self, parent=None):
super().__init__(parent)
# Das Zeichenfeld muss den Focus für KeyPress-Events erhalten.
self.setFocusPolicy(Qt.StrongFocus)
# Wir laden eine png-Datei (mit Transparenz) und skalieren das Bild
# auf die gewünschte Größe.
self.background_tex = QImage("Ground.png")
self.players_tex = [
QImage("panzer_0.png"),
QImage("panzer_1.png"),
QImage("panzer_2.png")
]
self.explosion_sprites = [
QImage("000" + str(i) + ".png") for i in range(1, 10)
] + [QImage("00" + str(i) + ".png") for i in range(10, 51)]
self.main = parent
self.lebendig = True
self.alive = False
self.point = QPoint(0, 0)
self.pointl = QPoint(0, 0)
self.balls = []
self.ballsize = 15
self.image = QImage('Pacman.png').scaled(100, 100)
self.x = 100
self.y = 100
self.velx = 0
self.vely = 0
self.winkel = 0
self.winkelnext = 0
self.players = []
self.score1 = 0
self.score2 = 0
self.level_id = 0
self.wallscoordinates = []
self.walls = []
self.wallsbuild = False
self.run = True
self.ups = 60
self.connected = False
self.timer = QTimer()
# Wir richten einen Server ein, zu dem Clients einen Kommunikationskanal
# öffnen können.
self.tcpServer = QTcpServer(self)
# Der Server akzeptiert jeden Client, der auf der angegebenen Port-Nummer
# sendet.
self.tcpServer.listen(QHostAddress.Any, 40890)
# self.tcpServer.listen(QHostAddress('127.0.0.1'), 40890)
# Falls beim Server eine Verbindungsanfrage von einem Client eingeht,
# soll die eigene Memberfunktion connectToClient aufgerufen werden.
self.tcpServer.newConnection.connect(self.connectToClient)
def openMachine(self):
self.isUp = True
self.ui.btCold.setEnabled(True)
self.ui.btWarm.setEnabled(True)
self.ui.spRefFre.setEnabled(True)
self.ui.spSendFre.setEnabled(True)
self.ui.btClose.setText('关机')
self.server = QTcpServer()
self.server.listen(self.serverIP, self.port)
self.server.newConnection.connect(self.newClient)
self.sendStateTimer.start(self.sendInterval)
self.refTableTimer.start(self.refInterval)
def __init__(self, parent=None):
super(DataReceive, self).__init__(parent)
self.tcpServer = QTcpServer(self)
if self.tcpServer.listen(QHostAddress("127.0.0.1"), 8890):
self.tcpServer.newConnection.connect(self.sendMessage)
self.tcpServerConnection = None
print('init done')
self.index = 0
self.data_size = 0
self.message = None
self.image = None
def __init__(self, gui):
SessionManager.__init__(self, gui)
self.session_type = SessionType.TEACHER
self.gui = gui
self.session_ticker = Ticker(self.tickSessionOnce, parent=gui)
self.simulation_paused_at = None # pause time if session is paused; None otherwise
self.server = QTcpServer(gui)
self.student_socket = None
self.server.newConnection.connect(self.studentConnects)
self.aircraft_list = [] # ControlledAircraft list
self.current_local_weather = None # initialised by the teaching console on sessionStarted
self.noACK_traffic_count = 0
def runReceiver(self, hostAddress: str):
if not self.__server:
self.__server = QTcpServer(self)
self.__server.acceptError.connect(self.__error)
if not self.__server.listen(
QHostAddress(hostAddress),
self.__serverPort) and not self.isListening():
print("RECEIVER NOT STARTED", self.__server.errorString())
else:
self.__server.newConnection.connect(self.__newConnection)
self.__incomingConnectionsAddress = hostAddress
self.__incomingConnectionsPort = self.__serverPort
print("RECEIVER STARTED")
def initServer(self):
"""
网络设置初始化
"""
self.tcpPort = 7788
self.tcpServer = QTcpServer(self)
self.clientConnection = QTcpSocket(self)
self.tcpServer.newConnection.connect(self.sendMessage)
self.serverStatuslabel.setText("请选择要传送的文件")
self.progressBar.reset()
self.serverOpenBtn.setEnabled(True)
self.serverSendBtn.setEnabled(False)
self.tcpServer.close()
def sessionOpened(self):
if self.networkSession is not None:
config = self.networkSession.configuration()
if config.type() == QNetworkConfiguration.UserChoice:
id = self.networkSession.sessionProperty('UserChoiceConfiguration')
else:
id = config.identifier()
settings = QSettings(QSettings.UserScope, 'QtProject')
settings.beginGroup('QtNetwork')
settings.setValue('DefaultNetworkConfiguration', id)
settings.endGroup();
self.tcpServer = QTcpServer(self)
if not self.tcpServer.listen():
QMessageBox.critical(self, "Fortune Server",
"Unable to start the server: %s." % self.tcpServer.errorString())
self.close()
return
for ipAddress in QNetworkInterface.allAddresses():
if ipAddress != QHostAddress.LocalHost and ipAddress.toIPv4Address() != 0:
break
else:
ipAddress = QHostAddress(QHostAddress.LocalHost)
ipAddress = ipAddress.toString()
self.statusLabel.setText("The server is running on\n\nIP: %s\nport %d\n\n"
"Run the Fortune Client example now." % (ipAddress, self.tcpServer.serverPort()))
def __init__(self, port, shell_variables={}):
self.logger = logging.getLogger(self.__class__.__name__)
self.tcp_server = QTcpServer()
self.sockets = []
self.stack_trace = None
if not self.tcp_server.listen(port=port):
self.logger.error("Unable to start code execution socket! Error: %s", self.tcp_server.errorString())
else:
self.tcp_server.newConnection.connect(self._on_new_connection)
self.shell = Console(locals=shell_variables)
def _onPushButton_Openserver_Clicked(self):
print("start socker at ",self.port)
if self.serveropened is False:
#start init qtcpserver
self.tcpServer = QTcpServer(self)
address = QHostAddress('0.0.0.0')
if not self.tcpServer.listen(address, self.port):
print("cant listen!")
self.close()
return
self.tcpServer.newConnection.connect(self.dealCommunication)
self.fillActivateIps()
class TcpServer(QObject):
def __init__(self):
super(TcpServer, self).__init__()
self.server = QTcpServer()
self.server.newConnection.connect(self.incomingConnection)
@pyqtSlot()
def incomingConnection(self):
self.client = TcpClient(self.server.nextPendingConnection())
self.client.parse_data = self.parse_data
def start(self):
if self.server.listen(QHostAddress.Any, 8888):
print "Tcp server started"
else:
print "Error starting Tcp server"
def parse_data(self, data):
print 'Server: ', str(data).strip()
def moveToThread(self, target_thread):
self.server.moveToThread(target_thread)
super(TcpServer, self).moveToThread(target_thread)
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.cam = webcam(640, 480, '/dev/video0')
self.cam.activate()
self.statusLabel = QLabel()
self.quitButton = QPushButton("Quit")
self.quitButton.setAutoDefault(False)
buttonLayout = QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(self.quitButton)
buttonLayout.addStretch(1)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle('Frame Server')
self.tcpServer = QTcpServer(self)
self.tcpServer.listen()
self.client = None
ipAddress = ''
for address in QNetworkInterface.allAddresses():
if address != QHostAddress.LocalHost and address.toIPv4Address():
ipAddress = address.toString()
break
if len(ipAddress) == 0:
ipAddress = QHostAddress(QHostAddress.LocalHost).toString()
self.statusLabel.setText(
'Address:\t\t{}\nPort:\t\t\t{}'.format(ipAddress, self.tcpServer.serverPort()))
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.clientConnected)
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.tcpServer = QTcpServer()
self.tcpClient = QTcpSocket()
self.bytesToWrite = 0
self.bytesWritten = 0
self.bytesReceived = 0
self.clientProgressBar = QProgressBar()
self.clientStatusLabel = QLabel("Client ready")
self.serverProgressBar = QProgressBar()
self.serverStatusLabel = QLabel("Server ready")
self.startButton = QPushButton("&Start")
self.quitButton = QPushButton("&Quit")
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.startButton.clicked.connect(self.start)
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.acceptConnection)
self.tcpClient.connected.connect(self.startTransfer)
self.tcpClient.bytesWritten.connect(self.updateClientProgress)
self.tcpClient.error.connect(self.displayError)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.clientProgressBar)
mainLayout.addWidget(self.clientStatusLabel)
mainLayout.addWidget(self.serverProgressBar)
mainLayout.addWidget(self.serverStatusLabel)
mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Loopback")
class Server(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.cam = webcam(640, 480, '/dev/video0')
self.cam.activate()
self.statusLabel = QLabel()
self.quitButton = QPushButton("Quit")
self.quitButton.setAutoDefault(False)
buttonLayout = QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(self.quitButton)
buttonLayout.addStretch(1)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle('Frame Server')
self.tcpServer = QTcpServer(self)
self.tcpServer.listen()
self.client = None
ipAddress = ''
for address in QNetworkInterface.allAddresses():
if address != QHostAddress.LocalHost and address.toIPv4Address():
ipAddress = address.toString()
break
if len(ipAddress) == 0:
ipAddress = QHostAddress(QHostAddress.LocalHost).toString()
self.statusLabel.setText(
'Address:\t\t{}\nPort:\t\t\t{}'.format(ipAddress, self.tcpServer.serverPort()))
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.clientConnected)
def clientConnected(self):
self.client = self.tcpServer.nextPendingConnection()
self.client.disconnected.connect(self.client.deleteLater)
self.client.disconnected.connect(self.clientDisconnected)
self.client.readyRead.connect(self.sendFrame)
self.client.readyRead.connect(self.client.readAll)
self.client.setReadBufferSize(32)
self.tcpServer.pauseAccepting()
def clientDisconnected(self):
self.client = None
self.tcpServer.resumeAccepting()
def sendFrame(self):
block = QByteArray()
out = QDataStream(block, QIODevice.WriteOnly)
out.setVersion(QDataStream.Qt_5_0)
frame = huffman.encode(self.cam.capture())
out.writeInt32(len(frame))
out.writeRawData(frame)
self.client.write(block)
class Dialog(QDialog):
TotalBytes = 50 * 1024 * 1024
PayloadSize = 65536
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.tcpServer = QTcpServer()
self.tcpClient = QTcpSocket()
self.bytesToWrite = 0
self.bytesWritten = 0
self.bytesReceived = 0
self.clientProgressBar = QProgressBar()
self.clientStatusLabel = QLabel("Client ready")
self.serverProgressBar = QProgressBar()
self.serverStatusLabel = QLabel("Server ready")
self.startButton = QPushButton("&Start")
self.quitButton = QPushButton("&Quit")
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.startButton.clicked.connect(self.start)
self.quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.acceptConnection)
self.tcpClient.connected.connect(self.startTransfer)
self.tcpClient.bytesWritten.connect(self.updateClientProgress)
self.tcpClient.error.connect(self.displayError)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.clientProgressBar)
mainLayout.addWidget(self.clientStatusLabel)
mainLayout.addWidget(self.serverProgressBar)
mainLayout.addWidget(self.serverStatusLabel)
mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Loopback")
def start(self):
self.startButton.setEnabled(False)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.bytesWritten = 0
self.bytesReceived = 0
while not self.tcpServer.isListening() and not self.tcpServer.listen():
ret = QMessageBox.critical(self, "Loopback",
"Unable to start the test: %s." % self.tcpServer.errorString(),
QMessageBox.Retry | QMessageBox.Cancel)
if ret == QMessageBox.Cancel:
return
self.serverStatusLabel.setText("Listening")
self.clientStatusLabel.setText("Connecting")
self.tcpClient.connectToHost(QHostAddress(QHostAddress.LocalHost), self.tcpServer.serverPort())
def acceptConnection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
self.tcpServerConnection.readyRead.connect(self.updateServerProgress)
self.tcpServerConnection.error.connect(self.displayError)
self.serverStatusLabel.setText("Accepted connection")
self.tcpServer.close()
def startTransfer(self):
self.bytesToWrite = Dialog.TotalBytes - self.tcpClient.write(QByteArray(Dialog.PayloadSize, '@'))
self.clientStatusLabel.setText("Connected")
def updateServerProgress(self):
self.bytesReceived += self.tcpServerConnection.bytesAvailable()
self.tcpServerConnection.readAll()
self.serverProgressBar.setMaximum(Dialog.TotalBytes)
self.serverProgressBar.setValue(self.bytesReceived)
self.serverStatusLabel.setText("Received %dMB" % (self.bytesReceived / (1024 * 1024)))
if self.bytesReceived == Dialog.TotalBytes:
self.tcpServerConnection.close()
self.startButton.setEnabled(True)
QApplication.restoreOverrideCursor()
def updateClientProgress(self, numBytes):
self.bytesWritten += numBytes
if self.bytesToWrite > 0:
self.bytesToWrite -= self.tcpClient.write(QByteArray(
min(self.bytesToWrite, Dialog.PayloadSize), '@'))
self.clientProgressBar.setMaximum(Dialog.TotalBytes)
self.clientProgressBar.setValue(self.bytesWritten)
self.clientStatusLabel.setText("Sent %dMB" % (self.bytesWritten / (1024 * 1024)))
def displayError(self, socketError):
if socketError == QTcpSocket.RemoteHostClosedError:
return
QMessageBox.information(self, "Network error",
"The following error occured: %s." % self.tcpClient.errorString())
self.tcpClient.close()
self.tcpServer.close()
self.clientProgressBar.reset()
self.serverProgressBar.reset()
self.clientStatusLabel.setText("Client ready")
self.serverStatusLabel.setText("Server ready")
self.startButton.setEnabled(True)
QApplication.restoreOverrideCursor()
def __init__(self):
super(TcpServer, self).__init__()
self.server = QTcpServer()
self.server.newConnection.connect(self.incomingConnection)
class Server(QDialog):
FORTUNES = (
"You've been leading a dog's life. Stay off the furniture.",
"You've got to think about tomorrow.",
"You will be surprised by a loud noise.",
"You will feel hungry again in another hour.",
"You might have mail.",
"You cannot kill time without injuring eternity.",
"Computers are not intelligent. They only think they are.")
def __init__(self, parent=None):
super(Server, self).__init__(parent)
self.tcpServer = None
self.networkSession = None
self.statusLabel = QLabel()
quitButton = QPushButton("Quit")
quitButton.setAutoDefault(False)
manager = QNetworkConfigurationManager()
if manager.capabilities() & QNetworkConfigurationManager.NetworkSessionRequired:
settings = QSettings(QSettings.UserScope, 'QtProject')
settings.beginGroup('QtNetwork')
id = settings.value('DefaultNetworkConfiguration', '')
settings.endGroup()
config = manager.configurationFromIdentifier(id)
if config.state() & QNetworkConfiguration.Discovered == 0:
config = manager.defaultConfiguration()
self.networkSession = QNetworkSession(config, self)
self.networkSession.opened.connect(self.sessionOpened)
self.statusLabel.setText("Opening network session.")
self.networkSession.open()
else:
self.sessionOpened()
quitButton.clicked.connect(self.close)
self.tcpServer.newConnection.connect(self.sendFortune)
buttonLayout = QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(quitButton)
buttonLayout.addStretch(1)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.statusLabel)
mainLayout.addLayout(buttonLayout)
self.setLayout(mainLayout)
self.setWindowTitle("Fortune Server")
def sessionOpened(self):
if self.networkSession is not None:
config = self.networkSession.configuration()
if config.type() == QNetworkConfiguration.UserChoice:
id = self.networkSession.sessionProperty('UserChoiceConfiguration')
else:
id = config.identifier()
settings = QSettings(QSettings.UserScope, 'QtProject')
settings.beginGroup('QtNetwork')
settings.setValue('DefaultNetworkConfiguration', id)
settings.endGroup();
self.tcpServer = QTcpServer(self)
if not self.tcpServer.listen():
QMessageBox.critical(self, "Fortune Server",
"Unable to start the server: %s." % self.tcpServer.errorString())
self.close()
return
for ipAddress in QNetworkInterface.allAddresses():
if ipAddress != QHostAddress.LocalHost and ipAddress.toIPv4Address() != 0:
break
else:
ipAddress = QHostAddress(QHostAddress.LocalHost)
ipAddress = ipAddress.toString()
self.statusLabel.setText("The server is running on\n\nIP: %s\nport %d\n\n"
"Run the Fortune Client example now." % (ipAddress, self.tcpServer.serverPort()))
def sendFortune(self):
fortune = self.FORTUNES[random.randint(0, len(self.FORTUNES) - 1)]
block = QByteArray()
out = QDataStream(block, QIODevice.WriteOnly)
out.setVersion(QDataStream.Qt_4_0)
out.writeUInt16(0)
out.writeQString(fortune)
out.device().seek(0)
out.writeUInt16(block.size() - 2)
clientConnection = self.tcpServer.nextPendingConnection()
clientConnection.disconnected.connect(clientConnection.deleteLater)
clientConnection.write(block)
clientConnection.disconnectFromHost()
class TestTransact(XWidget, Ui_Form):
def __init__(self):
super(TestTransact, self).__init__()
self.setupUi(self)
try:
self._init_device_config()
self._init_terminal_operation()
self._init_online_parameters()
except Exception as e:
print("here exception")
self.exception(e)
# ********************************************** Init ****************************************************
def _init_device_config(self):
self.deviceconfig = DeviceConfig()
self.deviceconfig.print_signal.connect(self.print_signal)
self.layout_DeviceConfig.addWidget(self.deviceconfig)
def _init_terminal_operation(self):
self.port = 12345
self.serveropened = False
self._onPushButton_Openserver_Clicked()
def _init_online_parameters(self):
self.comboBox_AuthorizationResponseCode.addItems(['00:Approve', '51:Decline'])
self._issuerdata = ['']
try:
with open('script/transact/issuerdata', 'r') as fd:
for line in fd.readlines():
line = line.replace('\n', '').replace('\r', '')
self._issuerdata.append(line)
fd.close()
except Exception as e:
self.exception(e)
self.comboBox_IssuerAppData.addItems(self._issuerdata)
def showEvent(self, QShowEvent):
try:
if self.config.get('comboBox_AuthorizationResponseCode'):
self.comboBox_AuthorizationResponseCode.setCurrentText(self.config['comboBox_AuthorizationResponseCode'])
if self.config.get('comboBox_IssuerAppData'):
self.comboBox_IssuerAppData.setCurrentText(self.config['comboBox_IssuerAppData'])
except Exception as e:
self.exception(e)
super().showEvent(QShowEvent)
def hideEvent(self, QHideEvent):
try:
self.config['comboBox_AuthorizationResponseCode'] = self.comboBox_AuthorizationResponseCode.currentText()
self.config['comboBox_IssuerAppData'] = self.comboBox_IssuerAppData.currentText()
except Exception as e:
self.exception(e)
super().hideEvent(QHideEvent)
# ********************************************** Slot ****************************************************
def _onPushButton_Openserver_Clicked(self):
print("start socker at ",self.port)
if self.serveropened is False:
#start init qtcpserver
self.tcpServer = QTcpServer(self)
address = QHostAddress('0.0.0.0')
if not self.tcpServer.listen(address, self.port):
print("cant listen!")
self.close()
return
self.tcpServer.newConnection.connect(self.dealCommunication)
self.fillActivateIps()
def dealCommunication(self):
# Get a QTcpSocket from the QTcpServer
print("start handle")
self.print_signal.emit("info", "connected")
self.tcpSocket = self.tcpServer.nextPendingConnection()
#first read
self.tcpSocket.readyRead.connect(self.showMessage)
self.tcpSocket.disconnected.connect(self.showDisconnect)
def showMessage(self):
print ("start read show message")
self.tcpSocket.readAll()
#construct return data here
origstr = self.comboBox_IssuerAppData.currentText()
lenofstr = int(len(origstr) / 2)
origstr2 = self.comboBox_AuthorizationResponseCode.currentText()
finalstr = "8A02{:02}{:02}91{:02X}{}".format(int(origstr2[0]) + 30, int(origstr2[1])+30, lenofstr, origstr)
print("return:", finalstr)
self.tcpSocket.write(finalstr.encode("utf-8"))
def showDisconnect(self):
self.print_signal.emit("info", "disconnected")
def fillActivateIps(self):
print("start fill")
for interface in QNetworkInterface.allInterfaces():
iflags = interface.flags()
if (iflags & QNetworkInterface.IsRunning) and not (iflags & QNetworkInterface.IsLoopBack) :
for addrentry in interface.addressEntries():
# print("append ",addrentry.ip().toString(),addrentry.ip().protocol())
if addrentry.ip().protocol() == QAbstractSocket.IPv4Protocol:
self.plainTextEdit_iplist.appendPlainText("{}:{}".format(addrentry.ip().toString(), self.port))
class CodeExecutor(object):
"""
This class is responsible for executing code (when starting Tribler in debug mode).
The protocol to execute code is as follows.
First, a client that wants to execute some code opens a connection with the TCP server and sends the
string: <code in base64 format> <task_id>\n
This code will be executed and the result will be sent to the client in the following format:
result <result> <task_id>\n.
If Tribler crashes, the server sends the following result: crash <stack trace in base64 format>
Note that the socket uses the newline as separator.
"""
def __init__(self, port, shell_variables={}):
self.logger = logging.getLogger(self.__class__.__name__)
self.tcp_server = QTcpServer()
self.sockets = []
self.stack_trace = None
if not self.tcp_server.listen(port=port):
self.logger.error("Unable to start code execution socket! Error: %s", self.tcp_server.errorString())
else:
self.tcp_server.newConnection.connect(self._on_new_connection)
self.shell = Console(locals=shell_variables)
def _on_new_connection(self):
while self.tcp_server.hasPendingConnections():
socket = self.tcp_server.nextPendingConnection()
socket.readyRead.connect(self._on_socket_read_ready)
socket.disconnected.connect(lambda dc_socket=socket: self._on_socket_disconnect(dc_socket))
self.sockets.append(socket)
# If Tribler has crashed, notify the other side immediately
if self.stack_trace:
self.on_crash(self.stack_trace)
def run_code(self, code, task_id):
self.shell.runcode(code)
stdout = self.shell.stdout.read()
stderr = self.shell.stderr.read()
self.logger.info("Code execution with task %s finished:", task_id)
self.logger.info("Stdout of task %s: %s", task_id, stdout)
if 'Traceback' in stderr and 'SystemExit' not in stderr:
self.logger.error("Executed code with failure: %s", b64encode(code))
# Determine the return value
if 'return_value' not in self.shell.console.locals:
return_value = ''.encode('base64')
else:
return_value = str(self.shell.console.locals['return_value']).encode('base64')
for socket in self.sockets:
socket.write("result %s %s\n" % (return_value, task_id))
def on_crash(self, exception_text):
self.stack_trace = exception_text
for socket in self.sockets:
socket.write("crash %s\n" % exception_text.encode('base64'))
def _on_socket_read_ready(self):
data = str(self.sockets[0].readAll())
parts = data.split(" ")
if len(parts) != 2:
return
try:
code = parts[0].decode('base64')
task_id = parts[1].replace('\n', '')
self.run_code(code, task_id)
except binascii.Error:
self.logger.error("Invalid base64 code string received!")
def _on_socket_disconnect(self, socket):
self.sockets.remove(socket)
def isAvailable(port):
server = QTcpServer()
result = server.listen(QHostAddress("127.0.0.1"), port)
server.close()
return result