def __call__(self, environ, start_response):
        """
        This function have to be called in a worker thread, not the IO thread.
        """
        rargs = environ['wsgiorg.routing_args'][1]
        controller = rargs['controller']

        # Media Transport
        if controller == 'mt':
            name = rargs['name']
            if name in self.mts:
                return self.mts[name](environ, start_response)
            else:
                return not_found(environ, start_response)

        if controller != 'upnp':
            return not_found(environ, start_response)

        try:
            udn = rargs['udn']
            if isInIOThread():
                # TODO: read request body
                return self.devices[udn](environ, start_response)
            else:
                # read request body
                input = environ['wsgi.input']
                environ['upnp.body'] = input.read(self.SOAP_BODY_MAX)
                # call the app in IO thread
                args = [udn, environ, start_response]
                blockingCallFromThread(self.reactor, self._call_handler, args)
                return args[3]
        except Exception, e:
            #print e
            #print 'Unknown access: ' + environ['PATH_INFO']
            return not_found(environ, start_response)

 def execute(self, op):
     """
     @param op: operation to execute
     @return: None
     
     
     """
     self.fd = op.fd
     op.state = 'running'
     self.busy = True
     try:
         if (op.fd is None) and (op.name not in ('open', '_stop')):
             raise RuntimeError("Calling a file operation {0} on None".format(op.name))
         if op.name == '_stop':
             self.running = False
             result = True
         elif op.name == 'open':
             result = self.manager.take(open(*op.args, **op.kwargs))
             op.fd = result
         elif op.name == 'interaction':
             result = op.callable(op.fd.fd, *op.args, **op.kwargs)
         else:
             result = getattr(op.fd.fd, op.name)(*op.args, **op.kwargs)
         op.state = 'success'
         threads.blockingCallFromThread(self.manager.reactor, op.deferred.callback, result)
     except Exception as e:
         op.state = 'failure'
         threads.blockingCallFromThread(self.manager.reactor, op.deferred.errback, e)
     finally:
         self.busy = False

def main(iface):
    ret = 0
    try:
        a = AutoDHTServer()
        a.start(iface)

        b = AutoDHTServer()
        b.start(iface)

        time.sleep(4)

        print a.set(key="APA", value="banan")

        print a.get(key="APA")
        print b.get(key="APA")

        a.stop()
        b.stop()

    except:
        traceback.print_exc()
        ret = 1

    finally:
        if reactor.running:
            threads.blockingCallFromThread(reactor, reactor.stop)

    return ret

def update(event, bot):
	""" update will check for git update and restart bot if core files need updating. """

	gitpath = bot.getOption("git_path", module="pbm_updaterelaunch")
	if not gitpath:
		gitpath = "git"

	check_output([gitpath, "fetch"])
	changes = check_output([gitpath, "diff", "--name-status", "master", "origin/master"])
	print "CHANGES:", changes
	corechange = False
	modchange = False
	for line in changes.splitlines():
		if line.lstrip("M\t").startswith("modules/") or line.lstrip("A\t").startswith("modules/"):
			modchange = True
		elif line.endswith(".py"):
			corechange = True
	check_output([gitpath, "merge", "origin/master"])

	if corechange:
		print "RESTARTING BOT"
		#restart bot
		blockingCallFromThread(reactor, Settings.shutdown, True)

	elif modchange:
		#reload
		if bot.isModuleAvailable("pbm_reload"):
			bot.getModule("pbm_reload").admin_reload_bot(event, bot)
		else:
			bot.say("Module(s) updated but can't reload. reload module not available.")
	else:
		bot.say("Already up-to date.")

def syncRunServer(srv, host=C.MANAGER_HOST, port=None, username=None,
                  password=None, tls_mode=C.MANAGER_TLS):
    """Run a labrad server of the specified class in a synchronous context.

    Returns a context manager to be used with python's with statement that
    will yield when the server has started and then shut the server down after
    the context is exited.
    """
    from labrad import protocol

    tls_mode = C.check_tls_mode(tls_mode)

    if port is None:
        port = C.MANAGER_PORT_TLS if tls_mode == 'on' else C.MANAGER_PORT

    @inlineCallbacks
    def start_server():
        p = yield protocol.connect(host, port, tls_mode, username, password)
        yield srv.startup(p)

    @inlineCallbacks
    def stop_server():
        srv.disconnect()
        yield srv.onShutdown()

    thread.startReactor()
    blockingCallFromThread(reactor, start_server)
    try:
        yield
    finally:
        try:
            blockingCallFromThread(reactor, stop_server)
        except Exception:
            pass # don't care about exceptions here

	def setOption(self, opt, value, channel=None, inreactor=False, **kwargs):
		if not self.event.isPM() and channel is None:
			if inreactor: self._botcont._settings.setOption(opt, value, channel=self.event.target, **kwargs)
			else: blockingCallFromThread(reactor, self._botcont._settings.setOption, opt, value, channel=self.event.target, **kwargs)
		else:
			if inreactor: self._botcont._settings.setOption(opt, value, channel=channel, **kwargs)
			else: blockingCallFromThread(reactor, self._botcont._settings.setOption, opt, value, channel=channel, **kwargs)

def syncRunServer(srv, host=C.MANAGER_HOST, port=C.MANAGER_PORT, password=None):
    """Run a labrad server of the specified class in a synchronous context.

    Returns a context manager to be used with python's with statement that
    will yield when the server has started and then shut the server down after
    the context is exited.
    """

    if password is None:
        password = C.PASSWORD

    srv.password = password

    @inlineCallbacks
    def start_server():
        connector = reactor.connectTCP(host, port, srv)
        yield srv.onStartup()
        returnValue(connector)

    @inlineCallbacks
    def stop_server():
        yield srv.onShutdown()

    thread.startReactor()
    connector = blockingCallFromThread(reactor, start_server)
    try:
        yield
    finally:
        try:
            connector.disconnect()
            blockingCallFromThread(reactor, stop_server)
        except Exception:
            pass # don't care about exceptions here

    def __launch_blocker_thread(self, user_id, user_name, x11_display, linuxsb):
        try:
            proclist = gtop.proclist(gtop.PROCLIST_KERN_PROC_UID, int(user_id))
            env_lang_var = "C"

            if len(proclist) > 0:
                for proc in proclist:
                    lang_var = (
                        Popen('cat /proc/%s/environ | tr "\\000" "\\n" | grep ^LANG= ' % proc, shell=True, stdout=PIPE)
                        .stdout.readline()
                        .strip("\n")
                    )
                    if len(lang_var) > 0:
                        env_lang_var = lang_var.replace("LANG=", "")
                        break

            cmd = ["su", user_name, "-c", "LANG=%s DISPLAY=%s nanny-desktop-blocker" % (env_lang_var, x11_display)]
            print cmd

            p = Popen(cmd)
            print "[LinuxSessionFiltering] launching blocker (pid : %s)" % p.pid

            while p.poll() == None:
                time.sleep(1)
                b = threads.blockingCallFromThread(reactor, linuxsb.is_user_blocked, user_id)
                if b == False:
                    p.terminate()
                    print "[LinuxSessionFiltering] Unblocking session %s" % user_id
                    return

            print "[LinuxSessionFiltering] blocker terminated by user interaction"
            threads.blockingCallFromThread(reactor, linuxsb.blocker_terminate_from_thread, user_id, p.poll())
        except:
            print "[LinuxSessionFiltering] blocker terminated by exception"
            threads.blockingCallFromThread(reactor, linuxsb.blocker_terminate_from_thread, user_id, 1)

def wrapBlocking(f, *a, **kw):
    """This wraps a function to make sure all is halted until the function
    is done. This works also for functions that return deferreds."""
    try:
        threads.blockingCallFromThread(reactor, _wrapBlocking, f, *a, **kw)
    #        threads.blockingCallFromThread(reactor,f,*a,**kw)
    except:
        print "An exception was raised when wrapBlocking..."

 def open(self, path, flags):
   if threads.blockingCallFromThread(reactor, self.file_db.file_exists, self.key, path):
     file_path = os.path.join(self.file_dir, path[1:])
     if not self.file_is_up_to_date(file_path, path):
       # we need to find this file on the dht
       threads.blockingCallFromThread(reactor, self.file_service.download, path, file_path, self.key, True)
     
   return os.open(os.path.join(self.file_dir, path[1:]), flags)

 def flush(self, path, fh):
   os.fsync(fh)
   if fh in self.updateables:
     full_file_path = os.path.join(self.file_dir, path[1:])
     mtime = threads.blockingCallFromThread(reactor, self.file_db.update_file_mtime, self.key, path)
     threads.blockingCallFromThread(reactor, self.file_db.update_size, self.key, path, os.path.getsize(full_file_path))
     reactor.callFromThread(self.file_service.publish_file, self.key, path, full_file_path, mtime)
     self.updateables.remove(fh)
   return 0

 def create(self, path, mode):
   threads.blockingCallFromThread(reactor, self.file_db.add_file, self.key, path, mode, 0)
   real_path = os.path.join(self.file_dir, path[1:])
   dir_path = os.path.dirname(real_path)
   if not os.path.exists(dir_path):
     self.log('create dir: {}'.format(dir_path))
     os.makedirs(dir_path)
   self.log('create file: {}'.format(real_path))
   return os.open(real_path, os.O_WRONLY | os.O_CREAT, mode)

def teardown(config, store):
    if reactor.running:
        tangelo.log_info("VTKWEB", "Shutting down Twisted reactor")
        threads.blockingCallFromThread(reactor, reactor.stop)

    if "processes" in store:
        tangelo.log_info("VTKWEB", "Terminating VTKWeb processes")
        for p in store["processes"].values():
            p["process"].terminate()
            p["process"].wait()

 def run(self):
     sys.stderr.write("SshClientFactory running!\n")
     self.factory = SSHFactory(self)
     self.sem = Semaphore(0)
     def _connectLater():
         sys.stderr.write("SshClientFactory connecting asynchronously\n")
         reactor.connectTCP(self.host, self.port, self.factory)      #@UndefinedVariable
         sys.stderr.write("SshClientFactory connected\n")
     threads.blockingCallFromThread(reactor, _connectLater)          #@UndefinedVariable
     self.sem.acquire()

 def testDataReceived(self):
     self.assertNotEqual(self.protocol,None)
     threads.blockingCallFromThread(reactor,self.protocol.dataReceived,"This is a test line")
     threads.blockingCallFromThread(reactor,self.protocol.transport.loseConnection)
     unity.wait(0.1)
     f = open("testing.txt","r")
     self.assertNotEqual(f,None)
     l = f.readline()
     self.assertEqual(l,"This is a test line")
     f.close()

 def testDataReceived(self):
     self.assertNotEqual(self.protocol,None)
     threads.blockingCallFromThread(reactor,self.protocol.transport.write,"Start something")
     threads.blockingCallFromThread(reactor,self.protocol.transport.loseConnection)
     unity.wait(0.1)
     f = open("testingout.txt","r")
     self.assertNotEqual(f,None)
     for i in range(0,100):
         l = f.readline()
         self.assertEqual(l,"This is a test line" + str(i) +"\n")
     f.close()

 def stop(self):
     """
     Stop the connector, closing the connection.
     The Reactor loop remains active as the reactor cannot be restarted.
     """
     if self._host:
         #threads.blockingCallFromThread(reactor, self._factory.stopTrying)
         threads.blockingCallFromThread(reactor, self._disconnect)
     else:
         self._database = None
         self._stock_exchange.stop()
         self._stock_exchange = None

 def start(self, url=None, request=None, response=None):
     if url:
         self.fetch(url)
     elif request:
         self.fetch(request)
     elif response:
         request = response.request
         self.populate_vars(request, response)
     else:
         self.populate_vars()
     start_python_console(self.vars)
     threads.blockingCallFromThread(reactor, self.engine.stop)

 def file_is_up_to_date(self, file_path_on_disk, path):
   self.log('Is file up to date? {}'.format(file_path_on_disk))
   if not os.path.isfile(file_path_on_disk):
     return False
   if os.stat(file_path_on_disk).st_mtime < threads.blockingCallFromThread(reactor, self.file_db.get_file_mtime, self.key, path):
     return False
   return True

def help(event, bot):
	""" help [argument].  If argument is specified, get the help string for that command.
	Otherwise list all commands (same as commands function).
	"""
	cmd, arg = argumentSplit(event.argument, 2)
	# other modules should probably not do this:
	if cmd:
		cmd_mappings = blockingCallFromThread(reactor, _filter_mappings, bot, event.isPM, cmd)
		if cmd_mappings:
			for mapping in cmd_mappings:
				if arg:
					h = functionHelp(mapping.function, arg)
					if h: bot.say(h)
					else: bot.say("No help for (%s) available." % cmd)
				else:
					h = functionHelp(mapping.function)
					if h:
						command = mapping.command
						if isIterable(command) and len(command) > 1:
							bot.say("%s Aliases: %s" % (h, ", ".join(command)))
						else:
							bot.say(h)
					else:
						bot.say("No help for (%s) available." % cmd)
		else:
			bot.say("Command %s not found." % cmd)
	else:
		list_commands(bot, event.isPM())