def __init__(self, parent=None): super(ServerDlg, self).__init__("&Close Server", parent) self.setWindowFlags(QC.Qt.WindowStaysOnTopHint) self.tcpServer = QN.QTcpServer(self) #Zjistím si svojí IP adresu for address in QN.QNetworkInterface.allAddresses(): if address != QN.QHostAddress.LocalHost and address.toIPv4Address( ): break else: address = QN.QHostAddress.LocalHost #print(address.toString()) self.tcpServer.listen(QN.QHostAddress("0.0.0.0"), PORT) #Any address self.tcpServer.newConnection.connect(self.addConnection) self.connections = [None for _ in range(6)] self.connectionAddress = [None for _ in range(6)] self.players = {} self.clicked.connect(self.close) font = self.font() font.setPointSize(24) self.setFont(font) self.setWindowTitle("Server")
def __init__(self): """Initialize""" super().__init__() self.server = qtn.QTcpServer() self.sock = qtn.QTcpSocket(self.server) # if self.server.listen(qtn.QHostAddress(self.ip), self.s): if self.server.listen(qtn.QHostAddress.LocalHost, self.s): print( f'DATA SERVER:\n\tAddress: {self.server.serverAddress().toString()}\n\tPort: {str(self.server.serverPort())}' ) else: print('ERROR!!!!') exit() self.server.newConnection.connect(self.__session) f = open('key.bin', 'rb') self.key = f.read() f.close() self.f = Fernet(self.key) del self.key # set your properties self.db = mysql.connector.connect(host='localhost', user='******', passwd='password', database='login_data', auth_plugin='mysql_native_password') self.mycursor = self.db.cursor()
def test_addConnection_2(): app.tcpServer = QtNetwork.QTcpServer(app) with mock.patch.object(app.tcpServer, 'nextPendingConnection', return_value=0): suc = app.addConnection() assert not suc
def connect_server(self): # Get the saved data from the settings file self.host = self.cfg_data.get_rpi_host() # Get the TCP connection host self.port = self.cfg_data.get_rpi_port() # Get the TCP connection port rem_stat = self.cfg_data.get_server_remote("TCPRPiServ") if rem_stat == "no": self.host = QtNetwork.QHostAddress.LocalHost elif rem_stat == "yes": for ip_address in QtNetwork.QNetworkInterface.allAddresses(): if ip_address != QtNetwork.QHostAddress.LocalHost and ip_address.toIPv4Address( ) != 0: break # If we found an IP then we exit the loop else: ip_address = QtNetwork.QHostAddress.LocalHost # If no IP is found, assign localhost self.host = ip_address # Assign the IP address that wa found above # TODO Add the ability to incorporate custom IP addresses self.tcp_server = QtNetwork.QTcpServer() # Create a server object self.tcp_server.newConnection.connect( self._new_connection) # Handler for a new connection self.tcp_server.listen(self.host, int( self.port)) # Start listening for connections self.conStatSigR.emit( "Waiting") # Indicate that the server is listening on the GUI self.logger.debug("RPI server connection initializer called")
def test_startCommunication_3(): app.tcpServer = None server = QtNetwork.QTcpServer(app) hostAddress = QtNetwork.QHostAddress('127.0.0.1') server.listen(hostAddress, 3490) suc = app.startCommunication() assert not suc
def run(self): '''This starts the thread running, but it must not be called directly, it must be started with Server.start() instead for it to be started in its own thread. If it is called directly then it will run in the thread in which it was called.''' self.debug = False self.lock = False for i in QtNetwork.QNetworkInterface.allAddresses(): print("Found Address:", i.toString()) if i != QtNetwork.QHostAddress.LocalHost and i.protocol() == QtNetwork.QAbstractSocket.IPv4Protocol: self.address = i break # This determines the IP adress of the server self.tcpServer = QtNetwork.QTcpServer(self) self.tcpServer.listen(QtNetwork.QHostAddress("0.0.0.0"), self.port) # Listen on all addreses on the specified port only self.tcpServer.newConnection.connect(self.addConnection) # Call self.addConnection whenever the server signals that there is a new inbound connection print("Server Initialised") self.constantTimer = QtCore.QTimer() self.constantTimer.timeout.connect(self.checkQueue) self.constantTimer.start(1) print("Server Checking Queue") # Integrate the checkQueue function into the QT event loop, with # a delay between calls of 1 millisecond self.receiveQueue.put({"action":"showAddress", "port":self.port, "address":self.address, "client":"thread"})
def __init__(self, scene_server_port): super(RescuersGui, self).__init__() self.port = scene_server_port self.rpm = rospy.get_param("/art/interface/projected_gui/rpm") self.xinput = "USBest Technology SiS HID Touch Controller" self.tcpServer = QtNetwork.QTcpServer(self) if not self.tcpServer.listen(port=self.port): rospy.logerr( 'Failed to start scene TCP server on port ' + str(self.port)) self.tcpServer.newConnection.connect(self.new_connection) self.connections = [] self.scene_timer = QtCore.QTimer() self.scene_timer.timeout.connect(self.send_to_clients_evt) self.scene_timer.start(1.0 / 15 * 1000) self.projectors = [ProjectorCalibrator("localhost")] rospy.loginfo("Waiting for projector nodes...") for proj in self.projectors: proj.wait_until_available() if not proj.is_calibrated(): rospy.loginfo("Starting calibration of projector: " + proj.proj_id) proj.calib_pub.publish(False) proj.calibrate(self.calibrated_cb) else: rospy.loginfo("Projector " + proj.proj_id + " already calibrated.") proj.calib_pub.publish(True)
def pick_free_port(): """ Picks a free port """ srv = QtNetwork.QTcpServer() srv.listen() port = srv.serverPort() srv.close() del srv return port
def serverIni(self): self.outLog('server initialize') self.serverSocket = QtNetwork.QTcpServer() if self.serverSocket.listen(QtNetwork.QHostAddress.Any, self.params['server']['port']): self.serverSocket.newConnection.connect(self.newConnection) else: exit(0) pass
def init_tcp(self, is_server, addr): if is_server: self.server = QtNetwork.QTcpServer(self) self.server.listen(QtNetwork.QHostAddress.Any, 8888) self.server.newConnection.connect(self.start_new_connection) else: self.socket = QtNetwork.QTcpSocket(self) self.socket.connectToHost(QtNetwork.QHostAddress(addr), 8888) self.socket.readyRead.connect(self.recv)
def autoDetectNetworkInterface(self): hostAddresses = [] interfaceFlags = QtNetwork.QNetworkInterface.IsUp | \ QtNetwork.QNetworkInterface.IsRunning # Grab all available interfaces allInterfaces = QtNetwork.QNetworkInterface.allInterfaces() for interface in allInterfaces: if ((interface.flags() & interfaceFlags == interfaceFlags) \ ):#and (interface.flags() & # QtNetwork.QNetworkInterface.IsLoopBack == 0)): addresses = interface.addressEntries() for address in addresses: if (address.ip().protocol() == QtNetwork.QAbstractSocket.IPv4Protocol) and \ address.ip() != ( QtNetwork.QHostAddress( QtNetwork.QHostAddress.LocalHost)): hostAddresses.append(address.ip()) # If there is more than one host address detected, # show error dialog if len(hostAddresses) > 1: alert = AlertDialog( "Network Error", "Could not auto detect network " "settings") alert.show() else: # only one IP address returned, try port 80 testServer = QtNetwork.QTcpServer(self) # Try to start a QTcpServer at hostAddress:80 # If the server starts, return those values as # detected values if testServer.listen(hostAddresses[0], 80): ipAddress = hostAddresses[0].toString() # populate server text boxes self.hostAddressTextBox.setText(ipAddress) self.hostPortTextBox.setText(str(80)) testServer.close() else: # Could not listen at detected IP address and # port 80. This may be because port 80 is # being used by another service, so let # QTcpServer pick the port. if testServer.listen(hostAddresses[0]): ipAddress = hostAddresses[0].toString() port = testServer.serverPort() # populate server text boxes self.hostAddressTextBox.setText(ipAddress) self.hostPortTextBox.setText(str(port)) testServer.close() else: # Can't auto detect network settings alert = AlertDialog( "Network Error", "Could not auto " "detect network " "settings") alert.show()
def startNotifier(self): if self.protocol() == 'unix': address = tempfile.mktemp(prefix="pmx") self.notifier = QtNetwork.QLocalServer(self) self.notifier.listen(address) else: self.notifier = QtNetwork.QTcpServer(self) self.notifier.listen() address = "%s:%d" % (self.notifier.serverAddress().toString(), self.notifier.serverPort()) self.notifier.newConnection.connect(self.on_notifier_newConnection) return address
def on_btnOpen_clicked(self): self.server = QtNetwork.QTcpServer() self.server.listen(QtNetwork.QHostAddress("0.0.0.0"), PORT) self.server.setObjectName("server") self.server.newConnection.connect(self.on_server_newConnection) self.totalsize = 0 self.bytereceived = 0 self.filename = "" self.inblock = QByteArray() self.on_bwr_update("open server begin receiving")
def __init__( self, parent, identifier_string, listener_address, port, timeout_ms=5000 ): super().__init__( parent ) #self.setAttribute(QtCore.Qt.WA_DeleteOnClose) self.timeout_ms = timeout_ms self.port_for_ping = int(port) self.active_connections = {} self.tcp_server = QtNetwork.QTcpServer() self.udp_socket = QtNetwork.QUdpSocket() self.identifier_string = identifier_string if not listener_address or listener_address == '': listener_address = QtNetwork.QHostAddress.AnyIPv4 if( not self.Listen_For_Replies( listener_address ) ): raise Exception( "Failed to find local network " + listener_address.toString() )
def __init__(self, username, recipient): super().__init__() self.username = username self.recipient = recipient self.listener = qtn.QTcpServer() self.listener.listen(qtn.QHostAddress.Any, self.port) self.listener.acceptError.connect(self.on_error) self.listener.newConnection.connect(self.on_connection) self.connections = [] self.client_socket = qtn.QTcpSocket() self.client_socket.error.connect(self.on_error)
def __init__(self, logger): super(SocketListener, self).__init__() self.logger = logger self.udpSocket = QtNetwork.QUdpSocket(self) self.udpSocket.bind(QtNetwork.QHostAddress.Any, 11211) self.udpSocket.readyRead.connect(self.readUdpSocket) self.tcpServer = QtNetwork.QTcpServer(self) self.tcpServer.listen(QtNetwork.QHostAddress.Any, 11211) self.tcpServer.newConnection.connect(self.tcpConnection) self.tcpConnection = None self.tcpData = b''
def __init__( self, parent, identifier_string, listener_address, port, timeout_ms=20000 ): super().__init__( parent ) #self.setAttribute(QtCore.Qt.WA_DeleteOnClose) self.timeout_ms = timeout_ms self.port_for_ping = int(port) self.active_connections = {} self.tcp_server = QtNetwork.QTcpServer() self.udp_socket = QtNetwork.QUdpSocket() self.identifier_string = identifier_string if( not self.Listen_For_Replies( listener_address ) ): if listener_address is None: raise Exception( "Failed to listen on default ip" ) else: raise Exception( "Failed to listen on ip " + listener_address.toString() )
def __init__(self, parent: QtCore.QObject = None): # Super call super(HTTP, self).__init__(parent=parent) # Internal attributes self._socket: QtNetwork.QTcpServer = QtNetwork.QTcpServer(parent=self) self._client: typing.Optional[QtNetwork.QTcpSocket] = None # Aliases qt_disconnect = super(HTTP, self).disconnect qt_connect = super(HTTP, self).connect # Internal calls self._socket.newConnection.connect(self.process_new_client) self._socket.acceptError.connect(self.process_connection_error) self._socket.setMaxPendingConnections(2)
def __init__(self, parent=None): super(ServerManager, self).__init__(parent) self._server = QtNetwork.QTcpServer(self) self._server.newConnection.connect(self.on_newConnection) self._clients = {} self._keyboards = { "454545": QtNetwork.QTcpSocket, "123123": QtNetwork.QTcpSocket } self._displays = {"456456": QtNetwork.QTcpSocket} self._distributors = {} self._counters = {"122": {"count": 5}, "123": {"count": 10}} self._client_type = { "0": "Keyboard", "1": "display", "2": "distributor" }
def test_addConnection_3(): class Test(QObject): nextBlockSize = 0 readyRead = pyqtSignal() disconnected = pyqtSignal() error = pyqtSignal() @staticmethod def peerAddress(): return Test() @staticmethod def toString(): return 'Test' app.tcpServer = QtNetwork.QTcpServer(app) with mock.patch.object(app.tcpServer, 'nextPendingConnection', return_value=Test()): suc = app.addConnection() assert suc
def connect_stellarium(self): # Get the saved data from the settings file self.host = self.cfg_data.get_stell_host() # Get the TCP connection host self.port = self.cfg_data.get_stell_port() # Get the TCP connection port if self.host == "localhost" or self.host == "127.0.0.1": self.host = QtNetwork.QHostAddress.LocalHost else: for ip_address in QtNetwork.QNetworkInterface.allAddresses(): if ip_address != QtNetwork.QHostAddress.LocalHost and ip_address.toIPv4Address() != 0: break else: ip_address = QtNetwork.QHostAddress.LocalHost self.host = ip_address self.tcp_server = QtNetwork.QTcpServer() # Create a server object self.tcp_server.newConnection.connect(self._new_connection) # Handler for a new connection self.tcp_server.listen(self.host, int(self.port)) # Start listening for connections self.conStatSigS.emit("Waiting") # Indicate that the server is listening on the GUI self.logger.debug("Stellarium server connection initializer called")
def startCommunication(self): """ startCommunication prepares the remote listening by starting a tcp server listening on localhost and port 3490. :return: success """ if self.tcpServer is not None: return False self.tcpServer = QtNetwork.QTcpServer(self) hostAddress = QtNetwork.QHostAddress('127.0.0.1') if not self.tcpServer.listen(hostAddress, 3490): self.log.warning('Port already in use') self.tcpServer = None return False else: self.log.info('Remote access enabled') self.tcpServer.newConnection.connect(self.addConnection) return True
def __init__(self, x, y, width, height, rpm, scene_server_port): super(RescuersGui, self).__init__() self.x = x self.y = y self.width = width self.height = height self.rpm = rpm self.port = scene_server_port self.tcpServer = QtNetwork.QTcpServer(self) if not self.tcpServer.listen(port=self.port): rospy.logerr('Failed to start scene TCP server on port ' + str(self.port)) self.tcpServer.newConnection.connect(self.new_connection) self.connections = [] self.scene_timer = QtCore.QTimer() self.scene_timer.timeout.connect(self.send_to_clients_evt) self.scene_timer.start(1.0 / 15 * 1000) self.projectors = [ProjectorHelper("localhost")] rospy.loginfo("Waiting for projector nodes...") for proj in self.projectors: proj.wait_until_available() if not proj.is_calibrated(): rospy.loginfo("Starting calibration of projector: " + proj.proj_id) proj.calibrate(self.calibrated_cb) else: rospy.loginfo("Projector " + proj.proj_id + " already calibrated.") rospy.loginfo("Ready")
def connect_server(self): """ Whenever we want a new TCP connection this function is called. :return: Nothing """ if self.host == "localhost": self.host = QtNetwork.QHostAddress.LocalHost else: for ip_address in QtNetwork.QNetworkInterface.allAddresses(): if ip_address != QtNetwork.QHostAddress.LocalHost and ip_address.toIPv4Address( ) != 0: break else: ip_address = QtNetwork.QHostAddress.LocalHost self.host = ip_address # Save the local IP address self.tcp_server = QtNetwork.QTcpServer() # Create a server object self.tcp_server.newConnection.connect( self._new_connection) # Handler for a new connection self.sendDataClient.connect( self.send) # Connect the signal trigger for data sending self.tcp_server.listen(QtNetwork.QHostAddress(self.host), int( self.port)) # Start listening for connections
def __init__(self, parent=None): super(WebServer, self).__init__(parent) self.HTTPMethods = {'GET': self._processGET} self.webResources = {} self.tcpServer = QtNetwork.QTcpServer(self)
def __init__(self, portNumber): super(TcpServer, self).__init__(None) self.portNumber = portNumber self.tcpServer = QtNetwork.QTcpServer() self.tcpServer.newConnection.connect(self.onNewTcpConnection)
def test_stopCommunication_2(): app.clientConnection = QtNetwork.QTcpServer(app) suc = app.stopCommunication() assert suc
# # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/> ''' Basic actions of QTcpServer, QTcpSocket communication. ''' from PyQt5 import QtCore, QtNetwork def new_server_connection(): print('new server connection') def new_client_connection(): print('new client connection') def setup(): server.listen(QtNetwork.QHostAddress.LocalHost, 34543) client_socket.connectToHost(QtNetwork.QHostAddress.LocalHost, 34543) app = QtCore.QCoreApplication([]) server = QtNetwork.QTcpServer() server.newConnection.connect(new_server_connection) client_socket = QtNetwork.QTcpSocket() client_socket.connected.connect(new_client_connection) QtCore.QTimer.singleShot(0, setup) QtCore.QTimer.singleShot(3000, app.quit) app.exec_()
def __init__(self): super().__init__() self.tcp_server = QtNetwork.QTcpServer(self) self.tcp_server.acceptError.connect(self.accept_error) self.tcp_server.newConnection.connect(self._new_connection)