From 84d86455e7c475f025c8cafcc4c2685fbaeffec3 Mon Sep 17 00:00:00 2001 From: Itay Grudev Date: Wed, 4 May 2016 19:59:07 +0100 Subject: [PATCH 1/4] Secondary instance implementation --- singleapplication.cpp | 211 +++++++++++++++++++++++++++++++----------- singleapplication.h | 5 +- 2 files changed, 162 insertions(+), 54 deletions(-) diff --git a/singleapplication.cpp b/singleapplication.cpp index 100ec9c..bd0b2b4 100644 --- a/singleapplication.cpp +++ b/singleapplication.cpp @@ -1,7 +1,8 @@ #include -#include #include +#include +#include #include #include @@ -12,22 +13,74 @@ #include "singleapplication.h" +struct InstancesInfo { + bool primary; + uint8_t secondary; +}; class SingleApplicationPrivate { +public: Q_DECLARE_PUBLIC(SingleApplication) -public: - SingleApplicationPrivate(SingleApplication *q_ptr) : q_ptr(q_ptr) { } + SingleApplicationPrivate(SingleApplication *q_ptr) : q_ptr(q_ptr) { + server = NULL; + } - void startServer(QString &serverName) + ~SingleApplicationPrivate() + { + cleanUp(); + } + + void startPrimary( bool resetMemory ) { Q_Q(SingleApplication); - - // Start a QLocalServer to listen for connections +#ifdef Q_OS_UNIX + // Handle any further termination signals to ensure the + // QSharedMemory block is deleted even if the process crashes + crashHandler(); +#endif + // Successful creation means that no main process exists + // So we start a QLocalServer to listen for connections server = new QLocalServer(); - QLocalServer::removeServer(serverName); - server->listen(serverName); - QObject::connect(server, SIGNAL(newConnection()), q, SLOT(slotConnectionEstablished())); + QLocalServer::removeServer( memory->key() ); + server->listen( memory->key() ); + QObject::connect( + server, + SIGNAL( newConnection() ), + q, + SLOT( slotConnectionEstablished() ) + ); + + // Reset the number of connections + memory->lock(); + InstancesInfo* inst = (InstancesInfo*)memory->data(); + + if( resetMemory ){ + inst->primary = true; + inst->secondary = 0; + } else { + inst->primary = true; + } + + memory->unlock(); + } + + void startSecondary() + { +#ifdef Q_OS_UNIX + // Handle any further termination signals to ensure the + // QSharedMemory block is deleted even if the process crashes + crashHandler(); +#endif + + // Connect to the Local Server of the main process to notify it + // that a new process had been started + QLocalSocket socket; + socket.connectToServer( memory->key() ); + + // Notify the parent that a new instance had been started; + socket.waitForConnected(100); + socket.close(); } #ifdef Q_OS_UNIX @@ -38,25 +91,26 @@ public: // Which in my opinion is idiotic, but lets handle that too. { sharedMemMutex.lock(); - sharedMem.append(memory); + sharedMem.append( this ); sharedMemMutex.unlock(); } + // Handle any further termination signals to ensure the // QSharedMemory block is deleted even if the process crashes - signal(SIGHUP, SingleApplicationPrivate::terminate); // 1 - signal(SIGINT, SingleApplicationPrivate::terminate); // 2 - signal(SIGQUIT, SingleApplicationPrivate::terminate); // 3 - signal(SIGILL, SingleApplicationPrivate::terminate); // 4 - signal(SIGABRT, SingleApplicationPrivate::terminate); // 6 - signal(SIGBUS, SingleApplicationPrivate::terminate); // 7 - signal(SIGFPE, SingleApplicationPrivate::terminate); // 8 - signal(SIGSEGV, SingleApplicationPrivate::terminate); // 11 - signal(SIGSYS, SingleApplicationPrivate::terminate); // 12 - signal(SIGPIPE, SingleApplicationPrivate::terminate); // 13 - signal(SIGALRM, SingleApplicationPrivate::terminate); // 14 - signal(SIGTERM, SingleApplicationPrivate::terminate); // 15 - signal(SIGXCPU, SingleApplicationPrivate::terminate); // 24 - signal(SIGXFSZ, SingleApplicationPrivate::terminate); // 25 + signal( SIGHUP, SingleApplicationPrivate::terminate ); // 1 + signal( SIGINT, SingleApplicationPrivate::terminate ); // 2 + signal( SIGQUIT, SingleApplicationPrivate::terminate ); // 3 + signal( SIGILL, SingleApplicationPrivate::terminate ); // 4 + signal( SIGABRT, SingleApplicationPrivate::terminate ); // 6 + signal( SIGBUS, SingleApplicationPrivate::terminate ); // 7 + signal( SIGFPE, SingleApplicationPrivate::terminate ); // 8 + signal( SIGSEGV, SingleApplicationPrivate::terminate ); // 11 + signal( SIGSYS, SingleApplicationPrivate::terminate ); // 12 + signal( SIGPIPE, SingleApplicationPrivate::terminate ); // 13 + signal( SIGALRM, SingleApplicationPrivate::terminate ); // 14 + signal( SIGTERM, SingleApplicationPrivate::terminate ); // 15 + signal( SIGXCPU, SingleApplicationPrivate::terminate ); // 24 + signal( SIGXFSZ, SingleApplicationPrivate::terminate ); // 25 } static void terminate(int signum) @@ -65,21 +119,34 @@ public: delete sharedMem.back(); sharedMem.pop_back(); } - ::exit(128 + signum); + ::exit( 128 + signum ); } - static QList sharedMem; + static QList sharedMem; static QMutex sharedMemMutex; #endif + void cleanUp() { + memory->lock(); + InstancesInfo* inst = (InstancesInfo*)memory->data(); + if( server != NULL ) { + server->close(); + inst->primary = false; + } else { + if( inst->secondary > 0 ) + inst->secondary -= 1; + } + memory->unlock(); + delete memory; + } + QSharedMemory *memory; SingleApplication *q_ptr; QLocalServer *server; - QLocalSocket *socket; }; #ifdef Q_OS_UNIX - QList SingleApplicationPrivate::sharedMem; + QList SingleApplicationPrivate::sharedMem; QMutex SingleApplicationPrivate::sharedMemMutex; #endif @@ -89,44 +156,72 @@ public: * @param argc * @param argv */ -SingleApplication::SingleApplication(int &argc, char *argv[]) +SingleApplication::SingleApplication(int &argc, char *argv[], uint8_t secondaryInstances) : app_t(argc, argv), d_ptr(new SingleApplicationPrivate(this)) { Q_D(SingleApplication); + // Check command line arguments for the force primary and secondary flags +#ifdef Q_OS_UNIX + bool forcePrimary = false; +#endif + bool secondary = false; + for( int i = 0; i < argc; ++i ) { + if( strcmp( argv[i], "--secondary" ) == 0 ) { + secondary = true; +#ifndef Q_OS_UNIX + break; +#endif + } +#ifdef Q_OS_UNIX + if( strcmp( argv[i], "--primary" ) == 0 ) { + secondary = false; + forcePrimary = true; + break; + } +#endif + } + QString serverName = app_t::organizationName() + app_t::applicationName(); - serverName.replace(QRegExp("[^\\w\\-. ]"), ""); + serverName.replace( QRegExp("[^\\w\\-. ]"), "" ); // Guarantee thread safe behaviour with a shared memory block d->memory = new QSharedMemory(serverName); // Create a shared memory block with a minimum size of 1 byte - if( d->memory->create(1, QSharedMemory::ReadOnly) ) - { #ifdef Q_OS_UNIX - // Handle any further termination signals to ensure the - // QSharedMemory block is deleted even if the process crashes - d->crashHandler(); + if( d->memory->create( sizeof(InstancesInfo) ) || forcePrimary ) { +#else + if( d->memory->create( sizeof(InstancesInfo) ) ) { #endif - // Successful creation means that no main process exists - // So we start a Local Server to listen for connections - d->startServer(serverName); + d->startPrimary( true ); + return; } else { - // Connect to the Local Server of the main process to notify it - // that a new process had been started - d->socket = new QLocalSocket(); - d->socket->connectToServer(serverName); + // Attempt to attach to the memory segment + if( d->memory->attach() ) { + d->memory->lock(); + InstancesInfo* inst = (InstancesInfo*)d->memory->data(); - // Even though a shared memory block exists, the original application - // might have crashed. - // So only after a successful connection is the second instance - // terminated. - d->socket->waitForConnected(100); - delete d->memory; - - // Terminate the program using STDLib's exit function - ::exit(EXIT_SUCCESS); + if( ! inst->primary ) { + d->startPrimary( false ); + d->memory->unlock(); + return; + } + + // Check if another instance can be started + if( secondary && inst->secondary < secondaryInstances ) { + inst->secondary += 1; + d->startSecondary(); + d->memory->unlock(); + return; + } + + d->memory->unlock(); + } } + + delete d->memory; + ::exit(EXIT_SUCCESS); } /** @@ -135,9 +230,19 @@ SingleApplication::SingleApplication(int &argc, char *argv[]) SingleApplication::~SingleApplication() { Q_D(SingleApplication); + delete d; +} - delete d->memory; - d->server->close(); +bool SingleApplication::isPrimary() +{ + Q_D(SingleApplication); + return d->server != NULL; +} + +bool SingleApplication::isSecondary() +{ + Q_D(SingleApplication); + return d->server == NULL; } /** diff --git a/singleapplication.h b/singleapplication.h index 91f5b11..780bd9e 100644 --- a/singleapplication.h +++ b/singleapplication.h @@ -22,9 +22,12 @@ class SingleApplication : public QAPPLICATION_CLASS typedef QAPPLICATION_CLASS app_t; public: - explicit SingleApplication(int&, char *[]); + explicit SingleApplication(int &argc, char *argv[], uint8_t secondaryInstances = 0); ~SingleApplication(); + bool isPrimary(); + bool isSecondary(); + Q_SIGNALS: void showUp(); From 8c9327036e39fec21c9f78188ce0db5659682562 Mon Sep 17 00:00:00 2001 From: Itay Grudev Date: Wed, 4 May 2016 20:40:03 +0100 Subject: [PATCH 2/4] Updated documentation --- README.md | 82 ++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 63 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index 465f0e9..8e56094 100644 --- a/README.md +++ b/README.md @@ -3,30 +3,44 @@ SingleApplication This is a replacement of the QSingleApplication for `Qt5`. -Keeps the Primary Instance of your Application and kills each subsequent instances. +Keeps the Primary Instance of your Application and kills each subsequent +instances. It can (if enabled) spawn a certain number of secondary instances +(with the `--secondary` command line argument). Usage ----- -The `SingleApplication` class inherits from whatever `Q[Core|Gui]Application` class you specify in the `*.pro` file. Further usage is similar to use one of the `Q[Core|Gui]Application` classes. -The library uses your `Organization Name` and `Application Name` to set up a `QLocalServer` and a `QSharedMemory` block. The first instance of your Application would check if the shared memory block exists and if not it will start a `QLocalServer` and then listen for connections on it. Each subsequent instance of your application would check if the shared memory block exists and if it does, it will connect to the QLocalServer to notify it that a new instance had been started, after which would terminate the new instance with status code `0`. The Primary Instance, `SingleApplication` would emmit the `showUp()` signal upon detecting that a new instance had been started. +The `SingleApplication` class inherits from whatever `Q[Core|Gui]Application` +class you specify. Further usage is similar to the use of the +`Q[Core|Gui]Application` classes. + +The library uses your `Organization Name` and `Application Name` to set up a +`QLocalServer` and a `QSharedMemory` block. The first instance of your +Application is your Primary Instance. It would check if the shared memory block +exists and if not it will start a `QLocalServer` and then listen for connections +on it. Each subsequent instance of your application would check if the shared +memory block exists and if it does, it will connect to the QLocalServer to +notify it that a new instance had been started, after which it would terminate + with status code `0`. The Primary Instance, `SingleApplication` would emit the + `showUp()` signal upon detecting that a new instance had been started. The library uses `stdlib` to terminate the program with the `exit()` function. Here is an example usage of the library: + ```cpp -// project.pro -DEFINES += QAPPLICATION_CLASS=QApplication # or whatever app class you want +// In your Project.pro +DEFINES += QAPPLICATION_CLASS=QGuiApplication # QApplication is the default // main.cpp #include "singleapplication.h" -int main(int argc, char *argv[]) +int main( int argc, char* argv[] ) { QApplication::setApplicationName("{Your App Name}"); QApplication::setOrganizationName("{Your Organization Name}"); - SingleApplication app(argc, argv); + SingleApplication app( argc, argv ); return app.exec(); } @@ -34,27 +48,57 @@ int main(int argc, char *argv[]) The `Show Up` signal ------------------------ -The SingleApplication class implements a `showUp()` signal. You can bind to that signal to raise your application's window when a new instance had been started. -Note that since `SingleApplication` extends the `QApplication` class you can do the following: +The SingleApplication class implements a `showUp()` signal. You can bind to that +signal to raise your application's window when a new instance had been started. + +Note that since `SingleApplication` extends the `QApplication` class you can do +the following: + ```cpp -// Truly raise your window. -QObject::connect(&app, &SingleApplication::showUp, [&] -{ - window.show(); - window.raise(); - window.activateWindow(); -}); // 'window' is your QWindow instance +// window is a QWindow instance +QObject::connect( &app, &SingleApplication::showUp, window, &QWindow::raise ); ``` -Using `QApplication::instance()` is a neat way to get the `SingleApplication` instance at any place in your program. +Using `QApplication::instance()` is a neat way to get the `SingleApplication` +instance anywhere in your program. +Secondary Instances +------------------- + +If you want to be able to launch additional Secondary Instances (not related to +your Primary Instance) you have to enable that with the third parameter of the +`SingleApplication` constructor. The default is `0` meaning no Secondary +Instances. Here is an example allowing spawning up to `2` Secondary Instances. + +```cpp +SingleApplication app( argc, argv, 2 ); +``` + +After which just call your program with the `--secondary` argument to launch a +secondary instance. + +__*Note:*__ If your Primary Instance is terminated upon launch of a new one it +will replace it as Primary even if the `--secondary` argument has been set. + +*P.S. If you think this behavior could be improved create an issue and explain +why.* Implementation -------------- -The library is implemented with a QSharedMemory block which is thread safe and guarantees a race condition will not occur. It also uses a QLocalSocket to notify the main process that a new instance had been spawned and thus invoke the `showUp()` signal. -To handle an issue on `*nix` systems, where the operating system owns the shared memory block and if the program crashes the memory remains untouched, the library binds to the following signals and closes the program with error code = `128 + signum` where signum is the number representation of the signal listed below. Handling the signal is required in order to safely delete the `QSharedMemory` block. Each of these signals are potentially lethal and will results in process termination. +The library is implemented with a QSharedMemory block which is thread safe and +guarantees a race condition will not occur. It also uses a QLocalSocket to +notify the main process that a new instance had been spawned and thus invoke the +`showUp()` signal. + +To handle an issue on `*nix` systems, where the operating system owns the shared +memory block and if the program crashes the memory remains untouched, the +library binds to the following signals and closes the program with error code = +`128 + signum` where signum is the number representation of the signal listed +below. Handling the signal is required in order to safely delete the +`QSharedMemory` block. Each of these signals are potentially lethal and will +results in process termination. * `SIGHUP` - `1`, Hangup. * `SIGINT` - `2`, Terminal interrupt signal From 8bccf446e190aedf0ffe11772a6a73d469ce774a Mon Sep 17 00:00:00 2001 From: Itay Grudev Date: Wed, 4 May 2016 20:41:23 +0100 Subject: [PATCH 3/4] Improved restoring QSharedMemory after crash --- singleapplication.cpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/singleapplication.cpp b/singleapplication.cpp index bd0b2b4..c5f52dc 100644 --- a/singleapplication.cpp +++ b/singleapplication.cpp @@ -185,8 +185,13 @@ SingleApplication::SingleApplication(int &argc, char *argv[], uint8_t secondaryI QString serverName = app_t::organizationName() + app_t::applicationName(); serverName.replace( QRegExp("[^\\w\\-. ]"), "" ); - // Guarantee thread safe behaviour with a shared memory block - d->memory = new QSharedMemory(serverName); + // Guarantee thread safe behaviour with a shared memory block. Also by + // attaching to it and deleting it we make sure that the memory i deleted + // even if the process had crashed + d->memory = new QSharedMemory( serverName ); + d->memory->attach(); + delete d->memory; + d->memory = new QSharedMemory( serverName ); // Create a shared memory block with a minimum size of 1 byte #ifdef Q_OS_UNIX @@ -246,7 +251,7 @@ bool SingleApplication::isSecondary() } /** - * @brief Executed when the showUp command is sent to LocalServer + * @brief Executed when a connection has been made to the LocalServer */ void SingleApplication::slotConnectionEstablished() { From 6fe44039410e7330349c2e783ec2ccfe68534715 Mon Sep 17 00:00:00 2001 From: Itay Grudev Date: Wed, 4 May 2016 20:51:06 +0100 Subject: [PATCH 4/4] Bugfix no showUp notification. Some minor improvements --- singleapplication.cpp | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/singleapplication.cpp b/singleapplication.cpp index c5f52dc..b63abdc 100644 --- a/singleapplication.cpp +++ b/singleapplication.cpp @@ -41,14 +41,14 @@ public: #endif // Successful creation means that no main process exists // So we start a QLocalServer to listen for connections - server = new QLocalServer(); QLocalServer::removeServer( memory->key() ); + server = new QLocalServer(); server->listen( memory->key() ); QObject::connect( server, - SIGNAL( newConnection() ), + &QLocalServer::newConnection, q, - SLOT( slotConnectionEstablished() ) + &SingleApplication::slotConnectionEstablished ); // Reset the number of connections @@ -73,6 +73,11 @@ public: crashHandler(); #endif + notifyPrimary(); + } + + void notifyPrimary() + { // Connect to the Local Server of the main process to notify it // that a new process had been started QLocalSocket socket; @@ -225,7 +230,8 @@ SingleApplication::SingleApplication(int &argc, char *argv[], uint8_t secondaryI } } - delete d->memory; + d->notifyPrimary(); + delete d; ::exit(EXIT_SUCCESS); }