Exemplo n.º 1
0
def main():
    disp = Dispatcher()
    Tasklet.new(disp.loop)()
    host = Host(disp, "/dev/ttySP1")
    disp.add_host(host)
    while True:
        host.send([0x45])
Exemplo n.º 2
0
        def client():
            try:
                remote_client = RemoteClient()
                remote_client.connect(('localhost', 9081))
                remote_task = remote_client.lookup('testing123')
                self.assertFalse(remote_task is None)
                MSG_TEST.send(remote_task)(20, 30)
                MSG_TEST.send(remote_task)(30, 40)
                client_results.append(MSG_SUM.call(remote_task)(10, 20, 30))
                client_results.append(MSG_SUM.call(remote_task)(10, 20, 30))
                MSG_TEST.send(remote_task)(20, 30)
                MSG_TEST.send(remote_task)(30, 40)

                MSG_SLEEP.call(remote_task)(1)

                try:
                    MSG_SLEEP.call(remote_task, timeout = 1)(2)
                    self.fail("expected timeout")
                except TimeoutError:
                    pass #expected

                MSG_QUIT.send(remote_task)()
                Tasklet.sleep(2)
                remote_client.close()
            except Exception:
                logging.exception("")
                self.fail("")
Exemplo n.º 3
0
 def accept_iter(self):
     while True:
         try:
             yield self.accept()
         except Exception:
             self.log.exception("in accept_iter")
             Tasklet.sleep(1.0) #prevent hogging
Exemplo n.º 4
0
def main():
    disp = Dispatcher()
    Tasklet.new(disp.loop)()
    host = Host(disp, "/dev/ttySP1")
    disp.add_host(host)
    while True:
        host.send([0x45])
Exemplo n.º 5
0
 def callback(socket, count, event, args, kwargs):
     print count, event, Tasklet.current()
     if (count, event) == (1, "write"):
         pass
     elif (count, event) == (2, "read"):
         Tasklet.sleep(1.0)
         return "OK\r\n"
    def __receive(self):
        # Called in the receiving tasklet
        reader = self.__stream.reader

        try:
            buffer = ""
            processData = True
            while True:
                line = reader.read_line()
                if line <> '---':
                    buffer += line + "\n"
                else:
                    try:
                        data = yaml.load(buffer)
                        processData = True

                        if data == 'ping':
                            processData = False
                            self.sendData('pong')

                    except yaml.parser.ParserError:
                        q.logger.log("[SocketTaskHandler] Received bad formatted data: " + str(buffer), 3)
                    else:
                        if processData:
                            q.logger.log("[SocketTaskHandler] Received data: " + str(data), 5)
                            Tasklet.new(self.__messageHandler)(data, self)
                    buffer = ""

        except EOFError:
            q.logger.log("[SocketTaskHandler] Client disconnected.", 3)
            MSG_SOCKET_CLOSE.send(self.__sending_tasklet)()
            self.__stream.close()
Exemplo n.º 7
0
        def client():
            try:
                remote_client = RemoteClient()
                remote_client.connect(('localhost', 9081))
                remote_task = remote_client.lookup('testing123')
                self.assertFalse(remote_task is None)
                MSG_TEST.send(remote_task)(20, 30)
                MSG_TEST.send(remote_task)(30, 40)
                client_results.append(MSG_SUM.call(remote_task)(10, 20, 30))
                client_results.append(MSG_SUM.call(remote_task)(10, 20, 30))
                MSG_TEST.send(remote_task)(20, 30)
                MSG_TEST.send(remote_task)(30, 40)

                MSG_SLEEP.call(remote_task)(1)

                try:
                    MSG_SLEEP.call(remote_task, timeout = 1)(2)
                    self.fail("expected timeout")
                except TimeoutError:
                    pass #expected

                MSG_QUIT.send(remote_task)()
                Tasklet.sleep(2)
                remote_client.close()
            except Exception:
                logging.exception("")
                self.fail("")
Exemplo n.º 8
0
    def testJoinAll(self):
        
        def sub0():
            raise Exception("a proper exc")
        
        def sub1():
            return 1
        
        def sub2():
            return 2
        
        def sub3():
            raise Exception("test exc")
        
        subs = [Tasklet.new(sub)() for sub in [sub0, sub1, sub2, sub3]]
        results = Tasklet.join_all(subs)
        
        self.assertTrue(isinstance(results[0], JoinError))
        self.assertTrue(isinstance(results[0].cause, Exception))
        self.assertEquals("a proper exc", str(results[0].cause), Exception)
        self.assertEquals(1, results[1])
        self.assertEquals(2, results[2])

        self.assertTrue(isinstance(results[3], JoinError))
        self.assertTrue(isinstance(results[3].cause, Exception))
        self.assertEquals("test exc", str(results[3].cause), Exception)
Exemplo n.º 9
0
 def server():
     server_endpoint = None
     try:
         remote_server = RemoteServer()
         server_endpoint = remote_server.serve(('localhost', 9081))
         remote_server.register('testing123')
         for msg, args, kwargs in Tasklet.receive():
             if msg.match(MSG_SUM):
                 server_results.append('s')
                 msg.reply(sum(args))
             elif msg.match(MSG_TEST):
                 server_results.append('t')
             elif msg.match(MSG_QUIT):
                 server_results.append('q')
                 break
             elif msg.match(MSG_SLEEP):
                 server_results.append('sl')
                 Tasklet.sleep(args[0])
                 msg.reply(True)
     except Exception:
         logging.exception("")
         self.fail("")
     finally:
         if server_endpoint is not None: 
             server_endpoint.close()
Exemplo n.º 10
0
 def a():
     while True:
         #for i in xrange(0, 3):
         #    try:
         #        print "Line %d ReadROM: %s" % (i + 1, dispatcher.request(MicroLANReadROM(i)))
         #    except MicroLANError as e:
         #        print "Line %d ReadROM: %s" % (i + 1, type(e).__name__)
         devs = {}
         for i in xrange(0, 3):
             try:
                 req = MicroLANListAll(dispatcher, i)
                 devices = req.execute()
             except MicroLANError as e:
                 print "Line %d SearchROM: %s" % (i + 1, type(e).__name__)
             else:
                 #print "Line %d SearchROM: %s" % (i + 1, devices)
                 if devices:
                     try:
                         dispatcher.request(MicroLANConvertTemperature(i))
                     except MicroLANError as e:
                         print "Line %d ConvertTemperature: %s" % (i + 1, type(e).__name__)
                     else:
                         devs[i] = devices
         Tasklet.sleep(1)
         print "---"
         for i in xrange(0, 3):
             devices = devs.get(i)
             if devices:
                 print "Line %d" % (i + 1)
                 for dev in devices:
                     try:
                         print "ReadTemperature of %s: %.1f" % (dev, dispatcher.request(MicroLANReadTemperature(i, dev)))
                     except MicroLANError as e:
                         print "ReadTemperature of %s: %s" % (dev, type(e).__name__)
         Tasklet.sleep(2)
Exemplo n.º 11
0
 def connect(self, addr):
     assert self._stream is None, "must not be disconneted before connecting"
     self._stream = BufferedStream(Socket.connect(addr, Timeout.current()))
     self._command_queue = Deque()
     self._response_queue = Deque()
     self._command_writer_task = Tasklet.new(self._command_writer)()
     self._response_reader_task = Tasklet.new(self._response_reader)()
 def sendToDrp(self, name, *args, **kwargs):
     MSG_DRP_CALL.send(self.__tasklet)(Tasklet.current(), name, *args, **kwargs)
     (msg, args, kwargs) = Tasklet.receive().next()
     if msg.match(MSG_DRP_RETURN):
         return args[0]
     elif msg.match(MSG_DRP_EXCEPTION):
         raise args[0]
Exemplo n.º 13
0
 def testDeadlocks(self):
     def process(cnn, cur, val):
         try:
             cur.execute("begin")
             cur.execute("insert into tbltest (test_id) values (1)")
             cur.execute("select sleep(2)")
             cur.execute("update tbltest set test_id=%d" % val)
             cur.execute("select sleep(2)")
             cur.execute("commit")
             return False
         except dbapi.Error as e:
             return "deadlock" in str(e).lower()
     cnn1 = dbapi.connect(host = DB_HOST, user = DB_USER, passwd = DB_PASSWD, db = DB_DB)
     cur1 = cnn1.cursor()
     cnn2 = dbapi.connect(host = DB_HOST, user = DB_USER, passwd = DB_PASSWD, db = DB_DB)
     cur2 = cnn2.cursor()
     t1 = Tasklet.new(process)(cnn1, cur1, 2)
     t2 = Tasklet.new(process)(cnn2, cur2, 3)
     res = Tasklet.join_all([t1, t2])
     self.assertTrue(res[0] or res[1],
             'At least one of the queries expected to fail due to deadlock (innodb must be used)')
     # Both connections must survive after error
     cur1.execute("select 1")
     cur2.execute("select 2")
     cur1.close()
     cnn1.close()
     cur2.close()
     cnn2.close()
Exemplo n.º 14
0
    def testMultiClientMultiServer(self):

        N = 40 * 100
        keys = ['test%d' % i for i in range(N)]

        mc = Memcache()
        mc.set_servers([
            ((MEMCACHE_IP, 11211), 100), ((MEMCACHE_IP, 11212), 100),
            ((MEMCACHE_IP, 11213), 100), ((MEMCACHE_IP, 11214), 100)
        ])

        with unittest.timer() as tmr:
            for i in range(N):
                self.assertEquals(MemcacheResult.STORED,
                                  mc.set(keys[i], 'hello world %d' % i))
        print 'single client multi server single set keys/sec', tmr.sec(N)

        stride = 40

        def fetcher():
            for i in range(0, N, stride):
                result, values = mc.get_multi(keys[i:i + stride])
                self.assertEquals(MemcacheResult.OK, result)
                self.assertEquals(stride, len(values))

        for nr_clients in [2, 4, 8, 16]:  #,32,64,128]:
            with unittest.timer() as tmr:
                for i in range(nr_clients):
                    Tasklet.new(fetcher)()
                Tasklet.join_children()
            print 'multi client (%d), multi server multi get (%d) keys/sec' % (
                nr_clients, stride), tmr.sec(N * nr_clients)
Exemplo n.º 15
0
    def testPushPop(self):

        self.assertEquals(TIMEOUT_NEVER, Timeout.current())

        Timeout.push(30)
        self.assertAlmostEqual(30, Timeout.current(), places=1)
        Timeout.pop()
        self.assertEquals(TIMEOUT_NEVER, Timeout.current())
        Timeout.push(30)
        self.assertAlmostEqual(30, Timeout.current(), places=1)
        Tasklet.sleep(1.0)
        self.assertAlmostEqual(29, Timeout.current(), places=1)
        #push a temporary short timeout
        Timeout.push(5)
        self.assertAlmostEqual(5, Timeout.current(), places=1)
        Timeout.pop()
        self.assertAlmostEqual(29, Timeout.current(), places=1)

        #try to push a new longer timeout than the parent timeout
        #this should fail, e.g. it will keep the parent timeout
        Timeout.push(60)
        self.assertAlmostEqual(29, Timeout.current(), places=1)
        Timeout.pop()
        self.assertAlmostEqual(29, Timeout.current(), places=1)
        Timeout.pop()
        self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Exemplo n.º 16
0
 def connect(self, addr):
     assert self._stream is None, "must not be disconneted before connecting"
     self._stream = BufferedStream(Socket.connect(addr, Timeout.current()))
     self._command_queue = Deque()
     self._response_queue = Deque()
     self._command_writer_task = Tasklet.new(self._command_writer)()
     self._response_reader_task = Tasklet.new(self._response_reader)()
Exemplo n.º 17
0
    def testPushPop(self):

        self.assertEquals(TIMEOUT_NEVER, Timeout.current())

        Timeout.push(30)
        self.assertAlmostEqual(30, Timeout.current(), places = 1)
        Timeout.pop()
        self.assertEquals(TIMEOUT_NEVER, Timeout.current())
        Timeout.push(30)
        self.assertAlmostEqual(30, Timeout.current(), places = 1)
        Tasklet.sleep(1.0)
        self.assertAlmostEqual(29, Timeout.current(), places = 1)
        #push a temporary short timeout
        Timeout.push(5)
        self.assertAlmostEqual(5, Timeout.current(), places = 1)
        Timeout.pop()
        self.assertAlmostEqual(29, Timeout.current(), places = 1)

        #try to push a new longer timeout than the parent timeout
        #this should fail, e.g. it will keep the parent timeout
        Timeout.push(60)
        self.assertAlmostEqual(29, Timeout.current(), places = 1)
        Timeout.pop()
        self.assertAlmostEqual(29, Timeout.current(), places = 1)
        Timeout.pop()
        self.assertEquals(TIMEOUT_NEVER, Timeout.current())
Exemplo n.º 18
0
    def testLock(self):
        lock = Lock()
        self.assertEquals(True, lock.acquire())   
        self.assertEquals(True, lock.is_locked())    
        self.assertEquals(None, lock.release())

        xs = []

        def t(x):
            try:
                with lock:
                    Tasklet.sleep(1.0)
                    xs.append(x)
                return x
            except TimeoutError:
                pass

        start = time.time()
        for i in range(5):
            Tasklet.new(t)(i)

        join_result = Tasklet.join_children()
        self.assertEquals(5, len(join_result))
        self.assertEquals(10, sum(xs))

        end = time.time()
        self.assertAlmostEqual(5.0, end - start, places = 1)
Exemplo n.º 19
0
    def testMessageSend(self):
        
        class MSG_PONG(Message): pass
        class MSG_PING(Message): pass

        def c(parent):
            for msg, args, kwargs in Tasklet.receive():     
                if msg.match(MSG_PING):
                    self.assertEquals((10, ), args)
                    MSG_PONG.send(parent)(20)

        parent = Tasklet.current()
        child = Tasklet.new(c)(parent)
        i = 0
        MSG_PING.send(child)(10)
        for msg, args, kwargs in Tasklet.receive():
            if msg.match(MSG_PONG):
                self.assertEquals((20, ), args)
                i += 1
                if i > 5: break
                MSG_PING.send(child)(10)

        self.assertEquals(6, i)

        try:
            start = time.time()
            for msg, args, kwargs in Tasklet.receive(2.0):
                self.fail('expected timeout error')            
        except TimeoutError:
            end = time.time()
            self.assertAlmostEqual(2.0, end - start, places = 1)

        child.kill()
Exemplo n.º 20
0
 def accept_iter(self):
     while True:
         try:
             yield self.accept()
         except Exception:
             self.log.exception("in accept_iter")
             Tasklet.sleep(1.0)  #prevent hogging
Exemplo n.º 21
0
    def testJoinAll(self):
        def sub0():
            raise Exception("a proper exc")

        def sub1():
            return 1

        def sub2():
            return 2

        def sub3():
            raise Exception("test exc")

        subs = [Tasklet.new(sub)() for sub in [sub0, sub1, sub2, sub3]]
        results = Tasklet.join_all(subs)

        self.assertTrue(isinstance(results[0], JoinError))
        self.assertTrue(isinstance(results[0].cause, Exception))
        self.assertEquals("a proper exc", str(results[0].cause), Exception)
        self.assertEquals(1, results[1])
        self.assertEquals(2, results[2])

        self.assertTrue(isinstance(results[3], JoinError))
        self.assertTrue(isinstance(results[3].cause, Exception))
        self.assertEquals("test exc", str(results[3].cause), Exception)
Exemplo n.º 22
0
    def __init__(self,
                 connector,
                 dbargs,
                 max_connections=10,
                 connect_timeout=-1,
                 max_connection_age=None,
                 max_connection_age_reaper_interval=60):
        super(Pool, self).__init__(connector, dbargs, connect_timeout)

        self._max_connections = max_connections
        self._max_connection_age = max_connection_age

        #some statistics
        self._queue_wait_timer_statistic = StatisticExtra()
        self._queue_wait_tasks_statistic = StatisticExtra()

        self._pool = Deque()  #the pool of available idle connections

        #watch for server disconnects on idle connections:
        self._idle_disconnect_channel = Channel()
        self._idle_disconnect_reaper_task = Tasklet.loop(
            self._idle_disconnect_reaper, daemon=True)()

        #check for old connections
        if self._max_connection_age is not None:
            self._old_connection_reaper_task = Tasklet.interval(
                max_connection_age_reaper_interval,
                self._old_connection_reaper,
                daemon=True)()
Exemplo n.º 23
0
    def testMessageSend(self):
        class MSG_PONG(Message):
            pass

        class MSG_PING(Message):
            pass

        def c(parent):
            for msg, args, kwargs in Tasklet.receive():
                if msg.match(MSG_PING):
                    self.assertEquals((10, ), args)
                    MSG_PONG.send(parent)(20)

        parent = Tasklet.current()
        child = Tasklet.new(c)(parent)
        i = 0
        MSG_PING.send(child)(10)
        for msg, args, kwargs in Tasklet.receive():
            if msg.match(MSG_PONG):
                self.assertEquals((20, ), args)
                i += 1
                if i > 5: break
                MSG_PING.send(child)(10)

        self.assertEquals(6, i)

        try:
            start = time.time()
            for msg, args, kwargs in Tasklet.receive(2.0):
                self.fail('expected timeout error')
        except TimeoutError:
            end = time.time()
            self.assertAlmostEqual(2.0, end - start, places=1)

        child.kill()
Exemplo n.º 24
0
    def testMaxAge(self):

        pool = Pool(client,
                    DB_ARGS,
                    max_connections=2,
                    connect_timeout=2,
                    max_connection_age=2,
                    max_connection_age_reaper_interval=1)

        new, cnn1 = pool.connect()
        new, cnn2 = pool.connect()

        pool.disconnect(cnn1)

        self.assertTrue(cnn1.is_connected())
        self.assertTrue(cnn2.is_connected())

        Tasklet.sleep(3)

        #cnn1 was idle, should be disconnected now by old age reaper
        self.assertFalse(cnn1.is_connected())
        self.assertTrue(cnn2.is_connected())

        pool.disconnect(cnn2)
        #cnn2 should be closed on old age

        self.assertFalse(cnn1.is_connected())
        self.assertFalse(cnn2.is_connected())
Exemplo n.º 25
0
 def handle_accept(self):
     if self.acceptChannel and self.acceptChannel.balance < 0:
         t = asyncore.dispatcher.accept(self)
         if t is None:
             return
         t[0].setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
         Tasklet.new(self.acceptChannel.send)(t)
Exemplo n.º 26
0
 def query_services(self, service_type, url, timeout=10, call_int=False, delay=0, *args, **kwargs):
     inst = self.app().inst
     daemons = inst.int_app.obj(DBCluster, "daemons", silent=True)
     tasklets = []
     for dmnid, dmninfo in daemons.data.items():
         services = dmninfo.get("services", {})
         for svcid, svcinfo in services.items():
             if svcinfo.get("type") != service_type:
                 continue
             if call_int:
                 found = False
                 for sid, sinfo in services.items():
                     if sinfo.get("type") != "int":
                         continue
                     found = True
                     svcid = sid
                     svcinfo = sinfo
                     break
                 if not found:
                     continue
             if "addr" not in svcinfo:
                 continue
             if "port" not in svcinfo:
                 continue
             task = Tasklet.new(self.do_query_service_exc)
             tasklets.append(task)
             task(svcid, svcinfo, url, timeout, *args, **kwargs)
             if delay > 0:
                 Tasklet.sleep(delay)
     Tasklet.join_all(tasklets)
Exemplo n.º 27
0
def main():
    try:
        dispatcher = Dispatcher()
        host = Host(dispatcher, "/dev/ttyUSB0")
        dispatcher.add_host(host)
        Tasklet.new(dispatcher.loop)()

        print "Calibration: %s" % host.calibrate_baudrate()
        print "Available: %s" % host.available()

        dev = RadioDevice(dispatcher, 2)
        print "Protocol version: %s" % dev.protocol_version

        # Running HTTP server
        application = django.core.handlers.wsgi.WSGIHandler()
        def app_wrapper(*args, **kwargs):
            try:
                return application(*args, **kwargs)
            except Exception as e:
                print e
        server = WSGIServer(application)
        server.serve(('localhost', 8080))

        while True:
            print "ADC data: %s, supply voltage: %.2f" % (dev.adc_data(), dev.supply_voltage())
            Tasklet.sleep(1)

        os._exit(0)
    except Exception as e:
        logging.exception(e)
        os._exit(1)
Exemplo n.º 28
0
 def callback(socket, count, event, args, kwargs):
     print count, event, Tasklet.current()
     if (count, event) == (1, "write"):
         pass
     elif (count, event) == (2, "read"):
         Tasklet.sleep(1.0)
         return "OK\r\n"
Exemplo n.º 29
0
def main():

    options = parse_options()

    options.dbargs = {'host': options.host, 
                      'port': options.port, 
                      'user': options.user, 
                      'passwd': options.passwd, 
                      'db': options.db}
        
    if options.use_pool:
        options.pool = Pool(client, options.dbargs, options.use_pool)
    
    for i in range(options.sessions):
        session = Session(options)
        Tasklet.new(session.run)()

    try:
        query_count = options.query_count
        start = time.time()
        query_count_done = sum(Tasklet.join_children())
        end = time.time()
        print end - start, query_count_done, query_count_done / (end - start)
    except Exception:
        logging.exception("must be an error in one of the sessions")
    
    quit()
Exemplo n.º 30
0
    def testMultiClientMultiServer(self):

        N = 40 * 100
        keys = ['test%d' % i for i in range(N)]

        mc = Memcache()
        mc.set_servers([((MEMCACHE_IP, 11212), 100),
                        ((MEMCACHE_IP, 11213), 100),
                        ((MEMCACHE_IP, 11214), 100),
                        ((MEMCACHE_IP, 11215), 100)])

        with unittest.timer() as tmr:
            for i in range(N):
                self.assertEquals(MemcacheResult.STORED, mc.set(keys[i], 'hello world %d' % i))
        print 'single client multi server single set keys/sec', tmr.sec(N)

        stride = 40
        def fetcher():
            for i in range(0, N, stride):
                result, values = mc.get_multi(keys[i:i+stride])
                self.assertEquals(MemcacheResult.OK, result)
                self.assertEquals(stride, len(values))

        for nr_clients in [2,4,8,16]:#,32,64,128]:
            with unittest.timer() as tmr:
                for i in range(nr_clients):
                    Tasklet.new(fetcher)()
                Tasklet.join_children()
            print 'multi client (%d), multi server multi get (%d) keys/sec' % (nr_clients, stride), tmr.sec(N * nr_clients)
Exemplo n.º 31
0
 def server():
     server_endpoint = None
     try:
         remote_server = RemoteServer()
         server_endpoint = remote_server.serve(('localhost', 9081))
         remote_server.register('testing123')
         for msg, args, kwargs in Tasklet.receive():
             if msg.match(MSG_SUM):
                 server_results.append('s')
                 msg.reply(sum(args))
             elif msg.match(MSG_TEST):
                 server_results.append('t')
             elif msg.match(MSG_QUIT):
                 server_results.append('q')
                 break
             elif msg.match(MSG_SLEEP):
                 server_results.append('sl')
                 Tasklet.sleep(args[0])
                 msg.reply(True)
     except Exception:
         logging.exception("")
         self.fail("")
     finally:
         if server_endpoint is not None:
             server_endpoint.close()
Exemplo n.º 32
0
 def testerrors(self):
     mc = Memcached(pool=MemcachedPool(size=4))
     tasks = []
     for i in xrange(0, 100):
         tasks.append(Tasklet.new(self.error_thread)(mc))
     for i in xrange(0, 100):
         tasks.append(Tasklet.new(self.handled_thread)(mc))
     Tasklet.join_all(tasks)
Exemplo n.º 33
0
 def handle_connect_event(self):
     err = self.socket.getsockopt(SOL_SOCKET, SO_ERROR)
     if err != 0:
         self.connected = False
         Tasklet.new(self.recvChannel.send_exception)(stdsocket.error, err)
     else:
         self.handle_connect()
         self.connected = True
Exemplo n.º 34
0
    def tearDown(self):
        MemcacheConnectionManager.create("default").close_all()

        cmd = 'killall %s' % MEMCACHED_BIN
        self.log.debug(cmd)
        os.system(cmd)

        Tasklet.sleep(1.0) #should be enough for memcached to go down
 def log(self, message):
     if hasattr(Tasklet.current(), 'jobguid'):
         jobguid = Tasklet.current().jobguid
         q.workflowengine.jobmanager.appendJobLog(jobguid, message)
     else:
         # No job in the context, do nothing
         pass
     return True
Exemplo n.º 36
0
 def testerrors(self):
     mc = Memcached(pool=MemcachedPool(size=4))
     tasks = []
     for i in xrange(0, 100):
         tasks.append(Tasklet.new(self.error_thread)(mc))
     for i in xrange(0, 100):
         tasks.append(Tasklet.new(self.handled_thread)(mc))
     Tasklet.join_all(tasks)
Exemplo n.º 37
0
 def ping(self):
     while True:
         if self._calibrated:
             pkt = [0xf2]
             for i in xrange(0, 8):
                 pkt.append(random.randint(0, 255))
             self.send(pkt)
         Tasklet.sleep(7)
Exemplo n.º 38
0
 def t(x):
     try:
         with sema:
             Tasklet.sleep(1.0)
             xs.append(x)
         return x
     except TimeoutError:
         pass
Exemplo n.º 39
0
    def tearDown(self):
        MemcacheConnectionManager.create("default").close_all()

        cmd = 'killall %s' % MEMCACHED_BIN
        self.log.debug(cmd)
        os.system(cmd)

        Tasklet.sleep(1.0)  #should be enough for memcached to go down
Exemplo n.º 40
0
 def testBlock(self):
     d = Deque()
     Tasklet.later(1.0, d.append)(20)
     s = time.time()
     #should block on pop
     self.assertEquals(20, d.pop(True))
     e = time.time()
     self.assertTrue((e - s) > 1.0)
Exemplo n.º 41
0
 def log(self, message):
     if hasattr(Tasklet.current(), 'jobguid'):
         jobguid = Tasklet.current().jobguid
         q.workflowengine.jobmanager.appendJobLog(jobguid, message)
     else:
         # No job in the context, do nothing
         pass
     return True
Exemplo n.º 42
0
 def ping(self):
     while True:
         if self._calibrated:
             pkt = [0xf2]
             for i in xrange(0, 8):
                 pkt.append(random.randint(0, 255))
             self.send(pkt)
         Tasklet.sleep(7)
Exemplo n.º 43
0
 def sendall(self, data, flags=0):
     # WARNING: this will busy wait until all data is sent
     # It should be possible to do away with the busy wait with
     # the use of a channel.
     self.sendBuffer += data
     while self.sendBuffer:
         Tasklet.sleep(0.01)
     return len(data)
Exemplo n.º 44
0
 def sendToDrp(self, name, *args, **kwargs):
     MSG_DRP_CALL.send(self.__tasklet)(Tasklet.current(), name, *args,
                                       **kwargs)
     (msg, args, kwargs) = Tasklet.receive().next()
     if msg.match(MSG_DRP_RETURN):
         return args[0]
     elif msg.match(MSG_DRP_EXCEPTION):
         raise args[0]
Exemplo n.º 45
0
 def __init__(self, dispatcher, devname):
     "Constructor. devname - serial port devname"
     self.dispatcher = dispatcher
     self.stream = SerialStream(devname)
     self._next_pkt_id = 0
     self._devname = devname
     self._sendlock = Lock()
     self._calibrated = False
     Tasklet.new(self.auto_calibrate_baudrate)()
Exemplo n.º 46
0
 def __init__(self, dispatcher, devname):
     "Constructor. devname - serial port devname"
     self.dispatcher = dispatcher
     self.stream = SerialStream(devname)
     self._next_pkt_id = 0
     self._devname = devname
     self._sendlock = Lock()
     self._calibrated = False
     Tasklet.new(self.auto_calibrate_baudrate)()
Exemplo n.º 47
0
 def c():
     for msg, args, kwargs in Tasklet.receive():
         if msg.match(MSG_TEST_SUM):
             msg.reply(sum(args))
         elif msg.match(MSG_TEST_MAX):
             msg.reply(max(args))
         elif msg.match(MSG_TEST_SLEEP):     
             Tasklet.sleep(args[0])
             msg.reply(True)
Exemplo n.º 48
0
 def testPushPop4(self):
     self.assertEquals(TIMEOUT_NEVER, Timeout.current())
     Tasklet.set_current_timeout(10.0)
     self.assertAlmostEqual(10.0, Timeout.current(), places = 1)
     Timeout.push(TIMEOUT_CURRENT)
     self.assertAlmostEqual(10.0, Timeout.current(), places = 1)
     Timeout.pop()
     self.assertAlmostEqual(10.0, Timeout.current(), places = 1)
     Tasklet.set_current_timeout(TIMEOUT_NEVER)
Exemplo n.º 49
0
def main(timeout = None):

    logging.basicConfig()
    logging.root.setLevel(logging.DEBUG)

    if timeout is not None:
        Tasklet.later(timeout, quit, name = 'unittest_timeout')(EXIT_CODE_TIMEOUT)
        
    dispatch(unittest.main)
Exemplo n.º 50
0
 def c():
     for msg, args, kwargs in Tasklet.receive():
         if msg.match(MSG_TEST_SUM):
             msg.reply(sum(args))
         elif msg.match(MSG_TEST_MAX):
             msg.reply(max(args))
         elif msg.match(MSG_TEST_SLEEP):
             Tasklet.sleep(args[0])
             msg.reply(True)
Exemplo n.º 51
0
    def memcachedRun(self):
        self.log.debug("using memcached daemon: %s", MEMCACHED_BIN)

        for i in range(4):
            cmd = '%s -m 10 -p %d -u nobody -l 127.0.0.1&' % (MEMCACHED_BIN, 11212 + i)
            self.log.debug(cmd)
            os.system(cmd)

        Tasklet.sleep(1.0) #should be enough for memcached to get up and running
Exemplo n.º 52
0
 def testPushPop4(self):
     self.assertEquals(TIMEOUT_NEVER, Timeout.current())
     Tasklet.set_current_timeout(10.0)
     self.assertAlmostEqual(10.0, Timeout.current(), places=1)
     Timeout.push(TIMEOUT_CURRENT)
     self.assertAlmostEqual(10.0, Timeout.current(), places=1)
     Timeout.pop()
     self.assertAlmostEqual(10.0, Timeout.current(), places=1)
     Tasklet.set_current_timeout(TIMEOUT_NEVER)
Exemplo n.º 53
0
    def testJoinResult(self):
        """test normal join and checks that parent will get child result"""
        def child(i):
            return i

        ch1 = Tasklet.new(child)(1)
        ch2 = Tasklet.new(child)(2)  

        self.assertEquals(1, Tasklet.join(ch1))
        self.assertEquals(2, Tasklet.join(ch2))
Exemplo n.º 54
0
def ManageSockets():
    global managerRunning

    while len(asyncore.socket_map):
        # Check the sockets for activity.
        asyncore.poll(0.05)
        # Yield to give other tasklets a chance to be scheduled.
        Tasklet.sleep(0.01)

    managerRunning = False
Exemplo n.º 55
0
    def testJoinResult(self):
        """test normal join and checks that parent will get child result"""
        def child(i):
            return i

        ch1 = Tasklet.new(child)(1)
        ch2 = Tasklet.new(child)(2)

        self.assertEquals(1, Tasklet.join(ch1))
        self.assertEquals(2, Tasklet.join(ch2))
Exemplo n.º 56
0
def server():
    """accepts connections on a socket, and dispatches
    new tasks for handling the incoming requests"""
    server_socket = Socket.new()
    server_socket.bind(('localhost', 1337))
    server_socket.listen()

    while True:
        client_socket = server_socket.accept()
        Tasklet.new(handler)(client_socket)