def atomize(self, ticket, xmlFile, atomize, userConf = None):
        reaction = 'config/reactionDefinitions.json'
        try:
            logStream = StringIO.StringIO()
            if userConf:
                jsonpointer = tempfile.mkstemp(suffix='.json', text=True)
                with open(jsonpointer[1], 'w') as f:
                    f.write(userConf)
                jsonpointer = jsonpointer[1]
            else:
                jsonpointer = None
            result = libsbml2bngl.readFromString(xmlFile,
                                                 reaction, False, jsonpointer, atomize, logStream)

            if result and atomize:
                pointer = tempfile.mkstemp(suffix='.bngl', text=True)
                with open(pointer[1], 'w') as f:
                    f.write(result.finalString)
                print pointer[1]
                bnglresult = libsbml2bngl.postAnalyzeString(pointer[1], bngDistro, result.database)
            else:
                bnglresult = result.finalString
            self.addToDict(ticket, [bnglresult, logStream.getvalue(), {'finalspecies':result.database.species, 'rawreactions':result.database.rawreactions}])
            print 'success', ticket

        except:
            self.addToDict(ticket, -5)
            print 'failure', ticket
        finally:
            task.deferLater(reactor, 600,  freeQueue, ticket)

 def test_auto_retune(self):
     # pylint: disable=no-member
     
     f1 = 50e6  # avoid 100e6 because that's a default a couple of places
     dev = simulate.SimulatedDevice(freq=f1, allow_tuning=True)
     bandwidth = dev.get_rx_driver().get_output_type().get_sample_rate()
     top = Top(devices={'s1': dev})
     (_key, receiver) = top.add_receiver('AM', key='a')
     
     # initial state check
     receiver.set_rec_freq(f1)
     self.assertEqual(dev.get_freq(), f1)
     
     # one "page" up
     f2 = f1 + bandwidth * 3/4
     receiver.set_rec_freq(f2)
     self.assertEqual(dev.get_freq(), f1 + bandwidth)
     
     # must wait for tune_delay, which is 0 for simulated source, or it will look still-valid
     yield deferLater(the_reactor, 0.1, lambda: None)
     
     # one "page" down
     receiver.set_rec_freq(f1)
     self.assertEqual(dev.get_freq(), f1)
     
     yield deferLater(the_reactor, 0.1, lambda: None)
     
     # long hop
     receiver.set_rec_freq(200e6)
     self.assertEqual(dev.get_freq(), 200e6)

 def privmsg(self, user, target, msg):
     if not user or self.nickname not in msg:
         return
     sentence = self.factory.markov.generateString()
     deferLater(self.factory.reactor,
         len(sentence) / 500.0,
         self.msg, target, sentence)

 def __connect(self):
     print "lancement de la connection a redis",self.port," - ",self.unix
     retry = 10
     while not self.stopTrying:
         try: 
             if self.port:
                 self.redis = yield ClientCreator(reactor, Redis).connectTCP(__HOST__, self.port)
             elif self.unix:
                 self.redis = yield ClientCreator(reactor, Redis).connectUNIX(self.unix)
             else:
                 raise NotImplemented("PAS de port ou de socket fournit au client")
             r = yield self.redis.select(self.db)
             print r , self,self.port,self.unix
             self.ready.callback(True)
             
         except ConnectionRefusedError,e:
             print >>sys.stderr,"connection impossible",str(e)
             if not retry:
                 print "nombre d'essai fini on reessais dans 1 heure"
                 retry = 11
                 yield task.deferLater(reactor, 3600,lambda: None)
             retry -= 1
             print "on essais dans %i secondes"%(10 - retry)
             yield task.deferLater(reactor, (10 - retry),lambda: None)
         except Exception,e:
             print >>sys.stderr,"connection impossible sur ",self.port," ", self.unix," ",str(e)
             print "connection impossible sur ",self.port," ", self.unix," ",str(e)
             raise e

def parseNewPage(f, external_id, remaining=None, parser=None):
    spoon = 1024*10
    if remaining is None:
        remaining = f.tell()
        # TODO! how do i know, that the received fileis more than 1024???
        parser=etree.HTMLParser(target=NewTarget())#encoding='cp1251'
        f.seek(0)
        rd = f.read(spoon)
        parser.feed(rd)
        remaining -= spoon
        d = deferLater(reactor, 0, parseNewPage, f, external_id, remaining, parser)
        return d
    else:
        if remaining < spoon:
            rd = f.read(remaining)
            parser.feed(rd)
            f.close()
            parser.close()
            return parser.target.prepareNewComponents(external_id)
        else:
            rd = f.read(spoon)
            parser.feed(rd)
            remaining -= spoon
            d = deferLater(reactor, 1, parseNewPage, f, external_id, remaining, parser)
            return d

    def delay(self, seconds, function, *args, **kwargs):
        """
         delay(seconds, function, *args, **kwargs):

         Delay execution of function(*args, **kwargs) for up to 120 seconds.

         Error messages are relayed to caller unless a specific keyword
         'errobj' is supplied pointing to another object to receiver errors.
        """
        # handle the special error-reporting object
        errobj = self.caller
        if "errobj" in kwargs:
            errobj = kwargs["errobj"]
            del kwargs["errobj"]
        # set up some callbacks for delayed execution
        def errback(f, errobj):
            if errobj:
                try: f = f.getErrorMessage()
                except: pass
                errobj.msg("EVLANG delay error: " + str(f))
        def runfunc(func, *args, **kwargs):
            threads.deferToThread(func, *args, **kwargs).addErrback(errback, errobj)
        # get things going
        if seconds <= 120:
            task.deferLater(reactor, seconds, runfunc, function, *args, **kwargs).addErrback(errback, errobj)
        else:
            raise EvlangError("delay() can only delay for a maximum of 120 seconds (got %ss)." % seconds )
        return True

    def test_replay(self):
        config = self.getConfig(StompSpec.VERSION_1_0)

        client = async.Stomp(config)
        client = yield client.connect(host=VIRTUALHOST)
        client.subscribe(self.queue, self._eatFrame, {StompSpec.ACK_HEADER: 'client-individual'})
        client.send(self.queue, self.frame)
        while self.framesHandled != 1:
            yield task.deferLater(reactor, 0.01, lambda: None)
        client._protocol.loseConnection()
        try:
            yield client.disconnected
        except StompConnectionError:
            pass
        client = yield client.connect(host=VIRTUALHOST)
        client.send(self.queue, self.frame)
        while self.framesHandled != 2:
            yield task.deferLater(reactor, 0.01, lambda: None)

        try:
            yield client.disconnect(failure=RuntimeError('Hi'))
        except RuntimeError as e:
            self.assertEquals(str(e), 'Hi')

        client = yield client.connect(host=VIRTUALHOST)
        client.send(self.queue, self.frame)
        while self.framesHandled != 2:
            yield task.deferLater(reactor, 0.01, lambda: None)

        yield client.disconnect()

def setup_crawler(
        spider_class,
        **kwargs
    ):
    """
    Use scrapy in a script
    see http://doc.scrapy.org/en/latest/topics/practices.html

    :param spider_class: Spider class to test
    :type spider_class: text
    """

    def add_item(item):
        items.append(item)

    items = []
    # create Crawler
    settings = get_project_settings()
    crawler = Crawler(settings)
    crawler.configure()
    # connect collecting function on item_passed
    crawler.signals.connect(add_item, signals.item_passed)
    # create & connect spider
    spider = spider_class(**kwargs)
    crawler.crawl(spider)
    # start crawler
    log.start()
    crawler.start()
    # run crawler
    task.deferLater(reactor, 1, reactor.stop)
    reactor.run()
    return items

 def __checkPred(res):
     if res:
         target.callback(self)
         return res
     else:
         task.deferLater(reactor, poll, self.__wait, pred, poll, target)
         return

    def test_retry_after_timeout(self):
        """
        If a timeout happens, one can retry to consume message from the queue
        later on.
        """
        yield self.manager.connected((self.client, self.channel))
        yield self.channel.queue_declare(
            queue=self.queue_prefix + "uuid1")

        reply = yield self.client.queue(self.tag_prefix + "uuid1.0")
        reply.clock = self.clock
        event_queue = QueueWrapper(reply).event_queue

        d1 = self.manager.get_message("uuid1", "0")
        yield event_queue.get()
        yield deferLater(reactor, 0, lambda: None)
        self.clock.advance(self.manager.message_timeout + 1)
        yield assert_fails_with(d1, Timeout)

        # Let's wrap the queue again
        reply = yield self.client.queue(self.tag_prefix + "uuid1.1")
        reply.clock = self.clock
        event_queue = QueueWrapper(reply).event_queue

        d2 = self.manager.get_message("uuid1", "1")
        yield event_queue.get()
        yield deferLater(reactor, 0, lambda: None)
        self.clock.advance(self.manager.message_timeout + 1)
        yield assert_fails_with(d2, Timeout)

    def testManySubscribers(self):
        """Subscribe 3 clients, expects 9 reqeusts 3x subscribe, 3x disconnect, 3x logged_out
        Check that service records correct data at each step"""
        self.webServer.expectRequests(9)
        
        client1 = MockFlashClient(1)
        client2 = MockFlashClient(2)
        client3 = MockFlashClient(3)
        client1.connectedEvent.addCallback(lambda _: client1.sendSubscribeMessage([1]))
        client2.connectedEvent.addCallback(lambda _: client2.sendSubscribeMessage([1]))
        client3.connectedEvent.addCallback(lambda _: client3.sendSubscribeMessage([2]))
        
        def assertsOnService(*a):
            self.assertEqual(len(self.service.channels.keys()), 2)
            self.assertEqual(len(self.service.channels[1]), 2)
            self.assertEqual(len(self.service.channels[2]), 1)
            self.assertEqual(len(self.service.clients.keys()), 3)
            self.assertEqual(self.service.clients.keys(), [1, 2, 3])
        task.deferLater(reactor, 0.05, assertsOnService
            ).addCallback(lambda _: client1.connector.disconnect()
            ).addCallback(lambda _: client2.connector.disconnect()
            ).addCallback(lambda _: client3.connector.disconnect())

        def assertClientsDead(*a):
            for channel in self.service.channels.values():
                for client in channel:
                    self.assertFalse(client.is_alive)
        self.webServer.getNFirstRequests(6).addCallback(assertsOnService #clients are not removed from channels yet, only marked as dead
            ).addCallback(assertClientsDead)
            
        def assertClientsRemoved(*a):
            self.assertEqual(len(self.service.channels.keys()), 0)
            self.assertEqual(len(self.service.clients.keys()), 0)
        self.webServer.getAllRequests().addCallback(assertClientsRemoved)
        return defer.DeferredList([client1.disconnectedEvent, client2.disconnectedEvent, client3.disconnectedEvent])

    def onStart(self):
        self.graphs = {}

        self._persistPath = PERSIST_PATH
        self.loadAll()

        deferLater(reactor, PERSIST_INTERVAL, self.periodicPersist)

def region_instance(region_instance_seq):
    region, instance_id = region_instance_seq[0], region_instance_seq[1]
    print 'region:', region, 'instance:', instance_id
    if region == app_util.app_region:
        print 'connect to:', region
        for image in all_images(region):
            try:
                print 'de-register images:', image
                image.deregister()
                print 'wait 20 seconds'
                yield task.deferLater(reactor, 20, defer.succeed, True)        
            except Exception as e:
                print 'de-register error:', e
        print 'create image:', app_util.app_name
        r_conn = boto.ec2.connect_to_region(region)
        try:
            #for service_name in identify.service_names(region):
            #    os.system('sudo rm ' + identify.service_path(service_name) )
            for instance in r_conn.get_only_instances(instance_ids=[instance_id]):
                print 'instance to tag:', instance
                instance.add_tag(fixed.tag_state, fixed.state_replicate)
            ami_response = r_conn.create_image(instance_id, app_util.app_name)
            print 'ami response:', ami_response
        except Exception as e:
            print 'exception:', e       
    else:
        print 'region mismatch'
    yield task.deferLater(reactor, 1, defer.succeed, True)    
    print 'complete'
    reactor.callLater(0, reactor.stop)        

def expose(application):
    def attachDnsController(dns_controller):
        #########
        # Mammatus is the giver of names, on TCP and UDP.
        ##
        verbosity = 0
        tcpFactory = names_server.DNSServerFactory(clients=[dns_controller], verbose=verbosity)
        udpFactory = names_dns.DNSDatagramProtocol(tcpFactory)
        tcpFactory.noisy = udpFactory.noisy = verbosity
        dns_service = service.MultiService()
        internet.TCPServer(53, tcpFactory).setServiceParent(dns_service)
        internet.UDPServer(53, udpFactory).setServiceParent(dns_service)
        dns_service.setServiceParent(application)
    def attachHttpController(http_controller):
        #########
        # Mammatus feeds you, over HTTP.
        ##
        httpFactory = web_server.Site(http_controller)
        web_service = internet.TCPServer(80, httpFactory)
        web_service.setServiceParent(application)

    #########
    # Expose Mammia
    ##
    deferDnsController = deferLater(reactor, 0, dns.getController, model)
    deferDnsController.addCallback(attachDnsController)
    deferHttpController = deferLater(reactor, 0, http.getController, model)
    deferHttpController.addCallback(attachHttpController)

    def test_transaction_commit(self):
        config = self.getConfig(StompSpec.VERSION_1_0)
        client = async.Stomp(config)
        client.add(ReceiptListener())
        yield client.connect(host=VIRTUALHOST)
        client.subscribe(
            self.queue,
            {StompSpec.ACK_HEADER: StompSpec.ACK_CLIENT_INDIVIDUAL, StompSpec.ID_HEADER: "4711"},
            listener=SubscriptionListener(self._eatFrame, ack=True),
        )

        transaction = "4711"
        yield client.begin(transaction, receipt="%s-begin" % transaction)
        client.send(self.queue, b"test message with transaction", {StompSpec.TRANSACTION_HEADER: transaction})
        yield task.deferLater(reactor, 0.1, lambda: None)
        client.send(self.queue, b"test message without transaction")
        while self.framesHandled != 1:
            yield task.deferLater(reactor, 0.01, lambda: None)
        self.assertEquals(self.consumedFrame.body, b"test message without transaction")
        yield client.commit(transaction, receipt="%s-commit" % transaction)
        while self.framesHandled != 2:
            yield task.deferLater(reactor, 0.01, lambda: None)
        self.assertEquals(self.consumedFrame.body, b"test message with transaction")
        client.disconnect()
        yield client.disconnected

    def onResponse(self, responseContent, url):
        """Called when new content arrives"""

        links = extractLinks(responseContent, url)
        new_ = set(links.keys()).difference(self.history)
        self.history.update(new_)

        # send system notifications for new urls
        today = date.today()
        appendLog = ''

        messages = []

        for url in new_:
            title = links[url]
            title_enc = title.encode('utf-8', 'replace')
            msg = '{0} {1} : {2}\n'.format(today.strftime('%Y-%m-%d'), title_enc, url)
            appendLog = appendLog + msg

            if filterTitle(title, self.keywords) or filterUrl(url, self.domains):
                messages.append(MESSAGE_TPL.format(title, url, url))

        notify(messages)

        # update archive
        archiveName = today.strftime('archive-%Y-%m.txt')
        with open(archiveName, 'a') as f:
            f.write(appendLog)

        # schedule next crawl
        deferLater(reactor, self.interval, self.fetch)

def test_no_self_connect():
    """
    Test that when a producer connects, the consumer sends all existing
    subscription to it.

    """
    class WampConsumerServerFactory(ConsumerMixin, wamp.WampServerFactory):
        protocol = wamp.WampServerProtocol

    id = generate_id()
    consumer = ConsumerServer('localhost', 19200, id=id)
    consumer.processor = WampConsumerServerFactory('ws://localhost:19202')
    listenWS(consumer.processor)
    producer = ProducerClient(id=id)
    deferLater(reactor, 0.5, producer.connect, 'localhost', 19200)

    def check_connection():
        """
        Make sure producer has no connections, because it's been controlled.

        """
        print(set(producer.nodes))
        assert set(producer.nodes) == set()

    return deferLater(reactor, 1.0, check_connection)

def deferred_route_twilio_call(session_id, url, defer_time):
    '''
    Currently unused but potentially useful.
    '''
    twilio_rest_client = TwilioRestClient(API_tokens.TWILIO_SID, API_tokens.TWILIO_AUTH_TOKEN)
    deferLater(reactor, defer_time, twilio_rest_client.calls.route, session_id, url)
    return True

    def _do_pull(
            self, i, num_pulls, hostname, subscr_info):
        prefix = "{0} {1}".format(hostname, subscr_info)
        subscription = self._subscriptions_dct[(hostname, subscr_info)]
        if num_pulls > 0 and i == num_pulls:
            yield subscription.unsubscribe()
            del self._subscriptions_dct[(hostname, subscr_info)]
            if not self._subscriptions_dct:
                self._d.callback(None)
            return
        i += 1
        sys.stdout.write('{0} pull #{1}'.format(prefix, i))
        if num_pulls > 0:
            sys.stdout.write(' of {0}'.format(num_pulls))
        print

        def print_event(event):
            self._event_count += 1
            print "{0} {1}".format(prefix, event)

        log.debug("subscription.pull- {0} {1} (start)"
                  .format(hostname, subscr_info))
        yield subscription.pull(print_event)
        log.debug("subscription.pull- {0} {1} (finished)"
                  .format(hostname, subscr_info))
        task.deferLater(reactor, 0, self._do_pull, i, num_pulls, hostname,
                        subscr_info)

    def startInventory(self, *args):
        """Add a ROSpec to the reader and enable it."""
        if self.state == LLRPClient.STATE_INVENTORYING:
            logger.warn('ignoring startInventory() while already inventorying')
            return None

        logger.info('starting inventory')

        if self.duration:
            task.deferLater(reactor, self.duration, self.stopPolitely, True)

        rospec = self.getROSpec()['ROSpec']

        d2 = defer.Deferred()
        d2.addCallback(self.send_ENABLE_EVENTS_AND_REPORTS, onCompletion=None)
        d2.addErrback(self.panic, 'START_ROSPEC failed')

        d1 = defer.Deferred()
        d1.addCallback(self.send_START_ROSPEC, rospec, onCompletion=d2)
        d1.addErrback(self.panic, 'ENABLE_ROSPEC failed')

        d = defer.Deferred()
        d.addCallback(self.send_ENABLE_ROSPEC, rospec, onCompletion=d1)
        d.addErrback(self.panic, 'ADD_ROSPEC failed')

        self.send_ADD_ROSPEC(rospec, onCompletion=d)