Page MenuHomePhabricator (Chris)
Files F130548

No OneTemporary
Actions

Authored By
Unknown
Size
8 KB
Referenced Files
None
Subscribers
None

View Options

diff --git a/README.md b/README.md
index 392813f..31e1b86 100644
--- a/README.md
+++ b/README.md
@@ -1,44 +1,51 @@
SingleApplication
=================
This is a replacement of the QSingleApplication for ```Qt5```.
Keeps the Primary Instance of your Application and kills each subsequent instance.
Usage
-----
The ```SingleApplication``` class inherits from ```QApplication```. Use it as if you are using the ```QApplication``` class.
The library uses your ```Organization Name``` and ```Application Name``` to set up a Local Socket. The first instance of your Application would start a ```QLocalServer``` and then listen for connections on the socket. Every subsequent instance of your application would attempt to connect to that socket. If successful it will be terminated, while in the Primary Instance, ```SingleApplication``` would emmit the ```showUp()``` signal.
The library uses ```stdlib``` to terminate the program with the ```exit()``` function.
Here is an example usage of the library:
```cpp
#include "singleapplication.h"
int main(int argc, char *argv[])
{
QApplication::setApplicationName("{Your App Name}");
QApplication::setOrganizationName("{Your Organization Name}");
SingleApplication app(argc, argv);
return app.exec();
}
```
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.
-Known bugs
-----------
-The ```SingleApplication``` class works really well for the scenario
-when a
-user starts your application twice, but the implementation it uses does not garantee it will work if two processes are started simultaniously (with a millisecond delay, which is only done programatically), in which case two instances might coexist on some platforms.
-_The issue is a work in proggress and should be fixed soon._
+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 with Unix 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.
+
+* ```SIGINT ``` - ```2```
+* ```SIGILL ``` - ```4```
+* ```SIGABRT``` - ```6```
+* ```SIGFPE ``` - ```8```
+* ```SIGSEGV``` - ```11```
+* ```SIGTERM``` - ```15```
+
License
-------
This library and it's supporting documentation are released under ```The MIT License (MIT)```.
diff --git a/singleapplication.cpp b/singleapplication.cpp
index 18044da..ca2b716 100644
--- a/singleapplication.cpp
+++ b/singleapplication.cpp
@@ -1,48 +1,133 @@
#include "singleapplication.h"
+#include <QSharedMemory>
+#include <QLocalSocket>
+#include <QLocalServer>
+#include <QMutex>
#include <cstdlib>
+#ifdef Q_OS_UNIX
+ #include <signal.h>
+ #include <unistd.h>
+#endif
+
+class SingleApplicationPrivate {
+public:
+ SingleApplicationPrivate(SingleApplication *q_ptr) : q_ptr(q_ptr) { }
+
+ void startServer(QString &serverName)
+ {
+ // Start a QLocalServer to listen for connections
+ server = new QLocalServer();
+ server->removeServer(serverName);
+ server->listen(serverName);
+ QObject::connect(server, SIGNAL(newConnection()), q_ptr, SLOT(slotConnectionEstablished()));
+ }
+
+#ifdef Q_OS_UNIX
+ void crashHandler()
+ {
+ // This guarantees the program will work even with multiple
+ // instances of SingleApplication in different threads
+ // Which in my opinion is idiotic, but lets handle that too
+ {
+ sharedMemMutex.lock();
+ sharedMem.append(memory);
+ sharedMemMutex.unlock();
+ }
+ // Handle any further termination signals to ensure the
+ // QSharedMemory block is deleted even if the process crashes
+ signal(SIGSEGV, SingleApplicationPrivate::terminate);
+ signal(SIGABRT, SingleApplicationPrivate::terminate);
+ signal(SIGFPE, SingleApplicationPrivate::terminate);
+ signal(SIGILL, SingleApplicationPrivate::terminate);
+ signal(SIGINT, SingleApplicationPrivate::terminate);
+ signal(SIGTERM, SingleApplicationPrivate::terminate);
+ }
+
+ static void terminate(int signum)
+ {
+ while( ! sharedMem.empty() ) {
+ delete sharedMem.back();
+ sharedMem.pop_back();
+ }
+ ::exit(128 + signum);
+ }
+
+ static QList<QSharedMemory*> sharedMem;
+ static QMutex sharedMemMutex;
+#endif
+
+ QSharedMemory *memory;
+ SingleApplication *q_ptr;
+ QLocalServer *server;
+ QLocalSocket *socket;
+};
+
+#ifdef Q_OS_UNIX
+ QList<QSharedMemory*> SingleApplicationPrivate::sharedMem;
+ QMutex SingleApplicationPrivate::sharedMemMutex;
+#endif
+
/**
* @brief Constructor. Checks and fires up LocalServer or closes the program
* if another instance already exists
* @param argc
* @param argv
*/
SingleApplication::SingleApplication(int &argc, char *argv[])
- : QApplication(argc, argv)
+ : QApplication(argc, argv), d_ptr(new SingleApplicationPrivate(this))
{
QString serverName = QApplication::organizationName() + QApplication::applicationName();
serverName.replace(QRegExp("[^\\w\\-. ]"), "");
- // Attempt to connect to the LocalServer
- socket = new QLocalSocket();
- socket->connectToServer(serverName);
- if(socket->waitForConnected(1000)){
- ::exit(EXIT_SUCCESS); // Terminate the program using STDLib's exit function
+ // Garantee thread safe behaviour with a shared memory block
+ d_ptr->memory = new QSharedMemory(serverName);
+
+ // Create a shared memory block with a minimum size of 1 byte
+ if( d_ptr->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_ptr->crashHandler();
+#endif
+ // Successful creation means that no main process exists
+ // So we start a Local Server to listen for connections
+ d_ptr->startServer(serverName);
} else {
- // If the connection is insuccessful, this is the main process
- // So we create a Local Server
- server = new QLocalServer();
- server->removeServer(serverName);
- server->listen(serverName);
- QObject::connect(server, SIGNAL(newConnection()), this, SLOT(slotConnectionEstablished()));
+ // Connect to the Local Server of the main process to notify it
+ // that a new process had been started
+ d_ptr->socket = new QLocalSocket();
+ d_ptr->socket->connectToServer(serverName);
+
+ // Even though a shared memory block exists, the original application might have crashed
+ // So only after a successful connection is the second instance terminated
+ if( d_ptr->socket->waitForConnected(100) )
+ {
+ ::exit(EXIT_SUCCESS); // Terminate the program using STDLib's exit function
+ } else {
+ delete d_ptr->memory;
+ ::exit(EXIT_SUCCESS);
+ }
}
}
/**
* @brief Destructor
*/
SingleApplication::~SingleApplication()
{
- server->close();
+ delete d_ptr->memory;
+ d_ptr->server->close();
}
/**
* @brief Executed when the showUp command is sent to LocalServer
*/
void SingleApplication::slotConnectionEstablished()
{
- QLocalSocket *socket = server->nextPendingConnection();
+ QLocalSocket *socket = d_ptr->server->nextPendingConnection();
socket->close();
delete socket;
emit showUp();
}
diff --git a/singleapplication.h b/singleapplication.h
index d49f8b1..669f878 100644
--- a/singleapplication.h
+++ b/singleapplication.h
@@ -1,31 +1,29 @@
#ifndef SINGLE_APPLICATION_H
#define SINGLE_APPLICATION_H
#include <QApplication>
-#include <QLocalSocket>
-#include <QLocalServer>
+
+class SingleApplicationPrivate;
/**
* @brief The SingleApplication class handles multipe instances of the same Application
* @see QApplication
*/
class SingleApplication : public QApplication
{
Q_OBJECT
public:
explicit SingleApplication(int&, char *[]);
~SingleApplication();
signals:
void showUp();
private slots:
void slotConnectionEstablished();
private:
- QLocalSocket *socket;
- QLocalServer *server;
-
+ SingleApplicationPrivate *d_ptr;
};
#endif // SINGLE_APPLICATION_H

File Metadata

Mime Type
text/x-diff
Expires
Mon, Jun 15, 11:31 PM (2 w, 3 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
72110
Default Alt Text
(8 KB)

Event Timeline