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 hasPendingFile(self, userName, serverAddress, clientAddress, fileName):
'''
看看是否是发给自己的文件
'''
ipAddress = self.getIP()
if ipAddress == clientAddress:
# 当我们收到的客户端地址和本机IP地址是一样的，表示确实是发给这台电脑的
isreceive = "来自{}({})的文件：{}，是否接收？".format(userName, serverAddress,
fileName)
btn = QMessageBox.information(self, "接收文件", isreceive,
QMessageBox.Yes, QMessageBox.No)
if btn == QMessageBox.Yes:
name = QFileDialog.getSaveFileName(self, "保存文件", fileName)
if name[0]:
client = TcpC(self)
client.setFileName(name[0])
client.setHostAddress(QHostAddress(serverAddress))
client.exec()
# 当我们的选择同意接收的时候，我们调用客户端的相关函数执行，为接收文件做好准备。
else:
self.sendMessage(Chat.Refuse, serverAddress)
self.udpSocket.close()
self.network()
def _is_url_naive(urlstr):
"""Naive check if given URL is really a URL.
Args:
urlstr: The URL to check for, as string.
Return:
True if the URL really is a URL, False otherwise.
"""
url = qurl_from_user_input(urlstr)
assert url.isValid()
if not utils.raises(ValueError, ipaddress.ip_address, urlstr):
# Valid IPv4/IPv6 address
return True
# Qt treats things like "23.42" or "1337" or "0xDEAD" as valid URLs
# which we don't want to. Note we already filtered *real* valid IPs
# above.
if not QHostAddress(urlstr).isNull():
return False
return '.' in url.host()
def listen(self, host=None, port=3000):
"""Method making the server listening to a given address."""
# If no address was specified: trying to give the best one
if host is None:
for ip in self.get_available_ips():
if ip != QHostAddress.LocalHost and ip.toIPv4Address():
host = ip
if host is None: # No suitable address was found
host = QHostAddress.LocalHost
# The address was given as string
if type(host) == str:
host = QHostAddress(host)
# For printing...
address = "{}:{}".format(host.toString(), port)
# Launching server
if not self.__tcpServer.listen(host, port):
self.__tcpServer.close()
print("Unable to listen on address '{}': {}.".format(
address, self.__tcpServer.errorString()))
raise ConnectionError(self.__tcpServer.errorString())
else:
print("Server is listening on address '{}'.".format(address))
self.listening.emit((host, port))
def __init__(self):
"""
Constructor of the BackgroundService class.
"""
self.processes = {}
self.connections = {}
self.isWorking = None
self.runningJob = [None, None, None, None]
self.__queue = []
self.services = {}
super(BackgroundService, self).__init__()
networkInterface = Preferences.getDebugger("NetworkInterface")
if networkInterface == "all" or '.' in networkInterface:
self.hostAddress = '127.0.0.1'
else:
self.hostAddress = '::1'
self.listen(QHostAddress(self.hostAddress))
self.newConnection.connect(self.on_newConnection)
port = self.serverPort()
## Note: Need the port if started external in debugger:
print('BackgroundService listening on: {0:d}'.format(port))
# __IGNORE_WARNING__
for pyName in ['Python2', 'Python3']:
venvName = Preferences.getDebugger(pyName + "VirtualEnv")
interpreter = e5App().getObject(
"VirtualEnvManager").getVirtualenvInterpreter(venvName)
if not interpreter and int(pyName[-1]) == sys.version_info[0]:
interpreter = sys.executable.replace("w.exe", ".exe")
if interpreter:
process = self.__startExternalClient(interpreter, port)
if process:
self.processes[pyName] = process, interpreter
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 ipIsValid(self):
return QHostAddress().setAddress(self.ipField.text())
def ConnectToServer(self):
ip = self.ui.lineEdit_IPAddress.text()
port = self.ui.lineEdit_PORT.text()
self.tcpsocket.connectToHost(QHostAddress(ip), int(port))
from PyQt5.QtCore import *
import numpy as np
import cv2
import sys
bf = cv2.BFMatcher()
sift = cv2.xfeatures2d.SIFT_create() # opencv 3
I1 = cv2.imread('/home/alireza/Documents/Geo-Localization/map.jpg')
G1 = cv2.cvtColor(I1, cv2.COLOR_BGR2GRAY)
keypoints1, desc1 = sift.detectAndCompute(G1, None)
# opencv 3
img_port = 1234
send_data_socket = QUdpSocket()
ROBOT_IP = QHostAddress("127.0.0.1")
ROBOT_data_port = 5678
def receive_data():
print("image Rec")
datagram = qb()
datagram.resize(rec_data_socket.pendingDatagramSize())
datagram, host, port = rec_data_socket.readDatagram(datagram.size())
datagram = qb(datagram)
rec_data_socket.flush()
buf = np.asarray(bytearray(datagram), dtype=np.uint8)
mat = cv2.imdecode(buf, cv2.IMREAD_COLOR)
datagram.clear()
def updateAudioPort(self):
'''更新我的端口和ip'''
self.audio_data.set_my_count(self.my_count)
self.audio_data.set_audio_status(AUDIO_STATUS_UPDATE)
self.audio_socket.writeDatagram(self.audio_data.audio_struct_pack(), QHostAddress(AUDIO_SERVER_IP), AUDIO_SERVER_PORT)
def __server(self):
self.srv = DataQueryTcpServer()
self.srv.listen(QHostAddress('0.0.0.0'), 1509)
self.srv.sendMessageToMain_signal.connect(self.server_work)
self.logstr(u'启动服务...')
self.__web_state = 1
"""
Initializes the rover UDP server. (currently acting as a dummy)
TODO: Implement ROS, listen to the 'right' nodes, bundle up a dictionary containing relevant data, send it to the multicast address. (test on the rover)
"""
import time
import json
import random
import signal
from PyQt5.QtNetwork import QUdpSocket, QHostAddress, QNetworkInterface
GAMEPAD_SERVER_ADDRESS = QHostAddress("127.0.0.1")
GAMEPAD_SERVER_PORT = 5000
SENSOR_PUBLISH_SERVER = QHostAddress("239.255.43.21")
SENSOR_PUBLISH_PORT = 45454
RUNNING = True
def generate_random_data():
"""
Generates random sensor data, returns as a json object.
"""
output = {}
# Drive : Speed + Turn
output["drive"] = {
"speed": random.randint(0, 16),
"turn": random.randint(-1, 1)
def mock_fromName(host):
info = QHostInfo()
if host == "known.domain":
info.setAddresses([QHostAddress("1.2.3.4")])
return info
def set_find_device_bind(self):
self.find_device.bind(QHostAddress(self.ip), 8888,
QUdpSocket.ReuseAddressHint)
def timeout(self):
'''定时器超时，槽函数，定期给服务器发送消息，获取服务器上所有的文件'''
self.udp_client_socket.writeDatagram(
str(FILE_STATUS_UPDATE).encode('utf-8'),
QHostAddress(FILE_SERVER_IP), FILE_SERVER_PORT_2)
def buttonConnect(self):
ip = self.ui.IPLineEdit.text()
port = self.ui.portLineEdit.text()
self.tcpSocket.connectToHost(QHostAddress(ip), int(port))
def isAvailable(port):
server = QTcpServer()
result = server.listen(QHostAddress("127.0.0.1"), port)
server.close()
return result
def __init__(self, ip, port):
super(MyTcpServer, self).__init__()
if self.isListening():
print("连接正在运行")
else:
self.listen(QHostAddress(ip), port)
def send_message(self,jdata,ip,port=0):
if port == 0:
port = self.port
data = json.loads(jdata)
self.udpSocket.writeDatagram(pickle.dumps((data["code"],data["msg"])),QHostAddress(ip),int(port))
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_device(self, address):
self.udpSocket.writeDatagram(b"ConnectToPcCloud-",
QHostAddress(address), 60000)
def giveMyChatRecord(self):
'''告知服务器，返回我的聊天记录'''
self.data.set_my_count(self.my_count)
self.data.set_friend_count(self.friend_count)
self.data.set_chat_status(CHAT_STATUS_CHAT_RECORE)
self.udp_client_socket.writeDatagram(self.data.chat_struct_pack(), QHostAddress(CHAT_SERVER_IP),CHAT_SERVER_PORT)
from coPyModules import *
from CoviseMsgLoop import CoviseMsgLoop, CoviseMsgLoopAction
from coviseModuleBase import *
import time
#--------
udpMode = False
try:
import covise
from PyQt5.QtNetwork import QHostAddress, QUdpSocket
# Set the socket parameters
secondUDP_IP = covise.getCoConfigEntry("vr-prepare.SecondUDP.IP")
if secondUDP_IP:
host = QHostAddress(secondUDP_IP)
else:
host = QHostAddress("127.0.0.1")
secondUDP_Port = covise.getCoConfigEntry("vr-prepare.SecondUDP.Port")
if secondUDP_Port:
port = int(secondUDP_Port)
else:
port = 6666
buf = 1024
addr = (host, port)
# Create socket and bind to address
if covise.coConfigIsOn("vr-prepare.SecondUDP"):
UDPSock = QUdpSocket()
UDPSock.bind(port)
udpMode = True
def __init__(self):
super().__init__()
self.isOnline = False
self.port = 8888
self.serverIP = QHostAddress('127.0.0.1')
self.initUI()
def updatePort(self):
'''告知服务器，更新我的聊天记录界面端口'''
self.data.set_my_count(self.my_count)
self.data.set_chat_status(CHAT_STATUS_UPDATE_RECORD_PAGE)
self.udp_client_socket.writeDatagram(self.data.chat_struct_pack(), QHostAddress(CHAT_SERVER_IP), CHAT_SERVER_PORT)
def incomingConnection(self, socketid):
'''
:description Info:内置方法，监听到有client连接时自动触发
开启一个线程
'''
st = ServerThread(socketid, self)
st.sendMessageToServer_signal.connect(self.recvMessageFromThread)
self.sendMessageToThread_signal.connect(st.sendMessageToSocket)
st.finished.connect(st.deleteLater)
self.sendMessageToMain_signal.emit({
'code': '0',
'msg': 'Start thread'
})
st.start()
def recvMessageFromThread(self, dict):
self.sendMessageToMain_signal.emit(dict)
def sendMessageToThread(self, msg):
self.sendMessageToThread_signal.emit(msg)
def stop(self):
self.close()
if __name__ == '__main__':
app = QApplication(sys.argv)
sqts = DataQueryTcpServer()
sqts.listen(QHostAddress('0.0.0.0'), 1509)
sys.exit(app.exec_())
