def __init__(self, name, socket, dispatcher, *args, **kwargs):
"""
Constructor
"""
QtCore.QObject.__init__(self, *args, **kwargs)
self.name = name
logger = logging.getLogger("faf.secondaryServer.%s" % self.name)
logger.info("Instantiating secondary server.")
self.logger = logger
self.socketPort = socket
self.dispatcher = dispatcher
self.command = None
self.message = None
self.blockSize = 0
self.serverSocket = QtNetwork.QTcpSocket()
self.serverSocket.error.connect(self.handleServerError)
self.serverSocket.readyRead.connect(self.readDataFromServer)
self.serverSocket.connected.connect(self.send_pending)
self.invisible = False
self._requests = []
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 connect(self):
if self.socket:
logging.warning(
'VoyagerClient:connect() socket appears to be active already!')
# FIXME Need some error handling!
self.socket = QtNetwork.QTcpSocket()
logging.info('Connecting')
# FIXME Does this leak sockets? Need to investigate why
# setting self.socket = None causes SEGV when disconnected
# (ie PHD2 closes).
self.socket.connectToHost('127.0.0.1', 5950)
logging.info('waiting')
# should be quick so we connect synchronously
if not self.socket.waitForConnected(5000):
logging.error('Could not connect to Voyager')
self.socket = None
return False
self.connected = True
self.socket.readyRead.connect(self.process)
self.socket.error.connect(self.error)
self.socket.stateChanged.connect(self.state_changed)
self.socket.disconnected.connect(self.disconnected)
return True
def __init__(self, parent, local_socket, *args, **kwargs):
QtCore.QObject.__init__(self, *args, **kwargs)
self.parent = parent
self.inputSocket = local_socket
self.inputSocket.setSocketOption(QtNetwork.QTcpSocket.KeepAliveOption,
1)
self.inputSocket.readyRead.connect(self.readDatas)
self.inputSocket.disconnected.connect(self.inputDisconnected)
self.__logger.info("FA connected locally.")
# Create a file to write the replay data into
self.replayData = QtCore.QByteArray()
self.replayInfo = fa.instance._info
# Open the relay socket to our server
self.relaySocket = QtNetwork.QTcpSocket(self.parent)
self.relaySocket.connectToHost(INTERNET_REPLAY_SERVER_HOST,
INTERNET_REPLAY_SERVER_PORT)
if util.settings.value("fa.live_replay",
DEFAULT_LIVE_REPLAY,
type=bool):
if self.relaySocket.waitForConnected(
1000): # Maybe make this asynchronous
self.__logger.debug("internet replay server " +
self.relaySocket.peerName() + ":" +
str(self.relaySocket.peerPort()))
else:
self.__logger.error("no connection to internet replay server")
def __init__(self):
super(JackStreamListen, self).__init__()
self.ip = '127.0.0.1'
self.port = '23'
self.state = 'disconnected'
self.channel_select = -1
self.channel_count = -1
# self.tsfmt = '%y%m%d-%H%M%S:'
# self.textFgColor = 'rgb(0,0,0)'
# self.textBgColor = 'rgb(255,255,255)'
# self.fontstr = 'Helvetica'
logging.debug('DBG: state = ' + self.state)
# self.insFile = "";self.insDir=""
# self.insSleepAmount = 0;
self.qsock = QtNetwork.QTcpSocket(self)
self.qsock.readyRead.connect(self.onReadyRead)
# create None/empty variables to be created/updated later
self.prevpkt = bytearray() # note a QByteArray b/c reusing msgify_pkt
self.audiodata = bytearray()
self.clips = []
self.rms = []
self.audiofmt = QAudioFormat()
self.audioout = QAudioOutput()
self.iodevice = self.createIoDevice()
#FIXME self.tcpSocket.error.connect(self.displayError)
# self.font = QtGui.QFont()
self.loadSettings()
self.initUI()
def __init__(self, **kwds):
super().__init__(**kwds)
# Create instance of TCP socket
self.socket = QtNetwork.QTcpSocket()
self.socket.disconnected.connect(self.handleDisconnect)
self.socket.readyRead.connect(self.handleReadyRead)
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 __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setGeometry(300, 300, 280, 600)
self.setWindowTitle('using threads')
self.layout = QVBoxLayout(self)
self.startBtn = QPushButton("Start")
self.startBtn.released.connect(self.startAq)
self.stopBtn = QPushButton("Stop")
self.stopBtn.released.connect(self.stopAq)
self.listwidget = QListWidget(self)
self.layout.addWidget(self.startBtn)
self.layout.addWidget(self.stopBtn)
self.layout.addWidget(self.listwidget)
self.threadPool = []
self.measure = True
self.threadSignal.connect(self.add)
# Network stuff
self.tcpClient = QtNetwork.QTcpSocket()
self.tcpClient.connectToHost('127.0.0.1', 5000)
self.tcpClient.readyRead.connect(self.getData)
self.tcpClient.error.connect(lambda x: print(x))
def run(self):
""" create new socket for communicate with client, receive header data contain request information, process it and
send accept, then listen for receive body data
"""
self.tcpSocket = QtNetwork.QTcpSocket()
if not self.tcpSocket.setSocketDescriptor(self.socketDescriptor):
raise Exception(self.tcpSocket.errorString())
self.tcpSocket.waitForReadyRead()
buffer = self.tcpSocket.readAll()
try:
try:
self.size, self.priority, self.timeout, self.route, self.module_version, self.call_back, self.token = self.extract(
buffer)
except ValueError:
self.size, self.priority, self.timeout, self.route, self.call_back, self.token = self.extract(buffer)
self.call_back = base64.b64decode(self.call_back).decode()
self.token = utils.decrypt_rsa(self.token, utils.get_rsa())
self.route_name = self.route_to_name(self.route)
ApiLogging.info('route is: ' + self.route_name)
if not self.module_version:
self.module_version = 'v_1_0'
except Exception as e:
print("rejected", e)
self.tcpSocket.write('{"status":"reject"}'.encode())
self.__close()
else:
self.size = int(self.size)
self.tcpSocket.write('{"status":"accept"}'.encode())
self.tcpSocket.waitForBytesWritten()
self.tcpSocket.readyRead.connect(self.__read_data)
self.tcpSocket.waitForDisconnected(
30 * 60 * 1000) # FIXME: change to better solution for big data timeout and handle incompleted data
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 connect(self, name):
logging.info(
f'RPC Camera connect: Connecting to RPCServer 127.0.0.1:{self.port}'
)
# FIXME Does this leak sockets? Need to investigate why
# setting self.socket = None causes SEGV when disconnected
# (ie PHD2 closes).
self.socket = QtNetwork.QTcpSocket()
self.socket.connectToHost('127.0.0.1', self.port)
logging.info('waiting')
# should be quick so we connect synchronously
if not self.socket.waitForConnected(5000):
logging.error('Could not connect to RPCServer')
self.socket = None
return False
self.socket.readyRead.connect(self.process)
logging.info('Connected to RPCServer')
self.connected = True
return True
def forward(self, alarm):
data = None
if alarm.source == 'pager':
data = alarm.pager.encode('utf-8')
socket = QtNetwork.QUdpSocket()
for host, addr, port in self.hosts:
self.logger.info('Forwarding to %s (%s:%u/udp)', host,
addr.toString(), port)
socket.writeDatagram(data, addr, port)
elif alarm.source == 'xml':
data = alarm.xml # bytes
socket = QtNetwork.QTcpSocket()
for host, addr, port in self.hosts:
self.logger.info('Forwarding to %s (%s:%u/tcp)', host,
addr.toString(), port)
socket.connectToHost(addr, port)
if not socket.waitForConnected(5000):
self.logger.error('Connection failed.')
continue
socket.writeData(data)
if not socket.waitForBytesWritten(5000):
self.logger.error('Writing to socket failed.')
socket.close()
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 openConnection(self):
self.tcpSocket = QtNetwork.QTcpSocket()
self.tcpSocket.readyRead.connect(self.readData)
self.tcpSocket.error.connect(self.onError)
self.tcpSocket.connectToHost("localhost", 6001)
self.tcpSocket.write(self.msg)
def OpenConnection(self):
self.CloseConnection()
if (self.connectionType.lower() == "socket"
or self.connectionType.lower() == "qtsocket"):
if "ws:" in self.connectionName:
connectionName = self.connectionName.replace("ws://", "")
(ip, port) = connectionName.rsplit(":", 1)
if ip == None or ip == "":
ip = "127.0.0.1"
if port == None or port == "":
port = "5679"
connectionName = "ws://" + ip + ":" + port
from PyQt5.QtWebSockets import QWebSocket
from PyQt5.QtCore import QUrl
self.connection = QWebSocket()
print("opening websocket " + connectionName)
self.connection.open(QUrl(connectionName))
self.connection.binaryMessageReceived.connect(
self.processBinaryMessage)
self.sendBytesFn = self.connection.sendBinaryMessage
else:
#print("opening TCP socket " + self.connectionName)
(ip, port) = self.connectionName.rsplit(":", 1)
if ip == None or ip == "":
ip = "127.0.0.1"
if port == None or port == "":
port = "5678"
port = int(port)
#print("ip is ", ip, ", port is ", port)
self.connection = QtNetwork.QTcpSocket(self)
self.connection.error.connect(self.displayConnectError)
ret = self.connection.readyRead.connect(self.readRxBuffer)
self.connection.connectToHost(ip, port)
self.readBytesFn = self.connection.read
self.sendBytesFn = self.connection.write
#print("making connection returned", ret, "for socket", self.connection)
self.connection.connected.connect(self.onConnected)
self.connection.disconnected.connect(self.onDisconnect)
elif (self.connectionType.lower() == "file"):
try:
self.connection = open(self.connectionName, 'rb')
self.readBytesFn = self.connection.read
self.sendBytesFn = self.connection.write
except IOError:
print("\nERROR!\ncan't open file ", self.connectionName)
sys.exit(1)
else:
print("\nERROR!\nneed to specify socket or file")
sys.exit()
self.connection
def startMultiplexer(self, address):
if self.protocol() == 'unix':
self.multiplexer = QtNetwork.QLocalSocket(self)
self.multiplexer.connectToServer(address,
QtCore.QIODevice.WriteOnly)
else:
self.multiplexer = QtNetwork.QTcpSocket(self)
address, port = address.split(':')
self.multiplexer.connectToHost(address, int(port),
QtCore.QIODevice.WriteOnly)
def start(self):
mutex = QtCore.QMutex() # Create a QMutex object
mutex.lock(
) # Lock the thread until it has started, to avoid any overlapping problems
self.logger.info("Client thread started") # Indicate thread start
self.sock = QtNetwork.QTcpSocket() # Create the TCP socket
self.reConnectSigC.connect(
self.connect_client) # Do the reconnect signal connection
self.connect_client() # Start a connection
mutex.unlock() # Unlock the thread, since it has started successfully
def __init__(self, logger_callback): super().__init__() self.log = logger_callback self.ip = '193.193.165.165' self.port = 20332 self.socket = QtNetwork.QTcpSocket() self.socket.readyRead.connect(self.read_answer) self.socket.connected.connect(self.handle_connected) self.socket.disconnected.connect(self.handle_disconnected) self.socket.error.connect(self.handle_error)
def __init__(self, device, postman, parent=None):
super(TcpThread, self).__init__(parent)
self.postman = postman
self.device = device
self.tcp = QtNetwork.QTcpSocket(parent)
#self.thread = QtCore.QThread()
#self.tcp.moveToThread(self.thread)
self.tcp.connected.connect(self.connected.emit)
self.tcp.disconnected.connect(self.disconnected.emit)
self.tcp.readyRead.connect(self.handleTcp)
self.tcp.error.connect(self.handleError)
def initExample(self):
self.tcp = QtNetwork.QTcpSocket(self)
self.tcp.readyRead.connect(self.readData)
self.tcp.stateChanged.connect(self.stateChanged)
self.tcp.error.connect(self.onError)
self.tcp.connectToHost("smtp.gmail.com", 587)
self.tcp.write(b"EHLO smtp.gmail.com\r\n")
self.tcp.write(b"QUIT\r\n")
def openConnection(self):
self.tcpSocket = QtNetwork.QTcpSocket()
self.tcpSocket.readyRead.connect(self.readData)
self.tcpSocket.error.connect(self.onError)
self.tcpSocket.connectToHost("www.something.com", 80)
self.tcpSocket.write(b"GET / HTTP/1.1\r\n" \
b"Host: www.something.com\r\n" \
b"\r\n")
def __init__(self, dispatch, host, port):
QtCore.QObject.__init__(self)
self.dispatch = dispatch
self.blockSize = 0
self.host = host
self.port = port
self.replayVaultSocket = QtNetwork.QTcpSocket()
self.replayVaultSocket.readyRead.connect(self._readDataFromServer)
self.replayVaultSocket.error.connect(self._handleServerError)
self.replayVaultSocket.disconnected.connect(self._disconnected)
def send_request(self, req_type):
"""Sending request to the server"""
if not " " in self.passwd.text() and len(self.passwd.text()) > 3:
self.frame = dumps({'type': req_type, 'nick': self.nickname.text(), 'password': self.passwd.text()})
self.sock = qtn.QTcpSocket()
# self.sock.connectToHost(qtn.QHostAddress(self.IP), self.PORT)
self.sock.connectToHost(qtn.QHostAddress.LocalHost, self.PORT)
self.sock.write(bytes(self.frame, 'utf8'))
self.sock.waitForBytesWritten(500)
self.message()
else:
self.status.setText("Password must be longer than 3 letters and must have no spaces. ")
def __init__(self, host, port=9002):
QtCore.QObject.__init__(self)
# always queue added, removed or event callbacks in order to
# prevent event processing within synchronous calls
self.__deviceAddedQueue.connect(self.deviceAdded, type=QtCore.Qt.QueuedConnection)
self.__deviceRemovedQueue.connect(self.deviceRemoved, type=QtCore.Qt.QueuedConnection)
# setup tcp socket
self.__host = host
self.__port = port
self.__socket = QtNetwork.QTcpSocket()
self.__socket.readyRead.connect(self.__handle_ready_read)
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 connect(self):
try:
_logger().debug('connecting to server: localhost:%s', self.port)
except AttributeError:
return
if self._socket:
self._socket.setParent(None)
self._socket.deleteLater()
self._socket = None
self._socket = QtNetwork.QTcpSocket()
self._socket.connected.connect(self._on_connected)
self._socket.error.connect(self._on_socket_error)
self._socket.readyRead.connect(self._on_socket_ready_read)
self._socket.connectToHost(QtNetwork.QHostAddress.LocalHost, self.port)
def __init__(self, host, port, dispatch):
QtCore.QObject.__init__(self)
self.socket = QtNetwork.QTcpSocket()
self.socket.readyRead.connect(self.readFromServer)
self.socket.error.connect(self.socketError)
self.socket.setSocketOption(QtNetwork.QTcpSocket.KeepAliveOption, 1)
self.socket.stateChanged.connect(self.on_socket_state_change)
self._host = host
self._port = port
self._state = ConnectionState.INITIAL
self.blockSize = 0
self._disconnect_requested = False
self._dispatch = dispatch
def __init__(self, parent=None):
super(Client, self).__init__(parent)
# Ititialize socket
self.socket = QN.QTcpSocket()
# Initialize data IO variables
self.nextBlockSize = 0
self.request = None
#self.setWindowTitle("Client")
# Signals and slots for networking
self.socket.readyRead.connect(self.readFromServer)
self.socket.disconnected.connect(self.serverHasStopped)
self.socket.error.connect(self.serverHasError)
def __init__(self, handler, host, port):
self.host = host
self.port = port
self.handler = handler
self.blockSize = 0
self.updateSocket = QtNetwork.QTcpSocket()
self.updateSocket.setSocketOption(QtNetwork.QTcpSocket.KeepAliveOption,
1)
self.updateSocket.setSocketOption(QtNetwork.QTcpSocket.LowDelayOption,
1)
self.updateSocket.error.connect(self.handleServerError)
self.updateSocket.readyRead.connect(self.readDataFromServer)
self.updateSocket.disconnected.connect(self.disconnected)
def __init__(self, parent=None):
super(Client, self).__init__(parent)
self.setupUi(self)
self.psbar.hide()
self.socket = QtNetwork.QTcpSocket()
self.socket.setObjectName("socket")
# self.socket.readyRead.connect(self.readResponse)
self.socket.connectToHost("192.168.1.150", PORT)
self.socket.bytesWritten.connect(self.on_server_bytesWritten)
self.filename = ""
self.outblock = QByteArray()
