def main(): # ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("AirMemo_appid") app = QApplication(sys.argv) serverName = 'AirMemo_client' socket = QLocalSocket() socket.connectToServer(serverName) # 如果连接成功,表明server已经存在,当前已有实例在运行 if socket.waitForConnected(500): sys.exit(app.quit()) # 没有实例运行,创建服务器 localServer = QLocalServer() localServer.listen(serverName) try: setApp(app) link_db(config.LDB_FILENAME) tray = AirTray() mainWindow = Ui_MainWindow(tray) setting_win = Ui_Settings(tray) dict = {'main_win': mainWindow, 'setting_win': setting_win} tray.set_menu(dict) tray.show() # mainWindow.show() setting_win.show() sys.exit(app.exec_()) finally: localServer.close()
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(-1) if self._isRunning: # Yes, there is. self._outStream = QTextStream(self._outSocket) self._outStream.setCodec('UTF-8') else: # No, there isn't. # First we remove existing servers of that name that might not have been properly closed as the server died QLocalServer.removeServer(self._id) 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 __init__(self, id, *argv): super().__init__(*argv) self._id = id if sys.platform.startswith('linux'): self.setStyle('Fusion') # 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.removeServer(self._id) self._server.listen(self._id) self._server.newConnection.connect(self._onNewConnection)
def send_to_running_instance(socketname, command, target_arg, *, legacy_name=None, socket=None): """Try to send a commandline to a running instance. Blocks for CONNECT_TIMEOUT ms. Args: socketname: The name which should be used for the socket. command: The command to send to the running instance. target_arg: --target command line argument socket: The socket to read data from, or None. legacy_name: The legacy name to first try to connect to. Return: True if connecting was successful, False if no connection was made. """ if socket is None: socket = QLocalSocket() if (legacy_name is not None and _has_legacy_server(legacy_name)): name_to_use = legacy_name else: name_to_use = socketname log.ipc.debug("Connecting to {}".format(name_to_use)) socket.connectToServer(name_to_use) connected = socket.waitForConnected(CONNECT_TIMEOUT) if connected: log.ipc.info("Opening in existing instance") json_data = {'args': command, 'target_arg': target_arg, 'version': qutebrowser.__version__, 'protocol_version': PROTOCOL_VERSION} try: cwd = os.getcwd() except OSError: pass else: json_data['cwd'] = cwd line = json.dumps(json_data) + '\n' data = line.encode('utf-8') log.ipc.debug("Writing: {}".format(data)) socket.writeData(data) socket.waitForBytesWritten(WRITE_TIMEOUT) if socket.error() != QLocalSocket.UnknownSocketError: raise SocketError("writing to running instance", socket) else: socket.disconnectFromServer() if socket.state() != QLocalSocket.UnconnectedState: socket.waitForDisconnected(CONNECT_TIMEOUT) return True else: if socket.error() not in (QLocalSocket.ConnectionRefusedError, QLocalSocket.ServerNotFoundError): raise SocketError("connecting to running instance", socket) else: log.ipc.debug("No existing instance present (error {})".format( socket.error())) return False
def send_to_running_instance(cmdlist): """Try to send a commandline to a running instance. Blocks for CONNECT_TIMEOUT ms. Args: cmdlist: A list to send (URLs/commands) Return: True if connecting was successful, False if no connection was made. """ socket = QLocalSocket() socket.connectToServer(SOCKETNAME) connected = socket.waitForConnected(100) if connected: log.ipc.info("Opening in existing instance") line = json.dumps(cmdlist) + '\n' data = line.encode('utf-8') log.ipc.debug("Writing: {}".format(data)) socket.writeData(data) socket.waitForBytesWritten(WRITE_TIMEOUT) if socket.error() != QLocalSocket.UnknownSocketError: _socket_error("writing to running instance", socket) else: return True else: if socket.error() not in (QLocalSocket.ConnectionRefusedError, QLocalSocket.ServerNotFoundError): _socket_error("connecting to running instance", socket) else: log.ipc.debug("No existing instance present (error {})".format( socket.error())) return False
def connectAndSend(self, content): self.content = json.dumps(content) self.socket = QLocalSocket() self.socket.connectToServer(self.servername) # self.socket.connected.connect(self.ready) self.socket.write(self.content.encode('utf-8')) pass
def __init__(self, *args, **kwargs): # logger.debug("{} init...".format(self.__class__.__name__)) super(QSingleApplication, self).__init__(*args, **kwargs) # 使用路径作为appid # appid = QApplication.applicationFilePath().lower().split("/")[-1] # 使用固定的appid appid = "SHL_LHX_Wallet" # logger.debug("{} appid name: {}".format(self.__class__.__name__,appid)) # self._socketName = "qtsingleapp-" + appid self._socketName = appid # print("socketName", self._socketName) self._activationWindow = None self._activateOnMessage = False self._socketServer = None self._socketIn = None self._socketOut = None self._running = False # 先尝试连接 self._socketOut = QLocalSocket(self) self._socketOut.connectToServer(self._socketName) self._socketOut.error.connect(self.handleError) self._running = self._socketOut.waitForConnected() # logger.debug("local socket connect error: {}".format(self._socketOut.errorString())) if not self._running: # 程序未运行 # logger.debug("start init QLocalServer.") self._socketOut.close() del self._socketOut self._socketServer = QLocalServer(self) # 设置连接权限 self._socketServer.setSocketOptions(QLocalServer.UserAccessOption) self._socketServer.listen(self._socketName) self._socketServer.newConnection.connect(self._onNewConnection) self.aboutToQuit.connect(self.removeServer)
def main(): import sys app = QApplication(sys.argv) translator = QTranslator() locale = QLocale.system().name() translateFile = os.path.join(BASEDIR, 'i18n\\translations', '{}.qm'.format(locale)) if translator.load(translateFile): app.installTranslator(translator) # QApplication.setStyle(QStyleFactory.create('Fusion')) if boolean(conf.value('General/LargeFont')): font = QFont('Courier New', 14) app.setFont(font) serverName = 'Tafor' socket = QLocalSocket() socket.connectToServer(serverName) # 如果连接成功,表明server已经存在,当前已有实例在运行 if socket.waitForConnected(500): return(app.quit()) # 没有实例运行,创建服务器 localServer = QLocalServer() localServer.listen(serverName) try: window = MainWindow() window.show() sys.exit(app.exec_()) except Exception as e: logger.error(e, exc_info=True) finally: localServer.close()
def __init__(self, *args, **kwargs): super(QSingleApplication, self).__init__(*args, **kwargs) appid = QApplication.applicationFilePath().lower().split("/")[-1] self._socketName = "qtsingleapp-" + appid print("socketName", self._socketName) self._activationWindow = None self._activateOnMessage = False self._socketServer = None self._socketIn = None self._socketOut = None self._running = False # 先尝试连接 self._socketOut = QLocalSocket(self) self._socketOut.connectToServer(self._socketName) self._socketOut.error.connect(self.handleError) self._running = self._socketOut.waitForConnected() if not self._running: # 程序未运行 self._socketOut.close() del self._socketOut self._socketServer = QLocalServer(self) self._socketServer.listen(self._socketName) self._socketServer.newConnection.connect(self._onNewConnection) self.aboutToQuit.connect(self.removeServer)
def _has_legacy_server(name): """Check if there is a legacy server. Args: name: The name to try to connect to. Return: True if there is a server with the given name, False otherwise. """ socket = QLocalSocket() log.ipc.debug("Trying to connect to {}".format(name)) socket.connectToServer(name) err = socket.error() if err != QLocalSocket.UnknownSocketError: log.ipc.debug("Socket error: {} ({})".format( socket.errorString(), err)) os_x_fail = (sys.platform == 'darwin' and socket.errorString() == 'QLocalSocket::connectToServer: ' 'Unknown error 38') if err not in [QLocalSocket.ServerNotFoundError, QLocalSocket.ConnectionRefusedError] and not os_x_fail: return True socket.disconnectFromServer() if socket.state() != QLocalSocket.UnconnectedState: socket.waitForDisconnected(CONNECT_TIMEOUT) return False
def _send_to_running_instance(self, payload: bytes, pid: int) -> None: from PyQt5.QtCore import QByteArray from PyQt5.QtNetwork import QLocalSocket named_pipe = f"{BUNDLE_IDENTIFIER}.protocol.{pid}" log.debug( f"Opening a local socket to the running instance on {named_pipe} " f"(payload={self.redact_payload(payload)!r})" ) client = QLocalSocket() try: client.connectToServer(named_pipe) if not client.waitForConnected(): log.error(f"Unable to open client socket: {client.errorString()}") return client.write(QByteArray(payload)) client.waitForBytesWritten() client.disconnectFromServer() if client.state() == QLocalSocket.ConnectedState: client.waitForDisconnected() finally: del client log.debug("Successfully closed client socket")
def main(): # ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("AirMemo_appid") app = QApplication(sys.argv) serverName = 'rest_clock' socket = QLocalSocket() socket.connectToServer(serverName) # 如果连接成功,表明server已经存在,当前已有实例在运行 if socket.waitForConnected(500): sys.exit(app.quit()) # 没有实例运行,创建服务器 localServer = QLocalServer() localServer.listen(serverName) try: set_app(app) tray = clock_tray() timeout_win = Ui_Timeout(tray) settings_win = Ui_Settings(tray) tran_win = TranSignalWidget() tran_win.showSignal.connect(timeout_win.show) win_dict = {"timeout_win": timeout_win, 'settings_win': settings_win} tray.set_menu(win_dict) set_aps(tran_win) timeout_win.show() TIME_MISSION.set_aps_mission() MYAPS.start() logging.debug('APS jobs {}'.format(MYAPS.get_jobs())) sys.exit(app.exec_()) finally: localServer.close()
def init(): """Start listening to incoming connections.""" global _server if _server is not None: return server = QLocalServer(None) # find a free socket name to use for name in ids(): if server.listen(name): break else: # all names failed, try to contact and remove stale file if that fails socket = QLocalSocket() for name in ids(): socket.connectToServer(name) if not socket.waitForConnected(10000): QLocalServer.removeServer(name) if server.listen(name): break else: socket.disconnectFromServer() else: # no ids left, don't listen return app.aboutToQuit.connect(server.close) server.newConnection.connect(slot_new_connection) os.environ["FRESCOBALDI_SOCKET"] = name _server = server
def __init__(self, timeout=2000, size=2**28): 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.encode()) self.sock.waitForBytesWritten() self.is_connected = True self.timeout = timeout atexit.register(self.close)
def f_main(): """主程序,保证程序单实例运行""" app = QtWidgets.QApplication(sys.argv) app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5()) servername = "TransTools" socket = QLocalSocket() socket.connectToServer(servername) if socket.waitForConnected(500): # 程序只允许单例运行 showmsg("程序已运行!") return(app.quit()) # 没有实例运行,创建服务器 localServer = QLocalServer() localServer.listen(servername) try: main = Main() main.show() sys.exit(app.exec_()) except Exception as e: showmsg(str(e), type=QMessageBox.Critical) finally: localServer.close()
def __init__(self, appid, *argv): super(SingleApplication, self).__init__(*argv) self._appid = appid self._activationWindow = None self._activateOnMessage = False self._outSocket = QLocalSocket() self._outSocket.connectToServer(self._appid) self._isRunning = self._outSocket.waitForConnected() self._outStream = None self._inSocket = None self._inStream = None self._server = None self.settings = QSettings(SingleApplication.getSettingsPath(), QSettings.IniFormat) self.singleInstance = self.settings.value('singleInstance', 'on', type=str) in {'on', 'true'} if self._isRunning and self.singleInstance: self._outStream = QTextStream(self._outSocket) for a in argv[0][1:]: a = os.path.join(os.getcwd(), a) if os.path.isfile(a): self.sendMessage(a) break sys.exit(0) else: error = self._outSocket.error() if error == QLocalSocket.ConnectionRefusedError: self.close() QLocalServer.removeServer(self._appid) self._outSocket = None self._server = QLocalServer() self._server.listen(self._appid) self._server.newConnection.connect(self._onNewConnection)
def __init__(self, id, *argv): super(QSingleApplication, self).__init__(*argv) self._id = id self._activationWindow = None self._activateOnMessage = False self._server = None # Is there another instance running? self._outSocket = QLocalSocket() self._outSocket.connectToServer(self._id) self._outSocket.error.connect(self.handleError) 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) self.aboutToQuit.connect(self.removeServer)
def singleStart(self, appMain): self.appMain = appMain # Socket self.m_socket = QLocalSocket() self.m_socket.connected.connect(self.connectToExistingApp) self.m_socket.error.connect( lambda: self.startApplication(first_start=True)) self.m_socket.connectToServer(self.sock_file, QIODevice.WriteOnly)
def get(): """Return a remote Frescobaldi, or None if not available.""" socket = QLocalSocket() name = os.environ.get("FRESCOBALDI_SOCKET") for name in (name, ) if name else ids(): socket.connectToServer(name) if socket.waitForConnected(5000): from . import api return api.Remote(socket)
def is_running(): local_socket = QLocalSocket() local_socket.connectToServer("percentage_ide") if local_socket.state(): # It's running result = (True, local_socket) else: # It's not running result = (False, local_socket) return result
def hasPrevious(self, name, args): socket = QLocalSocket() socket.connectToServer(name, QLocalSocket.ReadWrite) if socket.waitForConnected(): if len(args) > 1: socket.write(args[1]) socket.flush() return True return False
def initLocalConnection(self): socket = QLocalSocket() socket.connectToServer(self.serverName) if socket.waitForConnected(self.TIME_OUT): self.isRuning = True if len(self.args) >= 3: data = self.args[1] + ',' + self.args[2] socket.writeData(data.encode()) socket.flush() socket.waitForBytesWritten() return self.newLocalServer()
def startClient(self) -> bool: Logger.log( "i", "Checking for the presence of an ready running Cura instance.") single_instance_socket = QLocalSocket(self._application) Logger.log("d", "Full single instance server name: %s", single_instance_socket.fullServerName()) single_instance_socket.connectToServer("ultimaker-cura") single_instance_socket.waitForConnected( msecs=3000) # wait for 3 seconds if single_instance_socket.state() != QLocalSocket.ConnectedState: return False # We only send the files that need to be opened. if not self._files_to_open: Logger.log("i", "No file need to be opened, do nothing.") return True if single_instance_socket.state() == QLocalSocket.ConnectedState: Logger.log( "i", "Connection has been made to the single-instance Cura socket.") # Protocol is one line of JSON terminated with a carriage return. # "command" field is required and holds the name of the command to execute. # Other fields depend on the command. if self._application.getPreferences().getValue( "cura/single_instance_clear_before_load"): payload = {"command": "clear-all"} single_instance_socket.write( bytes(json.dumps(payload) + "\n", encoding="ascii")) payload = {"command": "focus"} single_instance_socket.write( bytes(json.dumps(payload) + "\n", encoding="ascii")) for filename in self._files_to_open: payload = { "command": "open", "filePath": os.path.abspath(filename) } single_instance_socket.write( bytes(json.dumps(payload) + "\n", encoding="ascii")) payload = {"command": "close-connection"} single_instance_socket.write( bytes(json.dumps(payload) + "\n", encoding="ascii")) single_instance_socket.flush() single_instance_socket.waitForDisconnected() return True
def connect(cls, single=False): """连接启动器 :param single: 如果是单实例则客户端必须由启动器启动 """ name = os.environ.get('SplashConnectName', None) if not name: if single: # 单实例客户端必须由启动器启动 sys.exit(-1) return cls.client = QLocalSocket() cls.client.connectToServer(name)
def test_other_error(self, ipc_server, monkeypatch): socket = QLocalSocket() ipc_server._socket = socket monkeypatch.setattr(socket, 'error', lambda: QLocalSocket.ConnectionRefusedError) monkeypatch.setattr(socket, 'errorString', lambda: "Connection refused") socket.setErrorString("Connection refused.") with pytest.raises(ipc.Error, match=r"Error while handling IPC " r"connection: Connection refused \(error 0\)"): ipc_server.on_error(QLocalSocket.ConnectionRefusedError)
def main(): app = QApplication(sys.argv) app.setApplicationVersion("v1.3.1") app.setQuitOnLastWindowClosed(False) socket = QLocalSocket() socket.connectToServer("blender-launcher-server") is_running = socket.waitForConnected() if not is_running: socket.close() BlenderLauncher(app) app.exec_()
def __init__(self, serverName, parent=None): SocketInterface.__init__(self, serverName, parent=parent) socket = QLocalSocket(parent) socket.readyRead.connect(self.receiveMessage) socket.connectToServer(serverName) if socket.waitForConnected(1000): socket.write("Hello {0}!".format(serverName).encode("utf-8")) socket.flush() socket.waitForBytesWritten(1000) self.conn = socket else: self.log("Could not connect to SocketServer.")
def __init__(self, parent, name): super(__class__, self).__init__(parent) self._parent = parent self._name = name self._timeout = 1000 self._socket = QLocalSocket(self) self._socket.connectToServer(self._name) self._is_already_running = self._socket.waitForConnected(self._timeout) if not self.isAlreadyRunning(): self._server = QLocalServer(self) self._server.newConnection.connect(self._receive_data) self._server.removeServer(self._name) self._server.listen(self._name)
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 hasPrevious(self, name, args): print("önceki socket kontrol ediliyor...") socket = QLocalSocket() socket.connectToServer(name, QLocalSocket.ReadWrite) if socket.waitForConnected(): print("Önceki instansa argümanlar gönderiliyor.") if len(args) > 1: socket.write(args[1]) else: pass socket.flush() return True print(socket.errorString()) return False