mirrors/SingleApplication
1
0
Fork 0
mirror of https://github.com/itay-grudev/SingleApplication.git synced 2025-03-31 17:42:39 +08:00
Code Activity

Secondary instance implementation

Browse Source
This commit is contained in:
Itay Grudev 2016-05-04 19:59:07 +01:00
parent fc5ce4c335
commit 84d86455e7
2 changed files with 162 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
singleapplication.cpp
View File

@ -1,7 +1,8 @@
#include <cstdlib> #include <cstdlib>
#include <QtCore/QSharedMemory>
#include <QtCore/QMutex> #include <QtCore/QMutex>
#include <QtCore/QSemaphore>
#include <QtCore/QSharedMemory>
#include <QtNetwork/QLocalSocket> #include <QtNetwork/QLocalSocket>
#include <QtNetwork/QLocalServer> #include <QtNetwork/QLocalServer>
@ -12,22 +13,74 @@
#include "singleapplication.h" #include "singleapplication.h"
struct InstancesInfo {
bool primary;
uint8_t secondary;
};
class SingleApplicationPrivate { class SingleApplicationPrivate {
public:
Q_DECLARE_PUBLIC(SingleApplication) 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); Q_Q(SingleApplication);
#ifdef Q_OS_UNIX
// Start a QLocalServer to listen for connections // 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(); server = new QLocalServer();
QLocalServer::removeServer(serverName); QLocalServer::removeServer( memory->key() );
server->listen(serverName); server->listen( memory->key() );
QObject::connect(server, SIGNAL(newConnection()), q, SLOT(slotConnectionEstablished())); 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 #ifdef Q_OS_UNIX
@ -38,25 +91,26 @@ public:
// Which in my opinion is idiotic, but lets handle that too. // Which in my opinion is idiotic, but lets handle that too.
{ {
sharedMemMutex.lock(); sharedMemMutex.lock();
sharedMem.append(memory); sharedMem.append( this );
sharedMemMutex.unlock(); sharedMemMutex.unlock();
} }
// Handle any further termination signals to ensure the // Handle any further termination signals to ensure the
// QSharedMemory block is deleted even if the process crashes // QSharedMemory block is deleted even if the process crashes
signal(SIGHUP, SingleApplicationPrivate::terminate); // 1 signal( SIGHUP, SingleApplicationPrivate::terminate ); // 1
signal(SIGINT, SingleApplicationPrivate::terminate); // 2 signal( SIGINT, SingleApplicationPrivate::terminate ); // 2
signal(SIGQUIT, SingleApplicationPrivate::terminate); // 3 signal( SIGQUIT, SingleApplicationPrivate::terminate ); // 3
signal(SIGILL, SingleApplicationPrivate::terminate); // 4 signal( SIGILL, SingleApplicationPrivate::terminate ); // 4
signal(SIGABRT, SingleApplicationPrivate::terminate); // 6 signal( SIGABRT, SingleApplicationPrivate::terminate ); // 6
signal(SIGBUS, SingleApplicationPrivate::terminate); // 7 signal( SIGBUS, SingleApplicationPrivate::terminate ); // 7
signal(SIGFPE, SingleApplicationPrivate::terminate); // 8 signal( SIGFPE, SingleApplicationPrivate::terminate ); // 8
signal(SIGSEGV, SingleApplicationPrivate::terminate); // 11 signal( SIGSEGV, SingleApplicationPrivate::terminate ); // 11
signal(SIGSYS, SingleApplicationPrivate::terminate); // 12 signal( SIGSYS, SingleApplicationPrivate::terminate ); // 12
signal(SIGPIPE, SingleApplicationPrivate::terminate); // 13 signal( SIGPIPE, SingleApplicationPrivate::terminate ); // 13
signal(SIGALRM, SingleApplicationPrivate::terminate); // 14 signal( SIGALRM, SingleApplicationPrivate::terminate ); // 14
signal(SIGTERM, SingleApplicationPrivate::terminate); // 15 signal( SIGTERM, SingleApplicationPrivate::terminate ); // 15
signal(SIGXCPU, SingleApplicationPrivate::terminate); // 24 signal( SIGXCPU, SingleApplicationPrivate::terminate ); // 24
signal(SIGXFSZ, SingleApplicationPrivate::terminate); // 25 signal( SIGXFSZ, SingleApplicationPrivate::terminate ); // 25
} }
static void terminate(int signum) static void terminate(int signum)
@ -65,21 +119,34 @@ public:
delete sharedMem.back(); delete sharedMem.back();
sharedMem.pop_back(); sharedMem.pop_back();
} }
::exit(128 + signum); ::exit( 128 + signum );
} }
static QList<QSharedMemory*> sharedMem; static QList<SingleApplicationPrivate*> sharedMem;
static QMutex sharedMemMutex; static QMutex sharedMemMutex;
#endif #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; QSharedMemory *memory;
SingleApplication *q_ptr; SingleApplication *q_ptr;
QLocalServer *server; QLocalServer *server;
QLocalSocket *socket;
}; };
#ifdef Q_OS_UNIX #ifdef Q_OS_UNIX
QList<QSharedMemory*> SingleApplicationPrivate::sharedMem; QList<SingleApplicationPrivate*> SingleApplicationPrivate::sharedMem;
QMutex SingleApplicationPrivate::sharedMemMutex; QMutex SingleApplicationPrivate::sharedMemMutex;
#endif #endif
@ -89,44 +156,72 @@ public:
* @param argc * @param argc
* @param argv * @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)) : app_t(argc, argv), d_ptr(new SingleApplicationPrivate(this))
{ {
Q_D(SingleApplication); 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(); 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 // Guarantee thread safe behaviour with a shared memory block
d->memory = new QSharedMemory(serverName); d->memory = new QSharedMemory(serverName);
// Create a shared memory block with a minimum size of 1 byte // Create a shared memory block with a minimum size of 1 byte
if( d->memory->create(1, QSharedMemory::ReadOnly) )
{
#ifdef Q_OS_UNIX #ifdef Q_OS_UNIX
// Handle any further termination signals to ensure the if( d->memory->create( sizeof(InstancesInfo) ) || forcePrimary ) {
// QSharedMemory block is deleted even if the process crashes #else
d->crashHandler(); if( d->memory->create( sizeof(InstancesInfo) ) ) {
#endif #endif
// Successful creation means that no main process exists d->startPrimary( true );
// So we start a Local Server to listen for connections return;
d->startServer(serverName);
} else { } else {
// Connect to the Local Server of the main process to notify it // Attempt to attach to the memory segment
// that a new process had been started if( d->memory->attach() ) {
d->socket = new QLocalSocket(); d->memory->lock();
d->socket->connectToServer(serverName); InstancesInfo* inst = (InstancesInfo*)d->memory->data();
// Even though a shared memory block exists, the original application if( ! inst->primary ) {
// might have crashed. d->startPrimary( false );
// So only after a successful connection is the second instance d->memory->unlock();
// terminated. return;
d->socket->waitForConnected(100); }
delete d->memory;
// Check if another instance can be started
// Terminate the program using STDLib's exit function if( secondary && inst->secondary < secondaryInstances ) {
::exit(EXIT_SUCCESS); 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() SingleApplication::~SingleApplication()
{ {
Q_D(SingleApplication); Q_D(SingleApplication);
delete d;
}
delete d->memory; bool SingleApplication::isPrimary()
d->server->close(); {
Q_D(SingleApplication);
return d->server != NULL;
}
bool SingleApplication::isSecondary()
{
Q_D(SingleApplication);
return d->server == NULL;
} }
/** /**

5
singleapplication.h
View File

@ -22,9 +22,12 @@ class SingleApplication : public QAPPLICATION_CLASS
typedef QAPPLICATION_CLASS app_t; typedef QAPPLICATION_CLASS app_t;
public: public:
explicit SingleApplication(int&, char *[]); explicit SingleApplication(int &argc, char *argv[], uint8_t secondaryInstances = 0);
~SingleApplication(); ~SingleApplication();
bool isPrimary();
bool isSecondary();
Q_SIGNALS: Q_SIGNALS:
void showUp(); void showUp();