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 remoe 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 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 startServer(self) -> None: self._single_instance_server = QLocalServer() if self._single_instance_server: self._single_instance_server.newConnection.connect(self._onClientConnected) self._single_instance_server.listen("stereotech-steslicer") else: Logger.log("e", "Single instance server was not created.")
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, 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 __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 __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 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 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, socketname, parent=None): """Start the IPC server and listen to commands. Args: socketname: The socketname to use. parent: The parent to be used. """ super().__init__(parent) self.ignored = False self._socketname = socketname self._timer = usertypes.Timer(self, 'ipc-timeout') self._timer.setInterval(READ_TIMEOUT) self._timer.timeout.connect(self.on_timeout) if os.name == 'nt': # pragma: no cover self._atime_timer = None else: self._atime_timer = usertypes.Timer(self, 'ipc-atime') self._atime_timer.setInterval(ATIME_INTERVAL) self._atime_timer.timeout.connect(self.update_atime) self._atime_timer.setTimerType(Qt.VeryCoarseTimer) self._server = QLocalServer(self) self._server.newConnection.connect(self.handle_connection) self._socket = None self._socketopts_ok = os.name == 'nt' if self._socketopts_ok: # pragma: no cover # If we use setSocketOptions on Unix with Qt < 5.4, we get a # NameError while listening... log.ipc.debug("Calling setSocketOptions") self._server.setSocketOptions(QLocalServer.UserAccessOption) else: # pragma: no cover log.ipc.debug("Not calling setSocketOptions")
def newLocalServer(self): self.localServer = QLocalServer(self) self.localServer.newConnection.connect(self.newLocalConnection) if not self.localServer.listen(self.serverName): if self.localServer.serverError( ) == QAbstractSocket.AddressInUseError: QLocalServer.removeServer(self.serverName) self.localServer.listen(self.serverName)
def create(self, name=piony.G_SOCKET_NAME): QLocalServer.removeServer(name) self.server = QLocalServer() if not self.server.listen(name): print("Error: server -- unable to start: {}.".format( self.server.errorString())) self.quit.emit() self.server.newConnection.connect(self.notify)
def __init__(self, instance=None): QObject.__init__(self) sock_name = self.get_sock_name(instance) QLocalServer.removeServer(sock_name) self._server = QLocalServer() self._server.newConnection.connect(self._on_new_connection) if not self._server.listen(sock_name): logging.error("Can not start ipc: %s" % self._server.errorString()) self._readers = {}
def test_socket_options_address_in_use_problem(qlocalserver, short_tmpdir): """Qt seems to ignore AddressInUseError when using socketOptions. With this test we verify this bug still exists. If it fails, we can probably start using setSocketOptions again. """ servername = str(short_tmpdir / 'x') s1 = QLocalServer() ok = s1.listen(servername) assert ok s2 = QLocalServer() s2.setSocketOptions(QLocalServer.UserAccessOption) ok = s2.listen(servername) print(s2.errorString()) # We actually would expect ok == False here - but we want the test to fail # when the Qt bug is fixed. assert ok
def __init__(self, app): super().__init__() self.setupUi(self) self.setAcceptDrops(True) # Server self.server = QLocalServer() self.server.listen("blender-launcher-server") self.server.newConnection.connect(self.new_connection) # Global scope self.app = app self.favorite = None self.status = "None" self.app_state = AppState.IDLE self.cashed_builds = [] self.notification_pool = [] self.windows = [self] self.manager = PoolManager(num_pools=50, maxsize=10) self.timer = None self.started = True self.latest_tag = "" self.new_downloads = False # Setup window self.setWindowTitle("Blender Launcher") self.app.setWindowIcon( QIcon(taskbar_icon_paths[get_taskbar_icon_color()])) # Setup font QFontDatabase.addApplicationFont( ":/resources/fonts/OpenSans-SemiBold.ttf") self.font = QFont("Open Sans SemiBold", 10) self.font.setHintingPreference(QFont.PreferNoHinting) self.app.setFont(self.font) # Setup style file = QFile(":/resources/styles/global.qss") file.open(QFile.ReadOnly | QFile.Text) self.style_sheet = QTextStream(file).readAll() self.app.setStyleSheet(self.style_sheet) # Check library folder if is_library_folder_valid() is False: self.dlg = DialogWindow( self, title="Information", text="First, choose where Blender<br>builds will be stored", accept_text="Continue", cancel_text=None, icon=DialogIcon.INFO) self.dlg.accepted.connect(self.set_library_folder) else: create_library_folders(get_library_folder()) self.draw()
def __init__(self, parent: QWidget = None): super().__init__(parent) self.setWindowFlags(self.windowFlags() & ~Qt.WindowContextHelpButtonHint) self.server = QLocalServer(self) if not self.server.listen("fortune"): QMessageBox.critical( self, self.tr("Local Fortune Server"), self.tr("Unable to start the server: %s." % (self.server.errorString())), ) QTimer.singleShot(0, self.close) return statusLabel = QLabel() statusLabel.setWordWrap(True) statusLabel.setText( self. tr("The server is running.\nRun the Local Fortune Client example now." )) self.fortunes = ( self.tr( "You've been leading a dog's life. Stay off the furniture."), self.tr("You've got to think about tomorrow."), self.tr("You will be surprised by a loud noise."), self.tr("You will feel hungry again in another hour."), self.tr("You might have mail."), self.tr("You cannot kill time without injuring eternity."), self.tr( "Computers are not intelligent. They only think they are."), ) quitButton = QPushButton(self.tr("Quit")) quitButton.setAutoDefault(False) quitButton.clicked.connect(self.close) self.server.newConnection.connect(self.sendFortune) buttonLayout = QHBoxLayout() buttonLayout.addStretch(1) buttonLayout.addWidget(quitButton) buttonLayout.addStretch(1) mainLayout = QVBoxLayout(self) mainLayout.addWidget(statusLabel) mainLayout.addLayout(buttonLayout) self.setWindowTitle(QGuiApplication.applicationDisplayName())
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 main(): global win signal.signal(signal.SIGINT, exit) args = parse_arguments() appKey = "scudcloud.pid" socket = QLocalSocket() socket.connectToServer(appKey) if socket.isOpen(): socket.close() socket.deleteLater() return 0 socket.deleteLater() app = QtWidgets.QApplication(sys.argv) app.setApplicationName(Resources.APP_NAME + ' Slack') app.setWindowIcon(QtGui.QIcon(Resources.get_path('scudcloud.png'))) try: settings_path, cache_path = load_settings(args.confdir, args.cachedir) except: print("Data directories " + args.confdir + " and " + args.cachedir + " could not be created! Exiting...") raise SystemExit() minimized = True if args.minimized is True else None urgent_hint = True if args.urgent_hint is True else None # Let's move the CSS to cachedir to enable additional actions copyfile(Resources.get_path('resources.css'), os.path.join(cache_path, 'resources.css')) # If there is an qt4 config and not a qt5, let's copy the old one qt4_config = os.path.join(settings_path, 'scudcloud.cfg') qt5_config = os.path.join(settings_path, 'scudcloud_qt5.cfg') if os.path.exists(qt4_config) and not os.path.exists(qt5_config): copyfile(qt4_config, qt5_config) win = sca.ScudCloud(debug=args.debug, minimized=minimized, urgent_hint=urgent_hint, settings_path=settings_path, cache_path=cache_path) app.commitDataRequest.connect(win.setForceClose, type=QtCore.Qt.DirectConnection) server = QLocalServer() server.newConnection.connect(restore) server.listen(appKey) win.restore() if win.minimized is None: win.show() sys.exit(app.exec_())
def main(now_version, new_version): try: serverName = 'dig_word_update_Server' socket = QLocalSocket() socket.connectToServer(serverName) # 如果连接成功,表明server已经存在,当前已有实例在运行 if socket.waitForConnected(500): pass else: localServer = QLocalServer() # 没有实例运行,创建服务器 localServer.listen(serverName) # 处理其他 downwin_class(now_version, new_version) except: pass
def __init__(self, parent=None): """Start the IPC server and listen to commands.""" super().__init__(parent) self._remove_server() self._timer = usertypes.Timer(self, 'ipc-timeout') self._timer.setInterval(READ_TIMEOUT) self._timer.timeout.connect(self.on_timeout) self._server = QLocalServer(self) ok = self._server.listen(SOCKETNAME) if not ok: raise IPCError("Error while listening to IPC server: {} " "(error {})".format(self._server.errorString(), self._server.serverError())) self._server.newConnection.connect(self.handle_connection) self._socket = None
def __init__(self, parent=None): """Start the IPC server and listen to commands.""" super().__init__(parent) self.ignored = False self._remove_server() self._timer = usertypes.Timer(self, 'ipc-timeout') self._timer.setInterval(READ_TIMEOUT) self._timer.timeout.connect(self.on_timeout) self._server = QLocalServer(self) ok = self._server.listen(SOCKETNAME) if not ok: if self._server.serverError() == QAbstractSocket.AddressInUseError: raise AddressInUseError(self._server) else: raise ListenError(self._server) self._server.newConnection.connect(self.handle_connection) self._socket = None
def initSplash(self, name, above=False): """初始化启动画面 :param name: local server name :param above: stays on top """ # 鼠标 self.setCursor(Qt.WaitCursor) # 是否置顶 if above: self.setWindowFlags( self.windowFlags() | Qt.WindowStaysOnTopHint) # 创建本地server self.m_server = QLocalServer(self) if self.m_server.listen(self.getName(name)): self.m_server.newConnection.connect(self.slotNewConnection)
def __init__(self, parent=None): super(Server, self).__init__(parent) statusLabel = QLabel() statusLabel.setWordWrap(True) quitButton = QPushButton("Quit") quitButton.setAutoDefault(False) self.fortunes = ( "You've been leading a dog's life. Stay off the furniture.", "You've got to think about tomorrow.", "You will be surprised by a loud noise.", "You will feel hungry again in another hour.", "You might have mail.", "You cannot kill time without injuring eternity.", "Computers are not intelligent. They only think they are.", ) self.server = QLocalServer() if not self.server.listen("fortune"): QMessageBox.critical( self, "Fortune Server", "Unable to start the server: %s." % self.server.errorString(), ) self.close() return statusLabel.setText("The server is running.\nRun the Fortune Client " "example now.") quitButton.clicked.connect(self.close) self.server.newConnection.connect(self.sendFortune) buttonLayout = QHBoxLayout() buttonLayout.addStretch(1) buttonLayout.addWidget(quitButton) buttonLayout.addStretch(1) mainLayout = QVBoxLayout() mainLayout.addWidget(statusLabel) mainLayout.addLayout(buttonLayout) self.setLayout(mainLayout) self.setWindowTitle("Fortune Server")
def init_nxdrive_listener(self) -> None: """ Set up a QLocalServer to listen to nxdrive protocol calls. On Windows, when an nxdrive:// URL is opened, it creates a new instance of Nuxeo Drive. As we want the already running instance to receive this call (particularly during the login process), we set up a QLocalServer in that instance to listen to the new ones who will send their data. The Qt implementation of QLocalSocket on Windows makes use of named pipes. We just need to connect a handler to the newConnection signal to process the URLs. """ self._nxdrive_listener = QLocalServer() self._nxdrive_listener.newConnection.connect(self._handle_connection) self._nxdrive_listener.listen("com.nuxeo.drive.protocol") self.aboutToQuit.connect(self._nxdrive_listener.close)
def __init__(self, argv, key): QApplication.__init__(self, argv) self._key = key self._timeout = 1000 socket = QLocalSocket(self) socket.connectToServer(self._key) if socket.waitForConnected(self._timeout): self._isRunning = True socket.abort() return socket.abort() self._isRunning = False self._server = QLocalServer(self) self._server.newConnection.connect(self.__onNewConnection) self._server.listen(self._key) self.aboutToQuit.connect(self.__onAboutToQuit)
def __init__(self): super(MainWindow, self).__init__() self.setStyleSheet("background-color: rgb(24, 25, 26); color: rgb(255, 170, 0); ") self.setWindowTitle("Liveplot - Plotting dashboard!") self.setWindowIcon(QIcon('icon.ico')) self.dockarea = DockArea() self.setCentralWidget(self.dockarea) self.namelist = NameList(self) self.addDockWidget(QtConst.LeftDockWidgetArea, self.namelist) self.server = QLocalServer() self.server.removeServer('LivePlot') self.server.listen('LivePlot') self.server.newConnection.connect(self.accept) self.bytes = bytearray() self.target_size = 0 self.meta = None self.insert_dock_right = True self.conns = [] self.shared_mems = [] signal.signal(signal.SIGINT, self.close)
def __init__(self, win_id, *argv): logfunc = logging.info logfunc(sys._getframe().f_code.co_name + '()') QApplication.__init__(self, *argv) self._id = win_id self._activation_window = None self._activate_on_message = False # Is there another instance running? self._outSocket = QLocalSocket() self._outSocket.connectToServer(self._id) self._isRunning = self._outSocket.waitForConnected() self._outStream = None self._inSocket = None self._inStream = None self._server = None if self._isRunning: # Yes, there is. self._outStream = QTextStream(self._outSocket) self._outStream.setCodec('UTF-8') else: # No, there isn't, at least not properly. # Cleanup any past, crashed server. error = self._outSocket.error() logfunc(LOGVARSTR % ('self._outSocket.error()', error)) if error == QLocalSocket.ConnectionRefusedError: logfunc('received QLocalSocket.ConnectionRefusedError; ' + \ 'removing server.') self.close() QLocalServer.removeServer(self._id) self._outSocket = None self._server = QLocalServer() self._server.listen(self._id) self._server.newConnection.connect(self._on_new_connection) logfunc(sys._getframe().f_code.co_name + '(): returning')
def __init__(self, socketname, parent=None): """Start the IPC server and listen to commands. Args: socketname: The socketname to use. parent: The parent to be used. """ super().__init__(parent) self.ignored = False self._socketname = socketname self._timer = usertypes.Timer(self, 'ipc-timeout') self._timer.setInterval(READ_TIMEOUT) self._timer.timeout.connect(self.on_timeout) if utils.is_windows: # pragma: no cover self._atime_timer = None else: self._atime_timer = usertypes.Timer(self, 'ipc-atime') self._atime_timer.setInterval(ATIME_INTERVAL) self._atime_timer.timeout.connect(self.update_atime) self._atime_timer.setTimerType(Qt.VeryCoarseTimer) self._server = QLocalServer(self) self._server.newConnection.connect( # type: ignore[attr-defined] self.handle_connection) self._socket = None self._old_socket = None if utils.is_windows: # pragma: no cover # As a WORKAROUND for a Qt bug, we can't use UserAccessOption on Unix. If we # do, we don't get an AddressInUseError anymore: # https://bugreports.qt.io/browse/QTBUG-48635 # # Thus, we only do so on Windows, and handle permissions manually in # listen() on Linux. log.ipc.debug("Calling setSocketOptions") self._server.setSocketOptions(QLocalServer.UserAccessOption) else: # pragma: no cover log.ipc.debug("Not calling setSocketOptions")
def __init__(self, win_id, *argv): self.logger = logging.getLogger(self.__class__.__name__) self.logger.info(f'Start Tribler application. Win id: "{win_id}". ' f'Sys argv: "{sys.argv}"') QApplication.__init__(self, *argv) self._id = win_id self._activation_window = None self._activate_on_message = False # Is there another instance running? self._outSocket = QLocalSocket() self._outSocket.connectToServer(self._id) self._isRunning = self._outSocket.waitForConnected() self._outStream = None self._inSocket = None self._inStream = None self._server = None if self._isRunning: # Yes, there is. self.logger.info('Another instance is running') self._outStream = QTextStream(self._outSocket) self._outStream.setCodec('UTF-8') else: # No, there isn't, at least not properly. # Cleanup any past, crashed server. error = self._outSocket.error() self.logger.info(f'No running instances (socket error: {error})') if error == QLocalSocket.ConnectionRefusedError: self.logger.info( 'Received QLocalSocket.ConnectionRefusedError; removing server.' ) self.close() QLocalServer.removeServer(self._id) self._outSocket = None self._server = QLocalServer() self._server.listen(self._id) connect(self._server.newConnection, self._on_new_connection)
def __init__(self, name, *args, **kwargs): super(QSingleApplication, self).__init__(*args, **kwargs) self._socketName = name self._activationWindow = None 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 # 创建本地server self._socketServer = QLocalServer(self) self._socketServer.listen(self._socketName) self._socketServer.newConnection.connect(self._onNewConnection) self.aboutToQuit.connect(self.removeServer)