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)
