class TCPServer(QObject):
def __init__(self, port):
QObject.__init__(self)
# logging instance
self.log = logging.getLogger('SMIGOL.TCPServer.{0}'.format(port))
# TCP server to listen for control commands
self.tcp_server = QTcpServer()
# TCP server listenning port
self.tcp_port = port
# TCP socket connection
self.tcp_connection = None
def start(self):
self.log.info("Starting TCP server...")
if self.tcp_server.listen(port=self.tcp_port):
txt = "Listening at http://localhost:{0} for a connection"
self.log.info(txt.format(self.tcp_server.serverPort()))
self.tcp_server.newConnection.connect(self._accept_connection)
else:
self.log.critical("Unable to start: {0}".format(
self.tcp_server.errorString()))
def disconnect(self):
if self.tcp_connection and self.tcp_connection.state(
) == QTcpSocket.ConnectedState:
loop = QEventLoop()
self.tcp_connection.disconnected.connect(loop.quit)
self.tcp_connection.disconnectFromHost()
self.log.debug("Entering disconnect state...")
if self.tcp_connection.state() == QTcpSocket.ConnectedState:
loop.exec_()
self.log.debug("Done waiting, closing server...")
if self.tcp_server.isListening():
self.tcp_server.close()
self.log.info("Server closed")
def _accept_connection(self):
if not self.tcp_connection:
self.tcp_connection = self.tcp_server.nextPendingConnection()
self.tcp_connection.error.connect(self._error_occurred)
txt = "Accepted connection"
self.log.debug(txt.format(self.tcp_server.serverPort()))
else:
self.log.warning("Received a second connection, ignoring it...")
self.tcp_server.nextPendingConnection()
def _error_occurred(self, socket_error):
if socket_error == QTcpSocket.RemoteHostClosedError:
self.log.info(self.tcp_connection.errorString())
else:
self.log.error(self.tcp_connection.errorString())
class ServerApp(FreeseerApp):
STATUS = ["Offline",
"Online"]
status = STATUS[0]
clients = []
passPhrase = ''
ipAddress = None
def __init__(self):
FreeseerApp.__init__(self)
self.resize(400, 300)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8(":/freeseer/logo.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.setWindowIcon(icon)
configdir = os.path.abspath(os.path.expanduser('~/.freeseer/'))
self.logger = Logger(configdir)
logging.info("Logger initialized")
self.server = QTcpServer(self)
logging.info("Starting Freeseer Server")
# Setup Widget
self.mainWidget = ControllerServerWidget()
self.setCentralWidget(self.mainWidget)
self.mainWidget.hostCombo.addItem(QtCore.QString("0.0.0.0"))
#Connections
self.connect(self.server, QtCore.SIGNAL('newConnection()'), self.acceptConnection)
self.connect(self.mainWidget.startButton, QtCore.SIGNAL('pressed()'), self.startServer)
self.connect(self.mainWidget.hostCombo, QtCore.SIGNAL('currentIndexChanged(int)'), self.ipComboBoxHandler)
self.connect(self.mainWidget.passEdit, QtCore.SIGNAL('textChanged(QString)'), self.onPassChanged)
# Initialize Passphrase Field
self.mainWidget.passEdit.setPlaceholderText("Passphrase required to start server")
self.mainWidget.startButton.setEnabled(False)
# Client Control
self.connect(self.mainWidget.clientStartButton, QtCore.SIGNAL('pressed()'), self.sendRecordCommand)
self.connect(self.mainWidget.clientStopButton, QtCore.SIGNAL('pressed()'), self.sendStopCommand)
self.connect(self.mainWidget.clientDisconnectButton, QtCore.SIGNAL('pressed()'), self.disconnectClients)
self.connect(self.mainWidget.clientList, QtCore.SIGNAL('itemSelectionChanged()'), self.updateClientButtons)
self.load_settings()
self.updateStatus(self.status)
###
### Translation Related
###
def retranslate(self):
self.setWindowTitle(self.uiTranslator.translate("ControllerServerApp", "Controller Server"))
#
# Reusuable Strings
#
self.serverStatusString = self.uiTranslator.translate("ControllerServerApp", "Server status")
self.startServerString = self.uiTranslator.translate("ControllerServerApp", "Start Server")
self.stopServerString = self.uiTranslator.translate("ControllerServerApp", "Stop Server")
self.startRecordingString = self.uiTranslator.translate("ControllerServerApp", "Start Recording")
self.stopRecordingString = self.uiTranslator.translate("ControllerServerApp", "Stop Recording")
self.pauseRecordingString = self.uiTranslator.translate("ControllerServerApp", "Pause Recording")
self.resumeRecordingString = self.uiTranslator.translate("ControllerServerApp", "Resume Recording")
# --- End Reusable Strings
#
# Server Settings
#
self.mainWidget.toolBox.setItemText(0, self.uiTranslator.translate("ControllerServerApp", "Server Settings"))
self.mainWidget.hostLabel.setText(self.uiTranslator.translate("ControllerServerApp", "IP Address"))
self.mainWidget.portLabel.setText(self.uiTranslator.translate("ControllerServerApp", "Port"))
self.mainWidget.passLabel.setText(self.uiTranslator.translate("ControllerServerApp", "Passphrase"))
# Button
if self.status == self.STATUS[0]:
self.mainWidget.startButton.setText(self.startServerString)
else:
self.mainWidget.startButton.setText(self.stopServerString)
# --- End Server Settings
#
# Control Clients
#
self.mainWidget.toolBox.setItemText(1, self.uiTranslator.translate("ControllerServerApp", "Control Clients"))
self.updateClientButtons()
self.mainWidget.clientDisconnectButton.setText(self.uiTranslator.translate("ControllerServerApp", "Disconnect"))
# --- End Control Clients
###
### Server Methods
###
def load_settings(self):
logging.info('Loading settings...')
configdir = os.path.abspath(os.path.expanduser('~/.freeseer/'))
self.config = Config(configdir)
# Load default language.
actions = self.menuLanguage.actions()
for action in actions:
if action.data().toString() == self.config.default_language:
action.setChecked(True)
self.translate(action)
break
def startServer(self):
if self.status == self.STATUS[0]: # Check if status is Offline
if self.ipAddress is None:
self.ipAddress = QHostAddress(self.mainWidget.hostCombo.currentText())
self.server.listen(self.ipAddress, PORT)
self.status = self.STATUS[1] # Set Running
self.mainWidget.hostCombo.setEnabled(False)
logging.info("Started server %s: %s", self.server.serverAddress().toString(), str(self.server.serverPort()))
elif self.status == self.STATUS[1]: # Check if status is Online
self.server.close()
self.status = self.STATUS[0] # Set status Offline
self.disconnectAllClients()
self.mainWidget.hostCombo.setEnabled(True)
self.ipAddress = None
self.updateStatus(self.status)
self.setPassPhrase()
self.setConnectionLabel()
self.retranslate()
def updateStatus(self, status):
self.mainWidget.statusLabel.setText("%s: %s" % (self.serverStatusString, status))
def setConnectionLabel(self):
text = "%s:%s" % (self.mainWidget.hostCombo.currentText(),
self.mainWidget.portEdit.text())
self.mainWidget.settingsEdit.setText(text)
if self.mainWidget.passEdit.text():
self.mainWidget.settingsEdit.setText("%s@%s" % (self.mainWidget.passEdit.text(),
text))
'''
This function is for changing the passphrase. It saves the new passphrase in the self.passPhrase after encoding it.
'''
def setPassPhrase(self):
self.passphrase = self.mainWidget.passEdit.text()
logging.info ("Passphrase set to %s", self.passphrase)
#self.passPhrase = base64.b64encode(self.passPhrase)
self.passphrase = str(self.passphrase)
self.passphrase = pwd_context.encrypt(self.passphrase)
'''
This function reads the passphrase sent from the client. It decodes the saved passphrase and the one that client sent and compares.
Client is accepted if the passphrases match. Otherwise client is rejected
'''
def readPassPhrase(self):
client = QtCore.QObject.sender(self)
message = client.read(client.bytesAvailable())
logging.info("Client said: %s", message)
if pwd_context.verify(message, self.passphrase) is False:
client.disconnectFromHost()
logging.info("Client rejected")
else:
self.clients.append(client)
self.updateList()
logging.info("Client accepted")
self.disconnect(client, QtCore.SIGNAL('readyRead()'), self.readPassPhrase)
self.connect(client, QtCore.SIGNAL('readyRead()'), self.startRead)
def onPassChanged(self):
"""Disable 'Start' button only when the passphrase field is empty."""
if self.mainWidget.passEdit.text():
self.mainWidget.startButton.setEnabled(True)
else:
self.mainWidget.startButton.setEnabled(False)
def ipComboBoxHandler(self):
self.ipAddress = QHostAddress(self.ipComboBox.itemText(self.ipComboBox.currentIndex()))
logging.info("Server IP changed to: %s", self.ipAddress.toString())
###
### Messaging
###
def startRead(self):
client = QtCore.QObject.sender(self)
message = client.read(client.bytesAvailable())
logging.info("Client said: %s", message)
return message
def sendMessage(self, client, message):
block = QtCore.QByteArray()
block.append(message)
client.write(block)
###
### Client List Methods
###
'''
This is the function to handle a new connection.
'''
def acceptConnection(self):
client = self.server.nextPendingConnection()
self.connect(client, QtCore.SIGNAL("disconnected()"), self.clientDisconnected)
self.connect(client, QtCore.SIGNAL('readyRead()'), self.readPassPhrase)
def clientDisconnected(self):
client = QtCore.QObject.sender(self)
logging.info("Client disconnected")
self.clients.remove(client)
self.updateList()
self.updateClientButtons()
'''
This method is to update the list
'''
def updateList(self):
self.mainWidget.clientList.clear()
for i in range(0, len(self.clients)):
client = self.clients[i]
listItem = ClientListItem(client)
self.mainWidget.clientList.addItem(listItem)
clientLabel = QtGui.QLabel('F1', self)
clientLabel.move(5 + (i * 20), 150)
def addClientToList(self, client):
self.clients.append(object)
listItem = ClientListItem(client)
self.mainWidget.clientList.addItem(listItem)
def removeClientFromTheList(self, client):
self.clients.remove(client)
self.updateList()
'''
Sends a record command to the selected clients
'''
def sendRecordCommand (self):
buttonText = self.mainWidget.clientStartButton.text()
# Find out what command to send
if buttonText == self.startRecordingString or buttonText == self.resumeRecordingString:
command = COMMANDS[1] # Set Record
elif buttonText == self.pauseRecordingString:
command = COMMANDS[2] # Set Pause
# Send command
for i in range(0, len(self.mainWidget.clientList.selectedItems())):
c_item = self.mainWidget.clientList.selectedItems()[i]
client = c_item.client
self.sendMessage(client, command)
if command == COMMANDS[1]: # Check if command is Record
c_item.changeStatus(CLIENT_STATUS[1]) # Set Recording
elif command == COMMANDS[2]: # Check if command is Pause
c_item.changeStatus(CLIENT_STATUS[2]) # Set Paused
logging.info("Sent %s command to %s" % (command, c_item.address))
self.updateClientButtons()
'''
Sends a stop command to selected clients
'''
def sendStopCommand (self):
command = COMMANDS[0] # Set Stop command
for i in range(0, len(self.mainWidget.clientList.selectedItems())):
c_item = self.mainWidget.clientList.selectedItems()[i]
client = c_item.client
self.sendMessage(client, command)
c_item.changeStatus(CLIENT_STATUS[3]) # Set Idle
logging.info("Sent %s command to %s" % (command, c_item.address))
self.updateClientButtons()
'''
Method to disconnect all clients selected from the list
'''
def disconnectClients(self):
for i in range(0, len(self.mainWidget.clientList.selectedItems())):
client = self.mainWidget.clientList.selectedItems()[i].client
client.disconnectFromHost()
'''
Method to disconnect all clients that are connected
'''
def disconnectAllClients(self):
for i in range(0, self.mainWidget.clientList.count()):
client = self.mainWidget.clientList.item(i).client
client.disconnectFromHost()
def updateClientButtons(self):
if len(self.mainWidget.clientList.selectedItems()) > 0:
self.mainWidget.clientDisconnectButton.setEnabled(True)
self.mainWidget.clientStartButton.setEnabled(True)
for i in range(0, len(self.mainWidget.clientList.selectedItems())):
clientStatus = self.mainWidget.clientList.selectedItems()[i].status
logging.debug("Client status: %s", clientStatus)
if clientStatus == CLIENT_STATUS[1]: # Client is Recording
self.mainWidget.clientStartButton.setText(self.pauseRecordingString)
self.mainWidget.clientStopButton.setEnabled(True)
elif clientStatus == CLIENT_STATUS[3]: # Client is Idle
self.mainWidget.clientStartButton.setText(self.startRecordingString)
self.mainWidget.clientStopButton.setEnabled(False)
elif clientStatus == CLIENT_STATUS[2]: # Client is Paused
self.mainWidget.clientStartButton.setText(self.resumeRecordingString)
self.mainWidget.clientStopButton.setEnabled(True)
else:
self.mainWidget.clientDisconnectButton.setEnabled(False)
self.mainWidget.clientStartButton.setEnabled(False)
self.mainWidget.clientStartButton.setText(self.startRecordingString)
self.mainWidget.clientStopButton.setEnabled(False)
self.mainWidget.clientStopButton.setText(self.stopRecordingString)
def isAvailable(port):
server = QTcpServer()
result = server.listen(QHostAddress("127.0.0.1"), port)
server.close()
return result
class HTTPProxy(QObject):
debug = True
log = sys.stderr
username = '******'
password = '******'
stopServing = pyqtSlot()
def __init__(self, parent=None):
super(HTTPProxy, 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('Proxy server running on 0.0.0.0 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', 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 SicsDEF(QGroupBox):
def __init__(self, ScanmanMain=""):
QGroupBox.__init__(self)
self.name = "Sics"
self.ui = Ui_Sics()
self.ui.setupUi(self)
self.scanman = ScanmanMain
self.ui.inbuffer_Edit.setText("Hello\n")
self.prm = DeviceParams()
self.cmplist = []
self.cmplist.append(CmpItem("inten2bgnd", 0))
self.cmplist.append(CmpItem("inten", 1))
self.cmplist.append(CmpItem("rho_inten", 2))
self.cmplist.append(CmpItem("rho_pos", 3))
self.cmplist.append(CmpItem("rho_fwhm", 4))
self.cmplist.append(CmpItem("rho_bgnd", 5))
self.compareprms = {}
self.compareprms["inten2bgnd"] = CmpItem(
"Minimum Intensity to Background", 2.0, 0, "greater")
self.compareprms["inten"] = CmpItem("Minimum Intensity", 20.0, 1,
"greater")
self.compareprms["rho_inten"] = CmpItem("Maximum %Rel StDev Intensity",
2.0, 2, "less")
self.compareprms["rho_pos"] = CmpItem("Maximum %Rel StDev Position",
2.0, 3, "less")
self.compareprms["rho_fwhm"] = CmpItem("Maximum %Rel StDev FWHM", 2.0,
4, "less")
self.compareprms["rho_bgnd"] = CmpItem("Maximum %Rel StDev Background",
2.0, 5, "less")
self.compareprms["err_ustrain"] = CmpItem("Maximum error in u-strain",
50.0, 6, "less")
self.reqcol = 0
self.curcol = 1
self.prevevents = float(0)
self.prevstatus = ""
self.worstpercent = float(0)
cmptbl = self.ui.compare_tbl
#for i in range(cmptbl.rowCount()):
# someitem = qt.QTableWidgetItem()
# someitem.setFlags(someitem.flags() & ~qtCore.Qt.ItemIsEditable)
# someitem.setTextAlignment(qtCore.Qt.AlignRight)
# someitem.setText("0")
# cmptbl.setItem(i,self.curcol,someitem)
cmptbl.setRowCount(len(self.compareprms))
cmptbl.setColumnCount(2)
#for item in self.compareprms.itervalues(): CDM itervalues depricated
for item in self.compareprms.values():
cmptbl.setItem(item.row, self.curcol, item.tblitem_cur)
cmptbl.setItem(item.row, self.reqcol, item.tblitem_req)
cmptbl.setVerticalHeaderItem(item.row, item.tblitem_header)
True
True
self.compare_tbl = mylib.Table(self.ui.compare_tbl)
#**************************************************************************************
def ClearValues(self):
self.prm.counter_value = float(0)
self.prm.counter_rate = float(0)
self.prm.accumulated_time = float(0)
self.prm.time_delta = float(0)
self.worstpercent = float(0)
#for item in self.cmplist:
# item.percent = float(0)
# item.cur = float(0)
for item in self.compareprms.itervalues():
item.percent = float(0)
item.cur = float(0)
#**************************************************************************************
def UpdateValues(self):
#paramdict = copy.deepcopy(self.scanman.ui.sourceGroupBox.paramdict)
paramdict = self.scanman.ui.sourceGroupBox.paramdict
try:
status = paramdict["DAQ_Status"]
except:
return False
if status == "Started":
if self.prevstatus != "Started":
self.ClearValues()
#self.prevstatus = status
#return True
#self.prevevents = float(paramdict["events"])
curtime = datetime.datetime.now()
delta = curtime - self.prm.timestamp
self.prm.time_delta = delta.total_seconds()
self.prm.accumulated_time += delta.total_seconds()
self.prm.timestamp = curtime
self.prm.count_delta = float(1.0)
#if paramdict.has_key("COUNT_METHOD"):
if "COUNT_METHOD" in paramdict.keys():
if paramdict[
"COUNT_METHOD"][:
-2] == "MONITOR" and self.worstpercent >= 100.0: #Required precision reached
self.prm.counter_value = float(
paramdict["COUNT_SIZE"]
) #So stop count by setting time as the preset time
else:
self.prm.counter_value = float(paramdict["time"])
else:
self.prm.counter_value = self.prm.accumulated_time
self.prm.counter_rate = self.worstpercent
if (self.prm.accumulated_time != 0):
self.average_rate = self.prm.counter_value / self.prm.accumulated_time
self.prevstatus = status
return True
elif (status == "Stopped" or status == 'Paused'):
self.ClearValues()
self.prevstatus = status
return False
#**************************************************************************************
def GetCurrent(self):
if "DAQ_Status" in self.scanman.ui.sourceGroupBox.paramdict: #This is data comming in from Histogram Server
if (self.UpdateValues() == False): return
cmptbl = self.ui.compare_tbl
rngList = self.scanman.ui.fitGroupBox.rangeList
rng = rngList[0]
if (rng.intensity == 0 or rng.fwhm == 0):
#self.ClearValues()
self.ui.worstprm_label.setText("N/A")
self.ui.worstval_edit.setText("%.4f" % (self.worstpercent))
return
for item in self.compareprms.itervalues():
item.req = float(cmptbl.item(item.row, self.reqcol).text())
self.compareprms["inten2bgnd"].Compare(rng.intensity / rng.background)
self.compareprms["inten"].Compare(rng.intensity)
self.compareprms["rho_inten"].Compare(rng.intensity_stdev /
rng.intensity * 100)
self.compareprms["rho_pos"].Compare(rng.position_stdev / rng.position *
100)
self.compareprms["rho_fwhm"].Compare(rng.fwhm_stdev / rng.fwhm * 100)
self.compareprms["rho_bgnd"].Compare(rng.background_stdev /
rng.background * 100)
self.compareprms["err_ustrain"].Compare(rng.errustrain)
itemkey = "inten2bgnd"
self.worstpercent = self.compareprms[itemkey].percent
worstitem = itemkey
#for itemkey in self.compareprms.iterkeys():
for itemkey in self.compareprms.keys():
item = self.compareprms[itemkey]
if item.percent < self.worstpercent:
self.worstpercent = item.percent
worstitem = itemkey
if self.worstpercent < 0: self.worstpercent = float(0)
self.ui.worstprm_label.setText(worstitem)
self.ui.worstval_edit.setText("%.4f" % (self.worstpercent))
True
#**************************************************************************************
def Device_print(self):
outstring = "Time: %s, Count: %10d, Delta: %6d, Time: %8.6f, Rate: %8.2f, Ave: %8.2f\r\n" % (
str(self.prm.timestamp.time()), self.prm.counter_value,
self.prm.count_delta, self.prm.time_delta, self.prm.counter_rate,
self.prm.average_rate)
return outstring
#**************************************************************************************
def Device_read(self):
outstring = "READ %c%c%c%c %s %.6f %10d %8.2f\r\n" % (
self.prm.state, self.prm.terminal_due, self.prm.range_error,
self.prm.range_gated, str(
self.prm.timestamp.time()), self.prm.accumulated_time,
self.prm.counter_value, self.prm.counter_rate)
paramdict = self.scanman.ui.sourceGroupBox.paramdict
if self.prm.counter_value >= float(
paramdict["COUNT_SIZE"]
) and paramdict["COUNT_METHOD"].find(
"MONITOR"
) > -1: #Only do a quick clear when performing a scan with the monitor.
self.prm.counter_value = float(0)
self.worstpercent = float(0)
True
return outstring
#**************************************************************************************
def ReadFromServer(self):
True
#**************************************************************************************
def StartServer(self):
self.host = "localhost"
self.port = int(self.ui.port_Edit.text())
self.ui.inbuffer_Edit.append("ServerStart on port:" + str(self.port))
self.timestamp = datetime.datetime.now()
self.tcpServer = QTcpServer(self)
self.tcpServer.listen(QHostAddress(self.host), self.port)
curtime = datetime.datetime.now()
delta = curtime - self.timestamp
self.time_delta = delta.total_seconds()
self.scanman.ui.fitGroupBox.fittedsignal.connect(self.GetCurrent)
self.connections = []
self.connect(self.tcpServer, qtCore.SIGNAL("newConnection()"),
self.addConnection)
self.ui.status_Edit.setText("On")
True
#**************************************************************************************
def addConnection(self):
try:
clientConnection = self.tcpServer.nextPendingConnection()
clientConnection.nextBlockSize = 0
self.connections.append(clientConnection)
self.connect(clientConnection, qtCore.SIGNAL("readyRead()"),
self.receiveMessage)
self.connect(clientConnection, qtCore.SIGNAL("disconnected()"),
self.removeConnection)
self.connect(clientConnection, qtCore.SIGNAL("error()"),
self.socketError)
except:
self.ui.inbuffer_Edit.append("Failed to add connection")
True
#**************************************************************************************
def receiveMessage(self):
try:
s = self.sender()
reply = ""
#self.disconnect(s, qtCore.SIGNAL("readyRead()"), self.receiveMessage) #Histogram server polls very quickly, rather let a request be completed before starting another one
if s.bytesAvailable() > 0:
textFromClient = s.readAll()
textFromClient = textFromClient.toLower()
#outstring = "%s - %s:%d -> %s" % (datetime.datetime.now().time(), s.peerAddress().toString(), s.peerPort(), textFromClient)
#self.ui.inbuffer_Edit.append(outstring)
if textFromClient.contains("pause"):
self.prm.state = 'P'
reply = "OK\r\n"
elif textFromClient.contains("continue"):
self.prm.state = 'R'
reply = "OK\r\n"
elif textFromClient.contains("resume"):
self.prm.state = 'R'
reply = "OK\r\n"
elif textFromClient.contains("start"):
self.prm.state = 'R'
reply = "OK\r\n"
elif textFromClient.contains("stop"):
self.prm.state = 'S'
#self.ClearValues()
reply = "OK\r\n"
elif textFromClient.contains("read"):
time.sleep(0.0001)
reply = self.Device_read()
elif textFromClient.contains("test"):
True
else:
reply = self.Device_print()
self.sendMessage(reply, s.socketDescriptor())
#self.connect(s, qtCore.SIGNAL("readyRead()"), self.receiveMessage)
except:
self.ui.inbuffer_Edit.append(
"Failed read message and send response")
True
#**************************************************************************************
def sendMessage(self, text, socketId):
try:
for s in self.connections:
if s.socketDescriptor() == socketId:
s.write(text)
except:
self.ui.inbuffer_Edit.append("Failed send response")
True
#**************************************************************************************
def removeConnection(self):
s = self.sender()
self.connections.remove(s)
True
#**************************************************************************************
def socketError(self):
self.ui.inbuffer_Edit.append("Socket Error...\n")
True
#**************************************************************************************
def StopServer(self):
for i in range(len(self.connections)):
self.connections[0].close(
) #Once removed, all will shift forward in the array
self.tcpServer.close()
self.scanman.ui.fitGroupBox.fittedsignal.disconnect(self.GetCurrent)
self.ui.status_Edit.setText("Off")
def DoIt(self, astr=""):
self.ui.inbuffer_Edit.setText(astr)
class HTTPProxy(QObject):
debug = True
log = sys.stderr
username = '******'
password = '******'
stopServing = pyqtSlot()
def __init__(self, parent=None):
super(HTTPProxy, 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('Proxy server running on 0.0.0.0 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', 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 ControlServer(QObject):
# Signal to inform that the set logging level command has been received
logging_command_received = pyqtSignal(int)
# Signal to inform that the quit command has been received and the system should exit
quit_command_received = pyqtSignal()
def __init__(self):
QObject.__init__(self)
# logging instance
self.log = logging.getLogger('GDAIS.ControlServer')
# TCP server to listen for control commands
self.tcp_server = QTcpServer()
# regexp to check if command is 'set_log_level'
self.valid_loglevel = re.compile(r"^set_log_level (\d?0)$")
def start(self):
self.log.info("Starting TCP server...")
if self.tcp_server.listen(port=12345):
txt = "Listening at http://localhost:{0} for commands"
self.log.info(txt.format(self.tcp_server.serverPort()))
self.tcp_server.newConnection.connect(self._accept_connection)
else:
self.log.warn("Unable to start: {0}".format(
self.tcp_server.errorString()))
# define a timer to auto-quit the app after 10 sec
timeout = 10 # seconds
self.log.warn(
"GDAIS will run for {0} seconds and then die".format(timeout))
self.timer = QTimer()
self.timer.timeout.connect(self.quit)
self.timer.start(timeout * 1000) # msec
def quit(self):
if self.tcp_connection and self.tcp_connection.state(
) == QTcpSocket.ConnectedState:
loop = QEventLoop()
self.tcp_connection.disconnected.connect(loop.quit)
self.tcp_connection.disconnectFromHost()
self.log.debug("Entering disconnect state...")
if self.tcp_connection.state() == QTcpSocket.ConnectedState:
loop.exec_()
self.log.debug("Done waiting, closing server...")
if self.tcp_server.isListening():
self.tcp_server.close()
self.quit_command_received.emit()
def _accept_connection(self):
self.tcp_connection = self.tcp_server.nextPendingConnection()
self.tcp_connection.readyRead.connect(self._read_data)
self.tcp_connection.error.connect(self._error_ocurred)
self.log.debug("Accepted connection")
def _read_data(self):
tcp_data = self.tcp_connection.readAll()
if tcp_data == 'quit':
self.log.info("Received 'quit' command")
self.quit()
elif self.valid_loglevel.match(tcp_data):
self.log.info("Received 'set_log_level' command")
try:
new_level = int(self.valid_loglevel.match(tcp_data).group(1))
except ValueError:
self.log.exception("Level has to be an integer value")
else:
self.logging_command_received.emit(new_level)
else:
self.log.error("Received unknown command: {0}".format(tcp_data))
def _error_ocurred(self, socket_error):
if socket_error == QTcpSocket.RemoteHostClosedError:
self.log.info(self.tcp_connection.errorString())
else:
self.log.error(self.tcp_connection.errorString())
class Dialog(QDialog):
TotalBytes = 50 * 1024 * 1024
PayloadSize = 65536
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.settings = QSettings('settings.ini', QSettings.IniFormat)
self.tcpServer = QTcpServer()
self.chBox = QCheckBox("Print log to window")
self.text = QPlainTextEdit()
self.serverStatusLabel = QLabel("Server ready")
self.lblFileName = QLabel("Choose file before start!")
self.saveButton = QPushButton("&Choose file...")
self.startButton = QPushButton("&Start")
self.stopButton = QPushButton("S&top")
self.quitButton = QPushButton("&Quit")
self.file = None
self.tcpServerConnection = None
self._lineCounter = 0
self._lineBuf = ''
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.stopButton, QDialogButtonBox.RejectRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
clearButon = QPushButton('&Clear')
self.saveButton.clicked.connect(self.savedlg)
self.startButton.clicked.connect(self.start)
self.stopButton.clicked.connect(self.stopClicked)
self.quitButton.clicked.connect(self.close)
clearButon.clicked.connect(self.text.clear)
self.tcpServer.newConnection.connect(self.acceptConnection)
saveLayout = QHBoxLayout()
saveLayout.addWidget(self.lblFileName)
saveLayout.addStretch(1)
saveLayout.addWidget(self.saveButton)
topTextLayout = QHBoxLayout()
topTextLayout.addWidget(self.chBox)
topTextLayout.addStretch(1)
topTextLayout.addWidget(clearButon)
mainLayout = QVBoxLayout()
mainLayout.addLayout(saveLayout)
mainLayout.addLayout(topTextLayout)
mainLayout.addWidget(self.text)
mainLayout.addWidget(self.serverStatusLabel)
# mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.title = "Simple Logger"
self.ver = '1.0'
self.setWindowIcon(QIcon('./icon.png'))
self.setWindowTitle("{} {}".format(self.title, self.ver))
def start(self):
if self.file is None:
QMessageBox.critical(self, self.title, "Unable open log file.\nPlease, select another file.")
return
self.startButton.setEnabled(False)
while not self.tcpServer.isListening() and not self.tcpServer.listen(port=9112):
ret = QMessageBox.critical(self, self.title,
"Unable to start the test: %s." % self.tcpServer.errorString(),
QMessageBox.Retry | QMessageBox.Cancel)
if ret == QMessageBox.Cancel:
return
self.serverStatusLabel.setText("Waiting connection ...")
def acceptConnection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
self.tcpServerConnection.readyRead.connect(self.updateLog)
self.tcpServerConnection.error.connect(self.displayError)
self.file = QFile(self.filename)
if not self.file.open(QFile.Append):
QMessageBox.warning(self, self.title, "Unable to write file {}:\n{}.".format(self.filename, self.file.errorString()))
self.file = None
return
self.textStream = QTextStream(self.file)
self.textStream.setCodec('UTF-8')
self.serverStatusLabel.setText("Logging ...")
self.tcpServer.close()
def savedlg(self):
self.filename = QFileDialog.getSaveFileName(self, "Log Filename", self.settings.value('directories/dir_save', QDir.currentPath()), "Text (*.log *.txt);;All (*)")
if not self.filename:
return
self.file = QFile(self.filename)
self.lblFileName.setText(self.filename)
if not self.file.open(QFile.WriteOnly):
QMessageBox.warning(self, self.title, "Unable to write file {}:\n{}.".format(self.filename, self.file.errorString()))
self.file = None
return
self.textStream = QTextStream(self.file)
self.textStream.setCodec('UTF-8')
self.settings.setValue('directories/dir_save', QFileInfo(self.file).path())
self.file.close()
def updateLog(self):
if self.tcpServerConnection.bytesAvailable():
data = self.tcpServerConnection.readAll()
line = "{}".format(str(data.data().decode()))
if self.chBox.isChecked():
self._lineCounter += 1
self._lineBuf += line
if self._lineCounter > 10:
self.text.appendPlainText(self._lineBuf)
self._lineCounter = 0
self._lineBuf = ''
self.textStream << line
self.file.flush()
# self.serverStatusLabel.setText(line)
def closeEvent(self, event):
if self.file is not None:
self.file.flush()
self.file.close()
def stopClicked(self):
if self.tcpServerConnection is not None:
self.tcpServerConnection.close()
self.file.close()
self.startButton.setEnabled(True)
self.serverStatusLabel.setText("Logger ready")
def displayError(self, socketError):
if socketError == QTcpSocket.RemoteHostClosedError:
return
QMessageBox.information(self, "Network error",
"The following error occured: %s." % self.tcpServer.errorString())
self.tcpServer.close()
self.file.close()
self.serverStatusLabel.setText("Logger ready")
self.startButton.setEnabled(True)
class Dialog(QDialog):
TotalBytes = 50 * 1024 * 1024
PayloadSize = 65536
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.settings = QSettings('settings.ini', QSettings.IniFormat)
self.tcpServer = QTcpServer()
self.chBox = QCheckBox("Print log to window")
self.text = QPlainTextEdit()
self.serverStatusLabel = QLabel("Server ready")
self.lblFileName = QLabel("Choose file before start!")
self.saveButton = QPushButton("&Choose file...")
self.startButton = QPushButton("&Start")
self.stopButton = QPushButton("S&top")
self.quitButton = QPushButton("&Quit")
self.file = None
self.tcpServerConnection = None
self._lineCounter = 0
self._lineBuf = ''
buttonBox = QDialogButtonBox()
buttonBox.addButton(self.startButton, QDialogButtonBox.ActionRole)
buttonBox.addButton(self.stopButton, QDialogButtonBox.RejectRole)
buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
clearButon = QPushButton('&Clear')
self.saveButton.clicked.connect(self.savedlg)
self.startButton.clicked.connect(self.start)
self.stopButton.clicked.connect(self.stopClicked)
self.quitButton.clicked.connect(self.close)
clearButon.clicked.connect(self.text.clear)
self.tcpServer.newConnection.connect(self.acceptConnection)
saveLayout = QHBoxLayout()
saveLayout.addWidget(self.lblFileName)
saveLayout.addStretch(1)
saveLayout.addWidget(self.saveButton)
topTextLayout = QHBoxLayout()
topTextLayout.addWidget(self.chBox)
topTextLayout.addStretch(1)
topTextLayout.addWidget(clearButon)
mainLayout = QVBoxLayout()
mainLayout.addLayout(saveLayout)
mainLayout.addLayout(topTextLayout)
mainLayout.addWidget(self.text)
mainLayout.addWidget(self.serverStatusLabel)
# mainLayout.addStretch(1)
mainLayout.addSpacing(10)
mainLayout.addWidget(buttonBox)
self.setLayout(mainLayout)
self.title = "Simple Logger"
self.ver = '1.0'
self.setWindowIcon(QIcon('./icon.png'))
self.setWindowTitle("{} {}".format(self.title, self.ver))
def start(self):
if self.file is None:
QMessageBox.critical(
self, self.title,
"Unable open log file.\nPlease, select another file.")
return
self.startButton.setEnabled(False)
while not self.tcpServer.isListening() and not self.tcpServer.listen(
port=9112):
ret = QMessageBox.critical(
self, self.title,
"Unable to start the test: %s." % self.tcpServer.errorString(),
QMessageBox.Retry | QMessageBox.Cancel)
if ret == QMessageBox.Cancel:
return
self.serverStatusLabel.setText("Waiting connection ...")
def acceptConnection(self):
self.tcpServerConnection = self.tcpServer.nextPendingConnection()
self.tcpServerConnection.readyRead.connect(self.updateLog)
self.tcpServerConnection.error.connect(self.displayError)
self.file = QFile(self.filename)
if not self.file.open(QFile.Append):
QMessageBox.warning(
self, self.title, "Unable to write file {}:\n{}.".format(
self.filename, self.file.errorString()))
self.file = None
return
self.textStream = QTextStream(self.file)
self.textStream.setCodec('UTF-8')
self.serverStatusLabel.setText("Logging ...")
self.tcpServer.close()
def savedlg(self):
self.filename = QFileDialog.getSaveFileName(
self, "Log Filename",
self.settings.value('directories/dir_save', QDir.currentPath()),
"Text (*.log *.txt);;All (*)")
if not self.filename:
return
self.file = QFile(self.filename)
self.lblFileName.setText(self.filename)
if not self.file.open(QFile.WriteOnly):
QMessageBox.warning(
self, self.title, "Unable to write file {}:\n{}.".format(
self.filename, self.file.errorString()))
self.file = None
return
self.textStream = QTextStream(self.file)
self.textStream.setCodec('UTF-8')
self.settings.setValue('directories/dir_save',
QFileInfo(self.file).path())
self.file.close()
def updateLog(self):
if self.tcpServerConnection.bytesAvailable():
data = self.tcpServerConnection.readAll()
line = "{}".format(str(data.data().decode()))
if self.chBox.isChecked():
self._lineCounter += 1
self._lineBuf += line
if self._lineCounter > 10:
self.text.appendPlainText(self._lineBuf)
self._lineCounter = 0
self._lineBuf = ''
self.textStream << line
self.file.flush()
# self.serverStatusLabel.setText(line)
def closeEvent(self, event):
if self.file is not None:
self.file.flush()
self.file.close()
def stopClicked(self):
if self.tcpServerConnection is not None:
self.tcpServerConnection.close()
self.file.close()
self.startButton.setEnabled(True)
self.serverStatusLabel.setText("Logger ready")
def displayError(self, socketError):
if socketError == QTcpSocket.RemoteHostClosedError:
return
QMessageBox.information(
self, "Network error",
"The following error occured: %s." % self.tcpServer.errorString())
self.tcpServer.close()
self.file.close()
self.serverStatusLabel.setText("Logger ready")
self.startButton.setEnabled(True)
