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 __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 updstartup(self):
self.udprecvcnt = 0
self.udpsendcnt = 0
self.socket = QtNetwork.QUdpSocket()
self.socket.bind(QtNetwork.QHostAddress(""), 6000)
self.socket.readyRead.connect(self.recvudp)
log.debug("Connected to socket, waiting for udp stream", extra = log.HST)
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 onTimer(self):
timeStr = Time(datetime.utcnow(), scale='utc').iso.split('.')[0]
self.curTime.setText(timeStr.split(" ")[1])
#print('write ' + timeStr.split(" ")[1])
dateStr = Time(datetime.utcnow(), scale='utc').iso.split(' ')[0]
self.curDate.setText(dateStr)
if (self.cmd < 200):
self.cmd = 200
else:
self.cmd = 100
self.SendTimePacket()
self.SrhAntSocket.writeDatagram(
QtCore.QByteArray(
struct.pack('!16sHHHLL', b'_Srh_Net_Packet_', 0,
self.cmd, 0, 0, 0)),
QtNetwork.QHostAddress('192.168.0.168'), 9998)
testSocket = QtNetwork.QTcpSocket()
testSocket.connectToHost('192.168.0.1', 80)
if testSocket.waitForConnected() == True:
self.Network.setPixmap(self.greenBox)
else:
self.Network.setPixmap(self.redBox)
testSocket.close()
def connect_client(self):
self.logger.debug("Client connection initializer called")
if self.sock.state() != QtNetwork.QAbstractSocket.ConnectedState:
# Get the host and port from the settings file for the client connection
host = self.cfg_data.get_tcp_client_host()
port = self.cfg_data.get_tcp_client_port()
self.sock = QtNetwork.QTcpSocket() # Create the TCP socket
self.sock.readyRead.connect(self._receive) # Data que signal
self.sock.connected.connect(
self._host_connected) # What to do when we have connected
self.sock.error.connect(
self._error
) # Log any error occurred and also perform the necessary actions
self.sock.disconnected.connect(
self._disconnected
) # If there is state change then call the function
self.conStatSigC.emit(
"Connecting") # Indicate that we are attempting a connection
self.sock.connectToHost(
QtNetwork.QHostAddress(host),
int(port)) # Attempt to connect to the server
if not self.sock.waitForConnected(
msecs=1000
): # Wait a until connected (the function is waiting for 1 sec)
self.conStatSigC.emit(
"Disconnected") # Indicate that we are not connected
self.logger.warning("Client was unable to connect to: %s:%s",
host, port)
def resendDatagram(self):
return #Počkejte si na verzi 1.1
for sent, request in self.history:
if not sent:
self.udpSocket.writeDatagram(request,
QN.QHostAddress(self.serverIP),
VOIP.SERVERPORT)
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, host=None, port=None, parent=None):
super(ReadOnlyTCPSocket, self).__init__(parent)
self.host = host
if not isinstance(port, int):
port = int(port)
self.port = port
self.connectToHost(QtNetwork.QHostAddress(self.host), self.port)
def __init__(self, parent, settings, address="0.0.0.0", port=PORT):
super(QtCore.QObject, self).__init__(parent)
self.settings = settings
self.server = QtWebSockets.QWebSocketServer(parent.serverName(),
parent.secureMode(),
parent)
if self.server.listen(QtNetwork.QHostAddress(address), port):
print('Listening: ' + self.server.serverName() + ' : ' +
self.server.serverAddress().toString() + ':' +
str(self.server.serverPort()))
else:
print('error')
self.server.newConnection.connect(self.on_new_connection)
self.clientConnection = None
self.gui = None
self.msg_responses = None
self.msg_uuids = None
self.users = {}
self.self_name = None
self.potions_disable_timer = QTimer()
self.potions_disable_timer.timeout.connect(self.clear_effects)
print(self.server.isListening())
def __init__(self, ip: str, port: int, user: str, password: str,
bddd: common.bdd.BDD):
QtCore.QObject.__init__(self)
addr = QtNetwork.QHostAddress(ip)
self.user = user
self.password = password
self.bddd = bddd
self.ip = ip
self.port = port
app_directory = os.path.dirname(
os.path.dirname(os.path.realpath(__file__)))
print(app_directory + "\Sync\openssl.key")
self.httpd = HTTPServer((ip, port), MyRequestHandler)
try:
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_context.load_cert_chain(
app_directory + '\\Sync\\fullchain.pem',
app_directory + "\\Sync\\privkey.pem")
self.httpd.socket = ssl_context.wrap_socket(self.httpd.socket,
server_side=True)
loop = asyncio.new_event_loop()
self.thread = Thread(target=self.Run, args=(loop, ip, port))
self.thread.start()
except:
traceback.print_exc()
def onDown(self, value):
timeStr = Time(datetime.utcnow(), scale='utc').iso.split('.')[0]
ds = int(((self.ElDesiredSpeed.value() * 0x4000 / self.RPMlimit) - 16))
self.Log.append('%s %d %s' % (timeStr, value, 'Up'))
self.SrhAntSocket.writeDatagram(
QtCore.QByteArray(
struct.pack('!16sHHhLL', b'_Srh_Net_Packet_', 0, 104, ds, 0,
0)), QtNetwork.QHostAddress('192.168.0.168'), 9998)
def Poll_For_New_Devices( self ): self.Attempt_Serial_Connections() potential_ip_addresses = Convert_IP_Range_To_List( self.ip_range ) possible_duplicates = [key.split( ':' )[0] for key in self.active_connections.keys()] for ip in [x for x in potential_ip_addresses if x not in possible_duplicates]: self.udp_socket.writeDatagram( self.identifier_string.encode(), QtNetwork.QHostAddress(ip), self.port_for_ping )
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 __init__(self, qtapp):
super().__init__()
self.qtapp = qtapp
self.socket = QtNetwork.QUdpSocket()
self.socket.bind(QtNetwork.QHostAddress(""), 6001)
self.t1 = QtCore.QTimer(qtapp)
self.t1.setInterval(10)
self.t1.timeout.connect(self.sample)
def onStopElev(self):
timeStr = Time(datetime.utcnow(), scale='utc').iso.split('.')[0]
self.Log.append('%s %s' % (timeStr, 'Stop'))
self.SrhAntSocket.writeDatagram(
QtCore.QByteArray(
struct.pack('!16sHHhLL', b'_Srh_Net_Packet_', 0, 106, 0, 0,
0)), QtNetwork.QHostAddress('192.168.0.168'), 9998)
self.Up.setChecked(False)
self.Down.setChecked(False)
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.server = mrMeshPyQtTCPServer()
if not self.server.listen(QtNetwork.QHostAddress("127.0.0.1"), 9995):
# if not self.server.listen(): #next available ## TODO may be better
print("Error")
return
print("Running on %d" % self.server.serverPort())
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 answer(self, player, number):
request = QC.QByteArray()
stream = QC.QDataStream(request, QC.QIODevice.WriteOnly)
stream.setVersion(QC.QDataStream.Qt_5_2)
stream.writeBool(False)
stream.writeUInt8(player)
stream.writeUInt8(number)
self.udpSocket.writeDatagram(request, QN.QHostAddress(self.serverIP),
VOIP.SERVERPORT)
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 writeDatagram(self, message, number):
request = QC.QByteArray()
stream = QC.QDataStream(request, QC.QIODevice.WriteOnly)
stream.setVersion(QC.QDataStream.Qt_5_2)
stream.writeBool(True)
stream.writeUInt8(
0) # Vyhrazuji si místo pro odesílatele zprávy, toho zapíše server
stream.writeUInt8(number)
stream.writeBytes(message)
#print("SEND", number)
self.udpSocket.writeDatagram(request, QN.QHostAddress(self.serverIP),
VOIP.SERVERPORT)
self.history.add(number, [False, request])
def __init__(self,
address = QtNetwork.QHostAddress(QtNetwork.QHostAddress.LocalHost),
encoding = 'utf-8',
port = 9500,
server_name = "default",
verbose = False,
**kwds):
super().__init__(**kwds)
# Initialize internal attributes
self.address = address
self.encoding = encoding
self.port = port
self.server_name = server_name
self.socket = None
self.verbose = verbose
def __init__(self, parent=None):
# set up the initial user interface window on Qt
QtWidgets.QMainWindow.__init__(self, parent)
self.ui = Ui_MrMeshMainWindow()
self.ui.setupUi(self)
# set up a tcp server instance (Qt TCP server)
self.server = mrMeshPyQtTCPServer(self)
self.ui.TCP_server = self.server ## this puts the service instance into the scope of the user interface (ui)
# TODO - hard code TCP port 9999 for now #next available may be better
if not self.server.listen(QtNetwork.QHostAddress('127.0.0.1'), 9999):
print('Error starting TCP instance on requested port - quitting.')
return
print('Running TCP instance on port %d' % self.server.serverPort())
# set up the menu bar in the UI window with its callbacks
Ui_setupMenuBarCallbacks(self.ui)
# lets keep track of how many vtk instances are open in a list that is in the scope of the ui
self.ui.vtkInstances = [] #empty for now
# and we are going to use a dictionary to keep track of unique instances
# the unique string generated by matlab will point at an index to the vtkInstances list #TODO is this sensible?
self.ui.vtkDict = {}
self.ui.statusbar.showMessage(
' ... Waiting for matlab to send a mesh ...')
# ---Ready to go unless testing/debugging ---------------------------------
# some debug options
if debug:
# ---------------
# add a vtk window!
mrMeshVTKWindow(self.ui, 'debug')
self.ui.statusbar.showMessage(
' ... in debug mode; loaded test VTK window ...')
def testMenuPrint(self):
print('test menu print message')
# some other test options
if test:
from testRender import mp_launchVTKWindow
mp_launchVTKWindow(self.ui)
def Connect_Client():
"""Connects to the server with provided hostname and port."""
if Server_Button.isChecked():
HOST = Host_Address.text()
PORT = int(Port_Number.text())
SOCKET.connectToHost(QtNetwork.QHostAddress(HOST), PORT)
Send_Message("{CONNECT}")
Server_Button.setIcon(
QtGui.QIcon(f"{os.getcwd()}/icons/exit_icon.svg"))
Server_Connection_Status.setText(
"<html><head/><body><center>CONNECTED </center></body></html>"
)
Theme(Chat_Theme.currentText())
Host_Address.setEnabled(False)
Port_Number.setEnabled(False)
Temporary_Avatar.setVisible(False)
User_Avatar.setVisible(True)
Username.setEnabled(True)
Sign_In_Button.setEnabled(True)
Message_Field.setText("Waiting for sign-in...")
else:
Send_Message("{DISCONNECT}")
Server_Button.setIcon(
QtGui.QIcon(f"{os.getcwd()}/icons/enter_icon.svg"))
Server_Connection_Status.setText(
"<html><head/><body><center>NOT CONNECTED</center></body></html>"
)
Theme(Chat_Theme.currentText())
Host_Address.setEnabled(True)
Port_Number.setEnabled(True)
Temporary_Avatar.setVisible(True)
User_Avatar.setVisible(False)
Username.setEnabled(False)
Sign_In_Button.setEnabled(False)
Message_Field.setText("Dissconnected! Good Bye...")
def __init__(self, server, parent=None):
super(VOIP, self).__init__(parent)
self.udpSocket = QN.QUdpSocket(self)
self.udpSocket.bind(QN.QHostAddress("0.0.0.0"), VOIP.MYPORT)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
self.p = pyaudio.PyAudio()
self.serverIP = server
self.history = Sequence(True)
self.resendTimer = QC.QTimer()
self.resendTimer.setInterval(VOIP.RINTERVAL)
self.resendTimer.timeout.connect(self.resendDatagram)
self.resendTimer.start()
def __init__(self, parent=None):
super(VOIP, self).__init__(parent)
self.udpSocket = QN.QUdpSocket(self)
self.udpSocket.bind(QN.QHostAddress("0.0.0.0"), VOIP.MYPORT)
self.udpSocket.readyRead.connect(self.processPendingDatagrams)
self.players = {}
self.connectionAddress = []
self.history = (Sequence(), Sequence(), Sequence(), Sequence(),
Sequence(), Sequence())
self.resendTimer = QC.QTimer()
self.resendTimer.setInterval(VOIP.RINTERVAL)
self.resendTimer.timeout.connect(self.resend)
self.resendTimer.start()
def open_receiver(self):
# create a UDP socket to send and receive messages from the client
if self.port is not None:
self.port.close()
self.port = QtNetwork.QUdpSocket()
success = self.port.bind(QtNetwork.QHostAddress(self.listener_address),
self.listener_portnum)
if not success:
self.window.show_status("Failed to bind listener socket.")
self.port.close()
self.port = None
else:
self.port.readyRead.connect(self.message_received)
self.window.show_status(
"Ready to go, listening for OSC UDP packets on %s:%d..." %
(self.listener_address, self.listener_portnum))
return
def __init__(self, parent):
super(QtCore.QObject, self).__init__(parent)
self.timer = QTimer()
self.timer.setInterval(50)
self.timer.timeout.connect(self.send_data)
self.clients = []
print("server name: {}".format(parent.serverName()))
self.server = QtWebSockets.QWebSocketServer(parent.serverName(),
parent.secureMode(),
parent)
if self.server.listen(QtNetwork.QHostAddress('127.0.0.1'), 8080):
print('Listening: {}:{}:{}'.format(
self.server.serverName(),
self.server.serverAddress().toString(),
str(self.server.serverPort())))
else:
print('error')
self.server.acceptError.connect(self.onAcceptError)
self.server.newConnection.connect(self.onNewConnection)
self.clientConnection = None
print(self.server.isListening())
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,
address=QtNetwork.QHostAddress(
QtNetwork.QHostAddress.LocalHost),
port=7624,
verbose=True,
**kwds):
super().__init__(**kwds)
self.device = None
self.message_string = ""
self.verbose = verbose
# Create socket.
self.socket = QtNetwork.QTcpSocket()
self.socket.disconnected.connect(self.handleDisconnect)
self.socket.readyRead.connect(self.handleReadyRead)
# Connect to socket.
self.socket.connectToHost(address, port)
if not self.socket.waitForConnected():
raise QtINDIClientException("Cannot connect to indiserver at " +
address + ", port " + str(port))
