Single Instance Application with command line interface

I wanted a python gtk application to open a new window on its first execution and then have subsequent executions send their command line arguments to the initial application rather than starting a new one. Here is the template which provides that functionality:

download singleinstanceapp.py

 
"""
This will only spawn one gtk application at a time.  If this command is executed 
while an instance is already running, the command line arguments are sent to the
already running application.
"""
 
import sys
 
import pygtk
pygtk.require('2.0')
import gtk
 
import socket
import threading
import SocketServer
 
class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
	def handle(self):
		data = self.request.recv(1024)
		cur_thread = threading.currentThread()
 
		# do something with the request:
		self.server.app.label.set_label(data)
 
		# could instead of the length of the input, could return error codes, more
		# information (if the request was a query), etc.  Using a length function
		# as a simple example
		response = 'string length: %d' % len(data)
 
		print 'responding to',data,'with',response
		self.request.send(response)
 
 
class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
	stopped = False
	allow_reuse_address = True
 
	def serve_forever(self):
		while not self.stopped:
			self.handle_request()
 
	def force_stop(self):
		self.server_close()
		self.stopped = True
		self.create_dummy_request()
 
	def create_dummy_request(self):
		client(self.server_address[0], self.server_address[1], 'last message for you')
 
 
def client(ip, port, message):
	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	sock.connect((ip, port))
	sock.send(message)
	response = sock.recv(1024)
	print "Received: %s" % response
	sock.close()
 
def start_server(host, port):
 
	server = ThreadedTCPServer((host, port), ThreadedTCPRequestHandler)
	ip, port = server.server_address
 
	# Start a thread with the server -- that thread will then start one
	# more thread for each request
	server_thread = threading.Thread(target=server.serve_forever)
	# Exit the server thread when the main thread terminates
	server_thread.setDaemon(True)
	server_thread.start()
 
	return server
 
 
class SingleInstanceApp:
	def destroy(self, widget, data=None):
		self.server.force_stop()
		gtk.main_quit()
		#exit(1) # I'm sorry but mozembed is making a huge pain in my ass
 
	def __init__(self, server):
		self.server = server
 
		# create a new window
		self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
		self.window.set_default_size(300,30)
		self.window.connect("destroy", self.destroy)
 
		self.label = gtk.Label("hello world")
		self.window.add(self.label)
 
		self.window.show_all()
 
		# and the window
		self.window.show()
 
	def main(self):
		gtk.gdk.threads_init()
		gtk.main()
 
if __name__ == "__main__":
	# pick some high port number here.  Should probably put this into a file 
	# somewhere.
	HOST, PORT = "localhost", 50010
 
	server = None
	try :
		client(HOST, PORT, ' '.join(sys.argv))
		print 'an insance was already open'
	except socket.error :
		exceptionType, exceptionValue, exceptionTraceback = sys.exc_info()
		if exceptionValue[0] == 111 :
			print 'this is the first instance'
			server = start_server(HOST, PORT)
		else :
			# don't actually know what happened ...
			raise
 
		app = SingleInstanceApp(server)
		server.app = app
		app.main()
 

The first execution of this script starts an asynchronous server on a predetermined port. This port is checked each time the script is run to see if another instance has already been started. If it has, the command line arguments are sent to the existing instance which can react to them however you want.

download singleinstanceapp.py

w

Just remembered that I hadn't published this script that I use fairly often which centers the currently active window on the screen using wmctrl (requires the patch provided)

wmctrl-patch

center_active_window.py