class Server(QWidget):
def __init__(self):
QWidget.__init__(self)
self.serverOpen = False
self.tcpServer = None
self.tcpServerConnection = None
self.textEdit = None
self.lineEdit = None
self.create_widgets()
def create_widgets(self):
self.tcpServer = QTcpServer()
self.textEdit = QTextEdit()
self.textEdit.setReadOnly(True)
self.lineEdit = QLineEdit()
self.lineEdit.setPlaceholderText("Enter response")
self.lineEdit.setMaxLength(50)
self.lineEdit.setEnabled(True)
vBox = QVBoxLayout()
vBox.addWidget(self.textEdit)
vBox.addWidget(self.lineEdit)
self.setLayout(vBox)
self.tcpServer.newConnection.connect(self.accept_connection)
def add_message(self, message):
self.textEdit.moveCursor(QTextCursor.End)
self.textEdit.insertPlainText(message)
self.textEdit.moveCursor(QTextCursor.End)
def open_server(self):
if (len(self.lineEdit.text()) == 0):
self.add_message("You must enter a response\n")
QMessageBox.critical(self, "Error", "You must enter a response")
return False
self.tcpServer.listen(QHostAddress(__serverUrl__), 9000)
self.serverOpen = self.tcpServer.isListening()
if (self.serverOpen):
serverAddress = self.tcpServer.serverAddress().toString()
serverPort = self.tcpServer.serverPort()
self.add_message("Server opened on %s on port %d\n" %
(serverAddress, serverPort))
self.lineEdit.setEnabled(False)
else:
self.add_message(self.tcpServer.errorString())
QMessageBox.critical(self, "Error", self.tcpServer.errorString())
return True
def accept_connection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
self.tcpServerConnection.readyRead.connect(self.receive_data)
self.tcpServerConnection.disconnected.connect(self.socket_disconnected)
peerAddress = self.tcpServerConnection.peerAddress().toString()
peerPort = self.tcpServerConnection.peerPort()
self.add_message("Connected to %s on port %d\n" %
(peerAddress, peerPort))
def receive_data(self):
rxData = self.tcpServerConnection.readAll()
self.add_message("Received '" + rxData.data().decode('utf8') + "'\n")
txString = self.lineEdit.text()
self.tcpServerConnection.write(txString.encode())
self.add_message("Wrote '" + txString + "'\n")
def socket_disconnected(self):
self.add_message("Disconnected from client\n")
def close_server(self):
if (self.serverOpen):
self.tcpServer.close()
self.lineEdit.setEnabled(True)
class Server(QObject):
debug = True
log = sys.stderr
username = '******'
password = '******'
stopServing = pyqtSlot()
def __init__(self, parent=None):
super(Server, self).__init__(parent)
self.proxy_server = QTcpServer(self)
self.proxy_server.listen(QHostAddress.Any, 8000)
self.proxy_server.newConnection.connect(self.manage_request)
if self.debug:
self.log.write('Server running on localhost port %s\n\n' %
self.port())
def port(self):
return self.proxy_server.serverPort()
def addr(self):
return self.proxy_server.serverAddress().toString()
def stopServing(self):
if self.debug:
self.log.write('Service is stopping...\n\n')
# does not "close" the server, just stop listening...
self.proxy_server.close()
if self.proxy_server.hasPendingConnections():
socket = self.proxy_server.nextPendingConnection()
while socket:
socket.abort()
socket = self.proxy_server.nextPendingConnection()
def manage_request(self):
proxy_server = self.sender()
# Qt docs says that the caller of nextPendingConnection()
# is the parent of the socket
socket = proxy_server.nextPendingConnection()
socket.readyRead.connect(self.process_request)
socket.disconnected.connect(socket.deleteLater)
def authorize_request(self, request_data):
return True
header = QHttpRequestHeader(QString(request_data))
if self.debug:
self.log.write(header.toString())
auth = header.value('Proxy-Authorization')
if not auth:
return False
challenge = base64.b64encode(self.username + ':' + self.password)
return challenge == str(auth).split()[1]
def process_request(self):
socket = self.sender()
request_data = socket.readAll()
if not self.authorize_request(request_data):
socket.write('HTTP/1.1 407 Proxy Authentication Required\r\n')
if self.debug:
self.log.write('407 Proxy Authentication Required\n\n')
socket.write('Proxy-Authenticate: Basic realm="test"\r\n')
socket.write('\r\n')
socket.disconnectFromHost()
return
else:
# remove Proxy-Authorization header
start = request_data.indexOf('Proxy-Authorization:')
end = request_data.lastIndexOf('\r\n')
request_data.remove(start, end)
request_data.append('\r\n')
pos = request_data.indexOf('\r\n')
request_line = request_data.left(pos)
request_data.remove(0, pos + 2)
entries = request_line.split(' ')
method = entries[0]
address = entries[1]
version = entries[2]
port = '80'
if address.count(':') > 1:
protocol, host, port = address.split(':')
else:
protocol, host = address.split(':')
print('address' + str(address))
#url = QUrl( protocol + host )
url = QUrl.fromEncoded(address)
#url.setHost( host )
#url.setPort( int(port) )
if not url.isValid():
if self.debug:
self.log.write('Invalid URL: %s\n\n', url)
socket.disconnectFromHost()
return
host = url.host()
port = 80 if (url.port() < 0) else url.port()
req = url.encodedPath()
if url.hasQuery():
req.append('?').append(url.encodedQuery())
request_line = method + ' ' + req + ' ' + version + '\r\n'
request_data.prepend(request_line)
if self.debug:
self.log.write(method + ' ' + address + ' ' + version + '\n\n')
key = host + ':' + QString.number(port)
proxy_socket = socket.findChild(QTcpSocket, key)
if proxy_socket:
proxy_socket.setObjectName(key)
proxy_socket.setProperty('url', url)
proxy_socket.setProperty('request_data', request_data)
proxy_socket.write(request_data)
else:
proxy_socket = QTcpSocket(socket)
proxy_socket.setObjectName(key)
proxy_socket.setProperty('url', url)
proxy_socket.setProperty('request_data', request_data)
proxy_socket.connected.connect(self.send_request)
proxy_socket.readyRead.connect(self.transfer_data)
proxy_socket.disconnected.connect(self.close_connection)
proxy_socket.error.connect(self.close_connection)
proxy_socket.connectToHost(host, port)
def send_request(self):
proxy_socket = self.sender()
request_data = proxy_socket.property('request_data').toByteArray()
proxy_socket.write(request_data)
def transfer_data(self):
proxy_socket = self.sender()
socket = proxy_socket.parent()
socket.write(proxy_socket.readAll())
def close_connection(self):
proxy_socket = self.sender()
if proxy_socket:
socket = proxy_socket.parent()
if isinstance(socket, QTcpSocket) and socket:
socket.disconnectFromHost()
if proxy_socket.error() != QTcpSocket.RemoteHostClosedError:
url = proxy_socket.property('url').toUrl()
error_string = proxy_socket.errorString()
if self.debug:
self.log.write('Error for %s %s\n\n' % (url, error_string))
proxy_socket.deleteLater()
class ServerSocket(QObject):
"""Class defining a socket for the server."""
listening = pyqtSignal(tuple)
message_received = pyqtSignal(tuple)
client_disconnected = pyqtSignal(str)
def __init__(self):
"""Constructor."""
QObject.__init__(self)
self.__tcpServer = QTcpServer()
self.__active_sockets = []
self.__tcpServer.newConnection.connect(self.__new_connection)
def __new_connection(self):
"""Method handling a new connection to the server."""
# Connecting the new client
client = self.__tcpServer.nextPendingConnection()
client.readyRead.connect(self.read_message)
client.disconnected.connect(self.__find_disconnected_client)
client.disconnected.connect(client.deleteLater) # Not sure
self.__active_sockets.append(client) # Hyper important !!!
print("A new client connected from address '{}'.".format(
client.peerAddress().toString()))
def __find_disconnected_client(self):
"""Method trying to find the disconnected client."""
self.client_disconnected.emit(self.sender().localAddress().toString())
self.__active_sockets = []
for socket in self.__tcpServer.children()[1:]:
if int(socket.socketDescriptor()) <= 10000: # Socket is active
self.__active_sockets.append(socket)
def get_available_ips(self):
"""Method returning the list of available ips."""
return QNetworkInterface.allAddresses()
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 read_message(self):
"""Method handling the messages."""
for socket in self.__active_sockets:
instr = socket.readAll()
message = str(instr, encoding="utf8")
if message:
self.message_received.emit((message, socket))
def __send_msg(self, message, socket):
"""Method effectively sending a message."""
socket.write(bytes(message, encoding="utf8"))
socket.flush()
def send_message(self, message, recipient=None):
"""Method used to send a message to the clients."""
if recipient: # A single recipient was provided
if type(recipient) is not str: # Given socket directly
self.__send_msg(message, recipient)
else: # Given ip address
for socket in self.__active_sockets:
if socket.peerAddress().toString() == recipient:
self.__send_msg(message, socket)
else: # Send for everyone
for socket in self.__active_sockets:
self.__send_msg(message, socket)
# block = QByteArray()
# out = QDataStream(block, QIODevice.ReadWrite)
# out.setVersion(QDataStream.Qt_5_0)
# out.writeUInt16(0)
# message = bytes(message, encoding="utf8")
# out.writeString(message)
# out.device().seek(0)
# out.writeUInt16(block.size() - 2)
# socket.write(block)
def get_address(self):
"""Method returning the adress."""
return self.__tcpServer.serverAddress()
def get_port(self):
"""Method returning the port."""
return self.__tcpServer.serverPort()
class BaristaServer():
MIN_PORT = 0
MAX_PORT = 65535
DEFAULT_PORT = 4200
def __init__(self, application, ip, port, sessionPath):
self.application = application
self.server = None
self.port = int(port)
self.ip = QHostAddress.Any
if ip is not None:
self.ip = QHostAddress(ip)
self.sessionPath = sessionPath
self.configpath = os.path.join(self.sessionPath, "barista.conf") ####
self.hardware = []
self.trainOnHW = 0
self.transactionList = []
self._loadConfig()
self.checkHardware()
state = self._checkConfig()
self.start()
self.sessionManager = ServerSessionManager(self, self.sessionPath)
def start(self):
self.server = QTcpServer()
self.server.listen(self.ip, self.port)
self.server.newConnection.connect(self._newConnection)
if self.server.isListening():
hostIP = str(self.server.serverAddress().toString())
if hostIP == '0.0.0.0':
hostIP = '<any>'
sys.stdout.write("Hostname: " + socket.gethostname() + "\tIP: " +
hostIP + ":" + str(self.server.serverPort()) +
"\n")
else:
sys.stderr.write(
"Something went wrong. Server is not listening.\n")
logging.error("Something went wrong. Server is not listening.")
exit(1)
def getBaristaStatus(self, pid=""):
hardware = [k["name"] for k in self.hardware]
statusdict = {"trainOnHW": self.trainOnHW, "hardware": hardware}
statusdict["connections"] = len(self.transactionList)
statusdict["config"] = self._checkConfig(False)
statusdict["training"] = len(
self.sessionManager.findSessionIDsWithState(State.RUNNING)) is 0
statusdict["sessioncount"] = len(self.sessionManager.sessions)
statusdict["sessionpath"] = self.sessionPath
if pid is not "":
pidses = {}
sessions = set(self.sessionManager.findSessionIDsByProjectId(pid))
pidses["pid"] = pid
pidses["count"] = len(sessions)
pidses["running"] = len(
set(self.sessionManager.findSessionIDsWithState(State.RUNNING))
& sessions)
pidses["running"] += len(
set(self.sessionManager.findSessionIDsWithState(State.PAUSED))
& sessions)
pidses["waiting"] = len(
set(self.sessionManager.findSessionIDsWithState(State.WAITING))
& sessions)
pidses["finished"] = len(
set(self.sessionManager.findSessionIDsWithState(
State.FINISHED)) & sessions)
statusdict["projectsessions"] = pidses
return statusdict
def _newConnection(self):
transaction = ServerTransaction(self)
self.transactionList.append(transaction)
transaction.socketClosed.connect(
lambda item=transaction: self._deleteConnection(item))
transaction.acceptClient(self.server.nextPendingConnection())
def _deleteConnection(self, transaction):
index = self.transactionList.index(transaction)
del self.transactionList[index]
def _saveConfig(self):
#Save train on hardware
tosave = dict()
tosave["trainOnHW"] = self.trainOnHW
with open(self.configpath, "w") as file:
json.dump(tosave, file, sort_keys=True, indent=4)
def _loadConfig(self):
####
if not os.path.exists(self.configpath):
# TODO Default
pass
else:
with open(self.configpath, "r") as file:
res = json.load(file)
if "trainOnHW" in res:
self.trainOnHW = res["trainOnHW"]
else:
# TODO default
pass
def _checkConfig(self, verbose=True):
state = True
caffe_versions.loadVersions(self.sessionPath)
if caffe_versions.versionCount() == 0:
if verbose:
sys.stderr.write(
"Warning: There is no Caffeversion set. Use the Versionmanager inside Barista to set the Path.\n"
)
logging.warning(
"There is no Caffeversion set. Use the Versionmanager inside Barista to set the Path."
)
if self.trainOnHW >= len(self.hardware):
self.trainOnHW = 0
if verbose:
sys.stderr.write(
"Warning: Currently selected Hardware could not be matched against detected Hardware."
" Set to CPU mode!\n")
logging.warning(
"Currently selected Hardware could not be matched against detected Hardware."
" Set to CPU mode!")
return state
def checkHardware(self, verbose=True, transaction=None):
caffe_versions.loadVersions(self.sessionPath)
if caffe_versions.versionCount() == 0:
if verbose:
sys.stderr.write(
"Warning: Can't check hardware without Caffeversions\n")
logging.warning("Can't check hardware without Caffeversions")
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": False,
"error": "Can't check hardware without Caffeversions"
}
transaction.send(msg)
return
try:
binary = caffe_versions.getDefaultVersion().getBinarypath()
self.hardware = checkHardware(binary, not verbose, transaction)
if verbose:
sys.stdout.write("Finished scanning Hardware. " +
str(len(self.hardware)) + " devices found.\n")
logging.info("Finished scanning Hardware. %s devices found.",
str(len(self.hardware)))
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": True,
"finished": True,
"hardware": self.hardware,
"current": self.trainOnHW
}
transaction.send(msg)
except:
if verbose:
sys.stderr.write("Error: Failed to check hardware!\n")
logging.error("Failed to check hardware!")
if transaction:
msg = {
"key": Protocol.SCANHARDWARE,
"status": False,
"error": "Failed to check hardware!"
}
transaction.send(msg)
def setHardware(self, hid):
if hid >= len(self.hardware):
return False
self.trainOnHW = hid
self._saveConfig()
return True
