class QTcpTransport(Transport):
'''A Transport connecting to a TCP server.
Connect using .start().
Received data is processed on the Qt mainloop thread.
'''
shorthand='qtcp'
@classmethod
def fromstring(cls, expression):
'''qtcp:<host>:<port>'''
_, host, port = expression.split(':')
return cls(host=host, port=int(port), sendername=expression)
def __init__(self, host, port, sendername='qtcp'):
self.address = (host, port)
self.sendername = sendername
self.leftover = b''
self.socket = QTcpSocket()
self.socket.readyRead.connect(self.on_ready_read)
self.socket.error.connect(self.on_error)
self.socket.connected.connect(self.on_connect)
def start(self):
if self.socket.state() != QAbstractSocket.UnconnectedState:
L().debug('start(): Socket is not in UnconnectedState, doing nothing')
return
L().debug('connecting to: %s'%(self.address,))
self.socket.connectToHost(self.address[0], self.address[1])
def stop(self):
self.socket.flush()
self.socket.disconnectFromHost()
def send(self, data, receivers=None):
if receivers is not None and self.sendername not in receivers:
return
L().debug('message to tcp server: %s'%data)
self.socket.write(data.decode('utf8'))
def on_ready_read(self):
data = self.socket.readAll().data()
pdata = data
if len(pdata) > 100:
pdata = pdata[:100] + b'...'
#if pdata.startswith('{'):
L().debug('message from tcp server: %s'%pdata)
self.leftover = self.received(
sender=self.sendername,
data=self.leftover + data
)
def on_connect(self):
L().info('QTcpSocket: Established connection to %s'%(self.address,))
def on_error(self, error):
L().info('QTcpSocket raised error: %s'%error)
class TcpDevice(DataDevice):
'''
classdocs
'''
def __init__(self, params={}, parent=None):
'''
Constructor
'''
super(TcpDevice, self).__init__(params, parent)
self.iodevice = QTcpSocket()
self.reconnect = int(params.get('Reconnect', 1000))
self.host = params.get('Host', None)
self.port = int(params.get('Port', 2000))
self.gpsdInit = bool(params.get('GpsdInit', False))
self.iodevice.readyRead.connect(self.readyRead)
self.iodevice.error.connect(self.socketError)
self.iodevice.connected.connect(self.socketConnected)
self.iodevice.disconnected.connect(self.socketDisconnected)
@pyqtSlot(QAbstractSocket.SocketError)
def socketError(self, error):
if self.iodevice.state() != QAbstractSocket.BoundState:
if self.reconnect > 0:
QTimer.singleShot(self.reconnect, self.onReconnectTimer)
def connectDevice(self):
self.iodevice.connectToHost(self.host, self.port)
def disconnectDevice(self):
if self.iodevice.state() is QAbstractSocket.ConnectedState:
self.iodevice.disconnectFromHost()
def readData(self):
size = self.iodevice.bytesAvailable()
data = self.iodevice.read(size)
return data
def readLine(self):
if self.iodevice.canReadLine():
return str(self.iodevice.readLine())
return ''
@pyqtSlot()
def socketConnected(self):
self.deviceConnected.emit(True)
if self.gpsdInit:
self.iodevice.writeData('?WATCH={"class":"WATCH","nmea":true}')
@pyqtSlot()
def socketDisconnected(self):
self.deviceDisconnected.emit(True)
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._host = host
self._log = logging.getLogger('tcp')
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def try_connect(self, port):
msg = 'connecting to ({}:{})'
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._sock.connectToHost(self._host, port)
ok = self._sock.waitForConnected()
if ok:
self._log.debug('connection successful')
else:
self._log.error('failed to connect')
def greet(self):
self.send(query_tag('port', 'udp'), '')
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ':' + payload + '\n'
data = message.encode()
self._sock.write(data)
class SocketTcpClient(AbstractSocket):
"""Socket que envia e recebe dados via TcpSocket"""
def __init__(self, portaResponder, parent=None):
super().__init__(None, portaResponder, parent)
self._socketClient = QTcpSocket(self)
self._socketClient.readyRead.connect(self._lerDados)
def _lerDados(self):
if self._socketClient.bytesAvailable():
host = self.ipServidor()
data = self._socketClient.readData()
self.dadosRecebidos.emit(host, data)
def enviarDados(self, byteArray):
self._socketClient.write(byteArray)
def setPara(self, para):
if self.getPara() != para:
super().setPara(para)
self._conectarServidor(para)
def _conectarServidor(self, ip):
if self._socketClient.state() in (QAbstractSocket.ConnectedState, QAbstractSocket.ConnectingState):
self._desconectarServidor()
self._socketClient.connectToHost(QHostAddress(ip), self.getPortaResponder())
def _desconectarServidor(self):
if self._socketClient.state() == QAbstractSocket.UnconnectedState:
return True
self._socketClient.disconnectFromHost()
return self._socketClient.waitForConnected(50)
def ipServidor(self):
return self._socketClient.peerAddress()
def meuIP(self):
return self._socketClient.localAddress()
class TCPConnection(Connection):
def __init__(self):
Connection.__init__(self)
# read all data in buffer before exiting self.read_data
self.break_on_packet_found = False
def begin(self, instrument):
self.log = logging.getLogger('GDAIS.' + instrument.short_name +
'.TCPConnection')
self.instrument = instrument
self.io_conn = QTcpSocket()
self.io_conn.connected.connect(self.connected)
self.io_conn.error.connect(self.connection_error)
self.io_conn.connectToHost(instrument.connection.tcp_host,
instrument.connection.tcp_port)
def connected(self):
self.io_conn.readyRead.connect(self.read_data)
Connection.begin(self, self.instrument)
def connection_error(self, socket_error):
if socket_error == QTcpSocket.RemoteHostClosedError:
self.log.info(self.io_conn.errorString())
else:
self.log.error(self.io_conn.errorString())
self.error_occurred.emit()
def quit(self):
if self.io_conn and self.io_conn.state() == QTcpSocket.ConnectedState:
loop = QEventLoop()
self.io_conn.disconnected.connect(loop.quit)
self.io_conn.disconnectFromHost()
self.log.debug("Entered disconnect state...")
if self.io_conn.state() == QTcpSocket.ConnectedState:
loop.exec_()
self.log.info("Done")
Connection.quit(self)
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._pending = None
self._host = host
self._log = logging.getLogger("tcp")
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def _cancel_pending(self):
self._pending.stop()
self._pending = None
self._sock.connected.disconnect(self._connection_success)
@pyqtSlot()
def _connection_success(self):
self._cancel_pending()
self._log.debug("connection successful")
@pyqtSlot()
def _connection_failure(self):
self._cancel_pending()
self._log.debug("connection failed")
def try_connect(self, port):
if self._pending:
self._cancel_pending()
self._sock.disconnectFromHost()
if self._sock.state() != QAbstractSocket.UnconnectedState:
self._sock.waitForDisconnected()
msg = "connecting to ({}:{})"
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._pending = QTimer()
self._pending.timeout.connect(self._connection_failure)
self._pending.setSingleShot(True)
self._sock.connected.connect(self._connection_success)
self._pending.start(10000)
self._sock.connectToHost(self._host, port)
def greet(self):
self.send(query_tag("port", "udp"), "")
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ":" + payload + "\n"
data = message.encode()
self._sock.write(data)
class ClientDialog(QtGui.QDialog):
STATUS = ["Not Connected",
"Host Lookup",
"Establishing connection",
"Connected",
"The socket is bound to an address and port",
"For internal use only",
"Socket is about to close"]
def __init__(self, configdir, recentconndb):
QtGui.QDialog.__init__(self)
# Variables
self.configdir = configdir
self.recentconndb = recentconndb
self.socket = QTcpSocket()
self.status = self.STATUS[0]
logging.info("Starting Client")
# Properties
self.setModal(True)
# Setup Widget
self.layout = QtGui.QVBoxLayout()
self.mainWidget = ControllerClientWidget()
self.layout.addWidget(self.mainWidget)
self.setLayout(self.layout)
#Connections
self.connect(self.socket, QtCore.SIGNAL('error(QAbstractSocket::SocketError)'), self.displayError)
self.connect(self.socket, QtCore.SIGNAL('connected()'), self.connected)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.connectToServer)
self.connect(self.mainWidget.hostEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.connect(self.mainWidget.portEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.connect(self.mainWidget.passEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.connect(self.mainWidget.recentConnList, QtCore.SIGNAL('doubleClicked(const QModelIndex &)'), self.recentListHandler)
self.loadRecentConnDB()
self.enableConnectButton()
self.hide()
# Translations
self.current_language = "en_US"
self.uiTranslator = QtCore.QTranslator()
self.uiTranslator.load(":/languages/tr_en_US.qm")
self.retranslate()
self.updateStatus()
###
### Translation Related
###
def retranslate(self, language=None):
if language is not None:
self.current_language = language
self.uiTranslator.load(":/languages/tr_%s.qm" % self.current_language)
self.setWindowTitle(self.uiTranslator.translate("ControllerClientApp", "Controller Client"))
#
# Reusable Strings
#
self.clientStatusString = self.uiTranslator.translate("ControllerClientApp", "Status")
self.connectString = self.uiTranslator.translate("ControllerClientApp", "Connect")
self.disconnectString = self.uiTranslator.translate("ControllerClientApp", "Disconnect")
# --- End Reusable Strings
#
# Connection Settings
#
self.mainWidget.toolBox.setItemText(0, self.uiTranslator.translate("ControllerClientApp", "Connection Settings"))
self.mainWidget.hostLabel.setText(self.uiTranslator.translate("ControllerClientApp", "Host name (or IP Address)"))
self.mainWidget.portLabel.setText(self.uiTranslator.translate("ControllerClientApp", "Port"))
self.mainWidget.passLabel.setText(self.uiTranslator.translate("ControllerClientApp", "Passphrase"))
if self.status == self.STATUS[3]:
self.mainWidget.connectButton.setText(self.uiTranslator.translate("ControllerClientApp", self.disconnectString))
else:
self.mainWidget.connectButton.setText(self.uiTranslator.translate("ControllerClientApp", self.connectString))
self.updateStatus()
# --- End Connection Settings
#
# Recent Connections
#
self.mainWidget.toolBox.setItemText(1, self.uiTranslator.translate("ControllerClientApp", "Recent Connections"))
# --- End Recent Connections
##
## UI Related
##
def enableConnectButton(self):
if self.mainWidget.passEdit.text() == '' or self.mainWidget.hostEdit.text() == '' or self.mainWidget.portEdit.text() == '':
self.mainWidget.connectButton.setEnabled(False)
else:
self.mainWidget.connectButton.setEnabled(True)
def connected(self):
caddr = self.socket.peerName()
cport = self.socket.peerPort()
logging.info("Connected to %s:%s" % (caddr, cport))
self.sendPassphrase()
self.mainWidget.connectButton.setText(self.disconnectString)
self.disconnect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.connectToServer)
self.disconnect(self.mainWidget.passEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.disconnectFromHost)
self.connect(self.socket, QtCore.SIGNAL("disconnected()"), self.disconnectedFromHost)
'''
This function is for updating the sockets status and the statusLabel. It's called when a stateChanged signal is triggered.
'''
def updateStatus(self):
state = self.socket.state()
self.status = self.STATUS[state]
self.mainWidget.statusLabel.setText(self.clientStatusString + ": " + self.status)
'''
When there is a socket error this function is called to show the error in a QMessageBox
'''
def displayError(self, socketError):
messageBox = QtGui.QMessageBox.critical(self, QtCore.QString('Error!'),
QtCore.QString(self.socket.errorString()))
logging.error("Socket error %s" % self.socket.errorString())
##
## Connection Related
##
'''
Function that is called when connect button is pressed.
'''
def connectToServer(self):
caddr = self.mainWidget.hostEdit.text()
cport = int(self.mainWidget.portEdit.text())
cpass = self.mainWidget.passEdit.text()
self.connect(self.socket, QtCore.SIGNAL('stateChanged(QAbstractSocket::SocketState)'), self.updateStatus)
logging.info("Connecting to %s:%s" % (caddr, cport))
self.socket.connectToHost(caddr, cport)
if not self.socket.waitForConnected(1000):
logging.error("Socket error %s", self.socket.errorString())
else:
# Add to recent connections if connection is successful
self.addToRecentConnections(caddr, cport, cpass)
def disconnectFromHost(self):
self.socket.disconnectFromHost()
'''
Function for disconnecting the client from the host.
'''
def disconnectedFromHost(self):
logging.info("Disconnected from host")
self.disconnect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.disconnectFromHost)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'), self.connectToServer)
self.connect(self.mainWidget.passEdit, QtCore.SIGNAL('textChanged(QString)'), self.enableConnectButton)
self.mainWidget.connectButton.setText(self.connectString)
'''
Function for sending message to the connected server
'''
def sendMessage(self, message):
logging.info("Sending message: %s", message)
block = QtCore.QByteArray()
block.append(message)
self.socket.write(block)
'''
This function is for sending the passphrase to the server. It uses the sendMessage function
'''
def sendPassphrase(self):
self.sendMessage(self.mainWidget.passEdit.text())
'''
This function is for reading message from the server
'''
def readMessage(self):
message = self.socket.read(self.socket.bytesAvailable())
logging("Server said:%s", message)
return message
##
## Recent Connections Related
##
def loadRecentConnDB(self):
model = self.recentconndb.get_recentconn_model()
self.mainWidget.recentConnList.setModel(model)
self.mainWidget.recentConnList.setColumnHidden(2, True) # Hide the passphrase column
'''
This function is for adding a new connection to the recent connections. It checks whether it exists in the database or not.
'''
def addToRecentConnections(self, caddr, cport, cpass):
self.recentconndb.insert_recentconn(caddr, cport, cpass)
self.loadRecentConnDB()
'''
Handler for the recent connections list. When you click on a recent connection the details of the connection are loaded
'''
def recentListHandler(self, connection):
chost = connection.sibling(connection.row(), 0).data().toString()
cport = int(connection.sibling(connection.row(), 1).data().toString())
cpass = connection.sibling(connection.row(), 2).data().toString()
self.mainWidget.hostEdit.setText(chost)
self.mainWidget.portEdit.setValue(cport)
self.mainWidget.passEdit.setText(cpass)
self.mainWidget.toolBox.setCurrentWidget(self.mainWidget.connWidget)
class ConnectWindow(QMainWindow, Ui_ConnectWindow):
def __init__(self):
"""
Arguments:
- `self`:
"""
QMainWindow.__init__(self)
self.setupUi(self)
self.socket = QTcpSocket()
self.connect()
# Signals
conn_success = pyqtSignal('QTcpSocket')
exit_signal = pyqtSignal()
# Slots
@pyqtSlot()
def connect_server(self):
"""
"""
self.statusBar.clearMessage()
host = self.serverLine.text().trimmed()
port = self.portLine.text().trimmed()
if host and port:
self.socket.connectToHost(host, int(port))
else:
self.statusBar.showMessage(
'Enter valid a server address and port!')
@pyqtSlot()
def on_success(self):
"""
"""
if self.socket.waitForReadyRead(10000):
msg = self.socket.readData(1024)
msg = loads(msg)
if msg['head'] == CONN_SUCC:
self.statusBar.showMessage('Connection established')
self.conn_success.emit(self.socket)
self.hide()
else:
self.statusBar.showMessage('Server is full!')
self.socket.disconnectFromHost()
else:
self.on_error()
@pyqtSlot()
def on_error(self):
self.statusBar.showMessage('Connection cannot be established!')
def closeEvent(self, event):
"""
"""
dialog = ExitDialog()
if dialog.exec_():
event.accept()
else:
event.ignore()
# Connections
def connect(self):
"""
"""
self.connectButton.clicked.connect(self.connect_server)
self.exitButton.clicked.connect(self.close)
self.socket.error.connect(self.on_error)
self.socket.connected.connect(self.on_success)
class TcpClient(QObject):
packet = pyqtSignal(str)
connected = pyqtSignal()
disconnected = pyqtSignal()
def __init__(self, host):
super().__init__()
self._sock = QTcpSocket()
self._pending = None
self._host = host
self._log = logging.getLogger('tcp')
self._sock.connected.connect(self.greet)
self._sock.connected.connect(self.connected.emit)
self._sock.disconnected.connect(self.disconnected.emit)
self._sock.readyRead.connect(self.recv)
def set_host(self, host):
self._sock.disconnectFromHost()
self._host = host
def _cancel_pending(self):
self._pending.stop()
self._pending = None
self._sock.connected.disconnect(self._connection_success)
@pyqtSlot()
def _connection_success(self):
self._cancel_pending()
self._log.debug('connection successful')
@pyqtSlot()
def _connection_failure(self):
self._cancel_pending()
self._log.debug('connection failed')
def try_connect(self, port):
if self._pending:
self._cancel_pending()
self._sock.disconnectFromHost()
if self._sock.state() != QAbstractSocket.UnconnectedState:
self._sock.waitForDisconnected()
msg = 'connecting to ({}:{})'
msg = msg.format(self._host.toString(), port)
self._log.debug(msg)
self._pending = QTimer()
self._pending.timeout.connect(self._connection_failure)
self._pending.setSingleShot(True)
self._sock.connected.connect(self._connection_success)
self._pending.start(10000)
self._sock.connectToHost(self._host, port)
def greet(self):
self.send(query_tag('port', 'udp'), '')
def recv(self):
while self._sock.canReadLine():
data = bytes(self._sock.readLine()) # handle QByteArray
message = data.decode()
self.packet.emit(message)
def send(self, tag, payload):
message = tag + ':' + payload + '\n'
data = message.encode()
self._sock.write(data)
class ClientDialog(QtGui.QDialog):
STATUS = [
"Not Connected", "Host Lookup", "Establishing connection", "Connected",
"The socket is bound to an address and port", "For internal use only",
"Socket is about to close"
]
def __init__(self, configdir, recentconndb):
QtGui.QDialog.__init__(self)
# Variables
self.configdir = configdir
self.recentconndb = recentconndb
self.socket = QTcpSocket()
self.status = self.STATUS[0]
log.info("Starting Client")
# Properties
self.setModal(True)
# Setup Widget
self.layout = QtGui.QVBoxLayout()
self.mainWidget = ControllerClientWidget()
self.layout.addWidget(self.mainWidget)
self.setLayout(self.layout)
#Connections
self.connect(self.socket,
QtCore.SIGNAL('error(QAbstractSocket::SocketError)'),
self.displayError)
self.connect(self.socket, QtCore.SIGNAL('connected()'), self.connected)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'),
self.connectToServer)
self.connect(self.mainWidget.hostEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.portEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.passEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.recentConnList,
QtCore.SIGNAL('doubleClicked(const QModelIndex &)'),
self.recentListHandler)
self.loadRecentConnDB()
self.enableConnectButton()
self.hide()
# Translations
self.app = QtGui.QApplication.instance()
self.current_language = "en_US"
self.uiTranslator = QtCore.QTranslator()
self.uiTranslator.load(":/languages/tr_en_US.qm")
self.retranslate()
self.updateStatus()
###
### Translation Related
###
def retranslate(self, language=None):
if language is not None:
self.current_language = language
self.uiTranslator.load(":/languages/tr_%s.qm" % self.current_language)
self.setWindowTitle(
self.app.translate("ControllerClientApp", "Controller Client"))
#
# Reusable Strings
#
self.clientStatusString = self.app.translate("ControllerClientApp",
"Status")
self.connectString = self.app.translate("ControllerClientApp",
"Connect")
self.disconnectString = self.app.translate("ControllerClientApp",
"Disconnect")
# --- End Reusable Strings
#
# Connection Settings
#
self.mainWidget.toolBox.setItemText(
0, self.app.translate("ControllerClientApp",
"Connection Settings"))
self.mainWidget.hostLabel.setText(
self.app.translate("ControllerClientApp",
"Host name (or IP Address)"))
self.mainWidget.portLabel.setText(
self.app.translate("ControllerClientApp", "Port"))
self.mainWidget.passLabel.setText(
self.app.translate("ControllerClientApp", "Passphrase"))
if self.status == self.STATUS[3]:
self.mainWidget.connectButton.setText(
self.app.translate("ControllerClientApp",
self.disconnectString))
else:
self.mainWidget.connectButton.setText(
self.app.translate("ControllerClientApp", self.connectString))
self.updateStatus()
# --- End Connection Settings
#
# Recent Connections
#
self.mainWidget.toolBox.setItemText(
1, self.app.translate("ControllerClientApp", "Recent Connections"))
# --- End Recent Connections
##
## UI Related
##
def enableConnectButton(self):
if self.mainWidget.passEdit.text(
) == '' or self.mainWidget.hostEdit.text(
) == '' or self.mainWidget.portEdit.text() == '':
self.mainWidget.connectButton.setEnabled(False)
else:
self.mainWidget.connectButton.setEnabled(True)
def connected(self):
caddr = self.socket.peerName()
cport = self.socket.peerPort()
log.info("Connected to %s:%s" % (caddr, cport))
self.sendPassphrase()
self.mainWidget.connectButton.setText(self.disconnectString)
self.disconnect(self.mainWidget.connectButton,
QtCore.SIGNAL('pressed()'), self.connectToServer)
self.disconnect(self.mainWidget.passEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'),
self.disconnectFromHost)
self.connect(self.socket, QtCore.SIGNAL("disconnected()"),
self.disconnectedFromHost)
'''
This function is for updating the sockets status and the statusLabel. It's called when a stateChanged signal is triggered.
'''
def updateStatus(self):
state = self.socket.state()
self.status = self.STATUS[state]
self.mainWidget.statusLabel.setText(self.clientStatusString + ": " +
self.status)
'''
When there is a socket error this function is called to show the error in a QMessageBox
'''
def displayError(self, socketError):
messageBox = QtGui.QMessageBox.critical(
self, QtCore.QString('Error!'),
QtCore.QString(self.socket.errorString()))
log.error("Socket error %s" % self.socket.errorString())
##
## Connection Related
##
'''
Function that is called when connect button is pressed.
'''
def connectToServer(self):
caddr = self.mainWidget.hostEdit.text()
cport = int(self.mainWidget.portEdit.text())
cpass = self.mainWidget.passEdit.text()
self.connect(
self.socket,
QtCore.SIGNAL('stateChanged(QAbstractSocket::SocketState)'),
self.updateStatus)
log.info("Connecting to %s:%s" % (caddr, cport))
self.socket.connectToHost(caddr, cport)
if not self.socket.waitForConnected(1000):
log.error("Socket error %s", self.socket.errorString())
else:
# Add to recent connections if connection is successful
self.addToRecentConnections(caddr, cport, cpass)
def disconnectFromHost(self):
self.socket.disconnectFromHost()
'''
Function for disconnecting the client from the host.
'''
def disconnectedFromHost(self):
log.info("Disconnected from host")
self.disconnect(self.mainWidget.connectButton,
QtCore.SIGNAL('pressed()'), self.disconnectFromHost)
self.connect(self.mainWidget.connectButton, QtCore.SIGNAL('pressed()'),
self.connectToServer)
self.connect(self.mainWidget.passEdit,
QtCore.SIGNAL('textChanged(QString)'),
self.enableConnectButton)
self.mainWidget.connectButton.setText(self.connectString)
'''
Function for sending message to the connected server
'''
def sendMessage(self, message):
log.info("Sending message: %s", message)
block = QtCore.QByteArray()
block.append(message)
self.socket.write(block)
'''
This function is for sending the passphrase to the server. It uses the sendMessage function
'''
def sendPassphrase(self):
self.sendMessage(self.mainWidget.passEdit.text())
'''
This function is for reading message from the server
'''
def readMessage(self):
message = self.socket.read(self.socket.bytesAvailable())
log.info("Server said: %s", message)
return message
##
## Recent Connections Related
##
def loadRecentConnDB(self):
model = self.recentconndb.get_recentconn_model()
self.mainWidget.recentConnList.setModel(model)
self.mainWidget.recentConnList.setColumnHidden(
2, True) # Hide the passphrase column
'''
This function is for adding a new connection to the recent connections. It checks whether it exists in the database or not.
'''
def addToRecentConnections(self, caddr, cport, cpass):
self.recentconndb.insert_recentconn(caddr, cport, cpass)
self.loadRecentConnDB()
'''
Handler for the recent connections list. When you click on a recent connection the details of the connection are loaded
'''
def recentListHandler(self, connection):
chost = connection.sibling(connection.row(), 0).data().toString()
cport = int(connection.sibling(connection.row(), 1).data().toString())
cpass = connection.sibling(connection.row(), 2).data().toString()
self.mainWidget.hostEdit.setText(chost)
self.mainWidget.portEdit.setValue(cport)
self.mainWidget.passEdit.setText(cpass)
self.mainWidget.toolBox.setCurrentWidget(self.mainWidget.connWidget)
class ConnectWindow(QMainWindow, Ui_ConnectWindow):
def __init__(self):
"""
Arguments:
- `self`:
"""
QMainWindow.__init__(self)
self.setupUi(self)
self.socket = QTcpSocket()
self.connect()
# Signals
conn_success = pyqtSignal('QTcpSocket')
exit_signal = pyqtSignal()
# Slots
@pyqtSlot()
def connect_server(self):
"""
"""
self.statusBar.clearMessage()
host = self.serverLine.text().trimmed()
port = self.portLine.text().trimmed()
if host and port:
self.socket.connectToHost(host, int(port))
else:
self.statusBar.showMessage('Enter valid a server address and port!')
@pyqtSlot()
def on_success(self):
"""
"""
if self.socket.waitForReadyRead(10000):
msg = self.socket.readData(1024)
msg = loads(msg)
if msg['head'] == CONN_SUCC:
self.statusBar.showMessage('Connection established')
self.conn_success.emit(self.socket)
self.hide()
else:
self.statusBar.showMessage('Server is full!')
self.socket.disconnectFromHost()
else:
self.on_error()
@pyqtSlot()
def on_error(self):
self.statusBar.showMessage('Connection cannot be established!')
def closeEvent(self, event):
"""
"""
dialog = ExitDialog()
if dialog.exec_():
event.accept()
else:
event.ignore()
# Connections
def connect(self):
"""
"""
self.connectButton.clicked.connect(self.connect_server)
self.exitButton.clicked.connect(self.close)
self.socket.error.connect(self.on_error)
self.socket.connected.connect(self.on_success)
