def send_message(self, message):
if not self.is_running:
raise Exception("Client cannot connect to IPC server. Not running.")
socket = QLocalSocket(self)
socket.connectToServer(self.socket_filename, QIODevice.WriteOnly)
if not socket.waitForConnected(self.timeout):
raise Exception(str(socket.errorString()))
socket.write(pickle.dumps(message))
if not socket.waitForBytesWritten(self.timeout):
raise Exception(str(socket.errorString()))
socket.disconnectFromServer()
def send_message(self, message):
if not self.is_running:
raise Exception(
"Client cannot connect to IPC server. Not running.")
socket = QLocalSocket(self)
socket.connectToServer(self.socket_filename, QIODevice.WriteOnly)
if not socket.waitForConnected(self.timeout):
raise Exception(str(socket.errorString()))
socket.write(pickle.dumps(message))
if not socket.waitForBytesWritten(self.timeout):
raise Exception(str(socket.errorString()))
socket.disconnectFromServer()
def main():
app = QtGui.QApplication(sys.argv)
androidToolsMainWin = AndroidToolsMainWindow()
uiMainWidget = Ui_MainWidget()
winOsArgv = WinCommandEnCoding.getOsArgv()
# single QApplication solution
# http://blog.csdn.net/softdzf/article/details/6704187
serverName = 'AndroidToolsServer'
clientSocket = QLocalSocket()
clientSocket.connectToServer(serverName)
QSettingsUtil.init()
# 如果连接成功， 表明server 已经存在，当前已经有实例在运行, 将参数发送给服务端
if clientSocket.waitForConnected(500):
# print u'连接成功 arg = ', winOsArgv
stream = QtCore.QTextStream(clientSocket)
# for i in range(0, len(winOsArgv)):
# stream << winOsArgv[i]
# 对于打开终端来说，所携带参数为第1位(打开文件的地址)，第0位为本执行程序地址
if len(winOsArgv) > 1:
stream << winOsArgv[1]
stream.setCodec('UTF-8')
stream.flush()
clientSocket.waitForBytesWritten()
# close client socket
clientSocket.close()
return app.quit()
# 如果没有实例执行，创建服务器
localServer = QLocalServer()
# 一直监听端口
localServer.listen(serverName)
# create db
createDb()
try:
uiMainWidget.setupUi(androidToolsMainWin, localServer, winOsArgv)
androidToolsMainWin.show()
sys.exit(app.exec_())
finally:
localServer.close()
def sendMessage(self, message):
assert(self._isRunning)
if self.isRunning():
socket = QLocalSocket(self)
socket.connectToServer(self._key, QIODevice.WriteOnly)
if not socket.waitForConnected(self._timeout):
return False
socket.write(message.encode('utf-8'))
if not socket.waitForBytesWritten(self._timeout):
return False
socket.disconnectFromServer()
return True
return False
def sendMessage(self, message):
assert (self._isRunning)
if self.isRunning():
socket = QLocalSocket(self)
socket.connectToServer(self._key, QIODevice.WriteOnly)
if not socket.waitForConnected(self._timeout):
return False
socket.write(message.encode('utf-8'))
if not socket.waitForBytesWritten(self._timeout):
return False
socket.disconnectFromServer()
return True
return False
class LivePlotClient(object):
def __init__(self, timeout=2000, size=2**20):
self.app = QCoreApplication.instance()
if self.app is None:
self.app = QCoreApplication([])
self.sock = QLocalSocket()
self.sock.connectToServer("LivePlot")
if not self.sock.waitForConnected():
raise EnvironmentError("Couldn't find LivePlotter instance")
self.sock.disconnected.connect(self.disconnect_received)
key = str(uuid.uuid4())
self.shared_mem = QSharedMemory(key)
if not self.shared_mem.create(size):
raise Exception("Couldn't create shared memory %s" % self.shared_mem.errorString())
logging.debug('Memory created with key %s and size %s' % (key, self.shared_mem.size()))
self.sock.write(key)
self.sock.waitForBytesWritten()
self.is_connected = True
self.timeout = timeout
atexit.register(self.close)
def close(self):
self.shared_mem.detach()
def send_to_plotter(self, meta, arr=None):
if not self.is_connected:
return
if meta["name"] is None:
meta["name"] = "*";
if arr is not None:
arrbytes = bytearray(arr)
arrsize = len(arrbytes)
if arrsize > self.shared_mem.size():
raise ValueError("Array too big %s > %s" % (arrsize, self.shared_mem.size()))
meta['arrsize'] = arrsize
meta['dtype'] = str(arr.dtype)
meta['shape'] = arr.shape
else:
meta['arrsize'] = 0
meta_bytes = json.dumps(meta).ljust(200)
if len(meta_bytes) > 200:
raise ValueError("meta object is too large (> 200 char)")
if arr is None:
self.sock.write(meta_bytes)
else:
if not self.sock.bytesAvailable():
self.sock.waitForReadyRead()
self.sock.read(2)
self.shared_mem.lock()
self.sock.write(meta_bytes)
region = self.shared_mem.data()
region[:arrsize] = arrbytes
self.shared_mem.unlock()
def plot_y(self, name, arr, extent=None, start_step=None):
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError('extent and start_step provide the same info and are thus mutually exclusive')
if extent is not None:
x0, x1 = extent
nx = len(arr)
start_step = x0, float(x1 - x0)/nx
meta = {
'name': name,
'operation':'plot_y',
'start_step': start_step,
'rank': 1,
}
self.send_to_plotter(meta, arr)
def plot_z(self, name, arr, extent=None, start_step=None):
'''
extent is ((initial x, final x), (initial y, final y))
start_step is ((initial x, delta x), (initial_y, final_y))
'''
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError('extent and start_step provide the same info and are thus mutually exclusive')
if extent is not None:
(x0, x1), (y0, y1) = extent
nx, ny = arr.shape
start_step = (x0, float(x1 - x0)/nx), (y0, float(y1 - y0)/ny)
meta = {
'name': name,
'operation':'plot_z',
'rank': 2,
'start_step': start_step,
}
self.send_to_plotter(meta, arr)
def plot_xy(self, name, xs, ys):
arr = np.array([xs, ys])
meta = {
'name': name,
'operation':'plot_xy',
'rank': 1,
}
self.send_to_plotter(meta, np.array([xs, ys]))
def append_y(self, name, point, start_step=None):
self.send_to_plotter({
'name': name,
'operation': 'append_y',
'value': point,
'start_step': start_step,
'rank': 1,
})
def append_xy(self, name, x, y):
self.send_to_plotter({
'name': name,
'operation': 'append_xy',
'value': (x, y),
'rank': 1,
})
def append_z(self, name, arr, start_step=None):
arr = np.array(arr)
meta = {
'name': name,
'operation':'append_z',
'rank': 2,
'start_step': start_step,
}
self.send_to_plotter(meta, arr)
def clear(self, name=None):
self.send_to_plotter({
'name': name,
'operation': 'clear'
})
def hide(self, name=None):
self.send_to_plotter({
'name': name,
'operation': 'close'
})
def remove(self, name=None):
self.send_to_plotter({
'name': name,
'operation': 'remove'
})
def disconnect_received(self):
self.is_connected = False
warnings.warn('Disconnected from LivePlotter server, plotting has been disabled')
#coding=utf-8
from time import sleep
from PyQt4.QtCore import QTextStream,QString
from PyQt4.QtNetwork import QLocalSocket
import random
import os
if __name__ == "__main__":
pid = os.getpid()
ls = QLocalSocket()
ls.connectToServer("localserver-test")
if ls.waitForConnected():
print "连接成功"
while True:
try:
ts = QTextStream(ls)
ts << QString.number(random.randrange(1000)) + "\nTTTTTTTTTT" + "\n PID = " + QString.number(pid) + "\n"
ts.flush()
print "werite :", ls.waitForBytesWritten()
print pid
sleep(1)
except Exception as e:
print e.message
class LivePlotClient(object):
def __init__(self, timeout=2000, size=2**20):
self.app = QCoreApplication.instance()
if self.app is None:
self.app = QCoreApplication([])
self.sock = QLocalSocket()
self.sock.connectToServer("LivePlot")
if not self.sock.waitForConnected():
raise EnvironmentError("Couldn't find LivePlotter instance")
self.sock.disconnected.connect(self.disconnect_received)
key = str(uuid.uuid4())
self.shared_mem = QSharedMemory(key)
if not self.shared_mem.create(size):
raise Exception("Couldn't create shared memory %s" %
self.shared_mem.errorString())
logging.debug('Memory created with key %s and size %s' %
(key, self.shared_mem.size()))
self.sock.write(key)
self.sock.waitForBytesWritten()
self.is_connected = True
self.timeout = timeout
atexit.register(self.close)
def close(self):
self.shared_mem.detach()
def send_to_plotter(self, meta, arr=None):
if not self.is_connected:
return
if meta["name"] is None:
meta["name"] = "*"
if arr is not None:
arrbytes = bytearray(arr)
arrsize = len(arrbytes)
if arrsize > self.shared_mem.size():
raise ValueError("Array too big %s > %s" %
(arrsize, self.shared_mem.size()))
meta['arrsize'] = arrsize
meta['dtype'] = str(arr.dtype)
meta['shape'] = arr.shape
else:
meta['arrsize'] = 0
meta_bytes = json.dumps(meta).ljust(200)
if len(meta_bytes) > 200:
raise ValueError("meta object is too large (> 200 char)")
if arr is None:
self.sock.write(meta_bytes)
else:
if not self.sock.bytesAvailable():
self.sock.waitForReadyRead()
self.sock.read(2)
self.shared_mem.lock()
self.sock.write(meta_bytes)
region = self.shared_mem.data()
region[:arrsize] = arrbytes
self.shared_mem.unlock()
def plot_y(self, name, arr, extent=None, start_step=None):
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError(
'extent and start_step provide the same info and are thus mutually exclusive'
)
if extent is not None:
x0, x1 = extent
nx = len(arr)
start_step = x0, float(x1 - x0) / nx
meta = {
'name': name,
'operation': 'plot_y',
'start_step': start_step,
'rank': 1,
}
self.send_to_plotter(meta, arr)
def plot_z(self, name, arr, extent=None, start_step=None):
'''
extent is ((initial x, final x), (initial y, final y))
start_step is ((initial x, delta x), (initial_y, final_y))
'''
arr = np.array(arr)
if extent is not None and start_step is not None:
raise ValueError(
'extent and start_step provide the same info and are thus mutually exclusive'
)
if extent is not None:
(x0, x1), (y0, y1) = extent
nx, ny = arr.shape
start_step = (x0, float(x1 - x0) / nx), (y0, float(y1 - y0) / ny)
meta = {
'name': name,
'operation': 'plot_z',
'rank': 2,
'start_step': start_step,
}
self.send_to_plotter(meta, arr)
def plot_xy(self, name, xs, ys):
arr = np.array([xs, ys])
meta = {
'name': name,
'operation': 'plot_xy',
'rank': 1,
}
self.send_to_plotter(meta, np.array([xs, ys]))
def append_y(self, name, point, start_step=None):
self.send_to_plotter({
'name': name,
'operation': 'append_y',
'value': point,
'start_step': start_step,
'rank': 1,
})
def append_xy(self, name, x, y):
self.send_to_plotter({
'name': name,
'operation': 'append_xy',
'value': (x, y),
'rank': 1,
})
def append_z(self, name, arr, start_step=None):
arr = np.array(arr)
meta = {
'name': name,
'operation': 'append_z',
'rank': 2,
'start_step': start_step,
}
self.send_to_plotter(meta, arr)
def clear(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'clear'})
def hide(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'close'})
def remove(self, name=None):
self.send_to_plotter({'name': name, 'operation': 'remove'})
def disconnect_received(self):
self.is_connected = False
warnings.warn(
'Disconnected from LivePlotter server, plotting has been disabled')
class QtSingleApplication(QApplication):
messageReceived = pyqtSignal(unicode)
def __init__(self, id, *argv):
super(QtSingleApplication, self).__init__(*argv)
self._id = id
self._activationWindow = None
self._activateOnMessage = False
# Is there another instance running?
self._outSocket = QLocalSocket()
self._outSocket.connectToServer(self._id)
self._isRunning = self._outSocket.waitForConnected()
if self._isRunning:
# Yes, there is.
self._outStream = QTextStream(self._outSocket)
self._outStream.setCodec('UTF-8')
else:
# No, there isn't.
self._outSocket = None
self._outStream = None
self._inSocket = None
self._inStream = None
self._server = QLocalServer()
self._server.listen(self._id)
self._server.newConnection.connect(self._onNewConnection)
def isRunning(self):
return self._isRunning
def id(self):
return self._id
def activationWindow(self):
return self._activationWindow
def setActivationWindow(self, activationWindow, activateOnMessage = True):
self._activationWindow = activationWindow
self._activateOnMessage = activateOnMessage
def activateWindow(self):
if not self._activationWindow:
return
self._activationWindow.setWindowState(
self._activationWindow.windowState() & ~Qt.WindowMinimized)
self._activationWindow.raise_()
self._activationWindow.activateWindow()
def sendMessage(self, msg):
if not self._outStream:
return False
self._outStream << msg << '\n'
self._outStream.flush()
return self._outSocket.waitForBytesWritten()
def _onNewConnection(self):
if self._inSocket:
self._inSocket.readyRead.disconnect(self._onReadyRead)
self._inSocket = self._server.nextPendingConnection()
if not self._inSocket:
return
self._inStream = QTextStream(self._inSocket)
self._inStream.setCodec('UTF-8')
self._inSocket.readyRead.connect(self._onReadyRead)
if self._activateOnMessage:
self.activateWindow()
def _onReadyRead(self):
while True:
msg = self._inStream.readLine()
if not msg: break
self.messageReceived.emit(msg)
