Esempio n. 1
0
 def handle_client(self, json_socket):
     global running
     global run_main
     self.connected = True
     api.spawn(self.read_client, json_socket)
     if running:
         json_socket.send(["state", "connected"])
     else:
         json_socket.send(["state", "idle"])
     starttime = time.time()
     while self.connected:
         if self.current:
             cmd = self.current.out_queue.get()
             if cmd[0] == "quit":
                 print("quit on handle client")
                 break
             else:
                 json_socket.send(cmd)
             #for cmd in self.current.queue.get():
             #    json_socket.send(cmd)
             #api.sleep(0)
         api.sleep(0)
     json_socket.close()
     if running:
         running.addCmd(["quit"])
         running = None
     sys.exit()
Esempio n. 2
0
def main():
    from optparse import OptionParser
    parser = OptionParser()
    parser.add_option("-l", "--listen", dest="host", default="0.0.0.0",
            help="the ip interface to bind")
    parser.add_option("-p", "--port", default=7902, type=int,
            help="which port to listen")
    parser.add_option("-d", "--daemon", action="store_true",
            help="run in daemon", default=False)

    (options, args) = parser.parse_args()

    cfg = {"localhost:7901":range(16),
            "localhost:7902":range(16),
            "localhost:7903":range(16)}
    store = Client(cfg, 16)

    print "server listening on %s:%s" % (options.host, options.port)
    server = api.tcp_listener((options.host, options.port))
    util.set_reuse_addr(server)

    while True:
        try:
            new_sock, address = server.accept()
        except KeyboardInterrupt:
            break
        api.spawn(handler, store, new_sock)

    print 'close listener ...'
    server.close()
Esempio n. 3
0
    def test_two_simultaneous_connections(self):
        """ This test is timing-sensitive. """
        self.pool = self.create_pool(2)
        conn = self.pool.get()
        self.set_up_test_table(conn)
        self.fill_test_table(conn)
        curs = conn.cursor()
        conn2 = self.pool.get()
        self.set_up_test_table(conn2)
        self.fill_test_table(conn2)
        curs2 = conn2.cursor()
        results = []
        LONG_QUERY = "select * from test_table"
        SHORT_QUERY = "select * from test_table where row_id <= 20"

        evt = coros.event()
        def long_running_query():
            self.assert_cursor_works(curs)
            curs.execute(LONG_QUERY)
            results.append(1)
            evt.send()
        evt2 = coros.event()
        def short_running_query():
            self.assert_cursor_works(curs2)
            curs2.execute(SHORT_QUERY)
            results.append(2)
            evt2.send()

        api.spawn(long_running_query)
        api.spawn(short_running_query)
        evt.wait()
        evt2.wait()
        results.sort()
        self.assertEqual([1, 2], results)
Esempio n. 4
0
    def start_udp_proxy(self, sim_ip, sim_port):
        """
        start a udp proxy, spawning two sockets which serve as the 
        faux region and faux client
        """

        # if we are already running a proxy for this, simply pass it's location back out
        if (sim_ip, sim_port) in self.udp_proxied_hosts:
            logger.debug("UDPProxy already exists for %s:%s at %s:%s" %
                         (sim_ip, sim_port,
                          self.udp_proxied_hosts[(sim_ip, sim_port)][0],
                          self.udp_proxied_hosts[(sim_ip, sim_port)][1]))
            return self.udp_proxied_hosts[(
                sim_ip, sim_port)][0], self.udp_proxied_hosts[(sim_ip,
                                                               sim_port)][1]

        # signal handler to capture erm signals
        if not self.signal_handler:
            self.signal_handler = signal.signal(signal.SIGINT,
                                                self.sigint_handler)

        self.viewer_facing_port_seed += 1
        self.server_facing_port_seed += 1

        udp_proxy = UDPProxy(sim_ip, sim_port, self.viewer_facing_port_seed,
                             self.server_facing_port_seed)

        # populate our trackers
        self.udp_proxied_hosts[(sim_ip, sim_port)] = (
            udp_proxy.hostname, udp_proxy.proxy_socket.getsockname()[1])
        self.udp_proxies.append(udp_proxy)

        api.spawn(udp_proxy.start_proxy)

        return udp_proxy.hostname, udp_proxy.proxy_socket.getsockname()[1]
Esempio n. 5
0
    def test_connect_ssl(self):
        def accept_once(listenfd):
            try:
                conn, addr = listenfd.accept()
                conn.write(b'hello\r\n')
                greenio.shutdown_safe(conn)
                conn.close()
            finally:
                greenio.shutdown_safe(listenfd)
                listenfd.close()

        server = api.ssl_listener(('0.0.0.0', 0),
                                  self.certificate_file,
                                  self.private_key_file)
        api.spawn(accept_once, server)

        raw_client = eventlet.connect(('127.0.0.1', server.getsockname()[1]))
        client = util.wrap_ssl(raw_client)
        fd = socket._fileobject(client, 'rb', 8192)

        assert fd.readline() == b'hello\r\n'
        try:
            self.assertEqual(b'', fd.read(10))
        except greenio.SSL.ZeroReturnError:
            # if it's a GreenSSL object it'll do this
            pass
        greenio.shutdown_safe(client)
        client.close()

        check_hub()
Esempio n. 6
0
    def test_connect_ssl(self):
        def accept_once(listenfd):
            try:
                conn, addr = listenfd.accept()
                conn.write(b'hello\r\n')
                greenio.shutdown_safe(conn)
                conn.close()
            finally:
                greenio.shutdown_safe(listenfd)
                listenfd.close()

        server = api.ssl_listener(('0.0.0.0', 0), self.certificate_file,
                                  self.private_key_file)
        api.spawn(accept_once, server)

        raw_client = eventlet.connect(('127.0.0.1', server.getsockname()[1]))
        client = util.wrap_ssl(raw_client)
        fd = socket._fileobject(client, 'rb', 8192)

        assert fd.readline() == b'hello\r\n'
        try:
            self.assertEqual(b'', fd.read(10))
        except greenio.SSL.ZeroReturnError:
            # if it's a GreenSSL object it'll do this
            pass
        greenio.shutdown_safe(client)
        client.close()

        check_hub()
Esempio n. 7
0
    def test_timeout_and_final_write(self):
        # This test verifies that a write on a socket that we've
        # stopped listening for doesn't result in an incorrect switch
        rpipe, wpipe = os.pipe()
        rfile = os.fdopen(rpipe,"r",0)
        wrap_rfile = greenio.GreenPipe(rfile)
        wfile = os.fdopen(wpipe,"w",0)
        wrap_wfile = greenio.GreenPipe(wfile)

        def sender(evt):
            api.sleep(0.02)
            wrap_wfile.write('hi')
            evt.send('sent via event')

        from eventlet import coros
        evt = coros.event()
        api.spawn(sender, evt)
        try:
            # try and get some data off of this pipe
            # but bail before any is sent
            api.exc_after(0.01, api.TimeoutError)
            _c = wrap_rfile.read(1)
            self.fail()
        except api.TimeoutError:
            pass

        result = evt.wait()
        self.assertEquals(result, 'sent via event')
Esempio n. 8
0
    def fan(self, block, input_list):
        queue = coros.queue(0)
        results = []
        exceptional_results = 0
        for index, input_item in enumerate(input_list):
            pool_item = self.get()

            ## Fan out
            api.spawn(
                self._invoke, block, pool_item, input_item, index, queue)

        ## Fan back in
        for i in range(len(input_list)):
            ## Wait for all guys to send to the queue
            index, value = queue.wait()
            if isinstance(value, Exception):
                exceptional_results += 1
            results.append((index, value))

        results.sort()
        results = [value for index, value in results]

        if exceptional_results:
            if exceptional_results == len(results):
                raise AllFailed(results)
            raise SomeFailed(results)
        return results
Esempio n. 9
0
 def read_client(self, json_socket):
     global running
     while True:
         api.sleep(0)
         data = json_socket.recv()
         if not data:
             # client disconnected, bail out
             if self.current:
                 self.current.out_queue.put(["quit"])
             break
         if data[0] == 'connect':
             if not running:
                 # initial connect command
                 running = GreenletsThread(*data[1:])
                 self.current = running
                 api.spawn(running.run)
                 for cmd in self.deferred_cmds:
                     running.addCmd(cmd)
                 self.deferred_cmds = []
                 json_socket.send(["hihi"])
             else:
                 running.addCmd(["bootstrap"])
         elif self.current:
             # forward command
             self.current.addCmd(data)
         else:
             if data[0] in ["throttle"]:
                 self.deferred_cmds.append(data)
     print("exit read client")
     # exit
     self.connected = False
Esempio n. 10
0
    def test_timeout_and_final_write(self):
        # This test verifies that a write on a socket that we've
        # stopped listening for doesn't result in an incorrect switch
        rpipe, wpipe = os.pipe()
        rfile = os.fdopen(rpipe, "r", 0)
        wrap_rfile = greenio.GreenPipe(rfile)
        wfile = os.fdopen(wpipe, "w", 0)
        wrap_wfile = greenio.GreenPipe(wfile)

        def sender(evt):
            api.sleep(0.02)
            wrap_wfile.write('hi')
            evt.send('sent via event')

        from eventlet import coros
        evt = coros.event()
        api.spawn(sender, evt)
        try:
            # try and get some data off of this pipe
            # but bail before any is sent
            api.exc_after(0.01, api.TimeoutError)
            _c = wrap_rfile.read(1)
            self.fail()
        except api.TimeoutError:
            pass

        result = evt.wait()
        self.assertEquals(result, 'sent via event')
Esempio n. 11
0
File: simrt.py Progetto: b2rex/b2rex
 def handle_client(self, json_socket):
     global running
     global run_main
     self.connected = True
     api.spawn(self.read_client, json_socket)
     if running:
         json_socket.send(["state", "connected"])
     else:
         json_socket.send(["state", "idle"])
     starttime = time.time()
     while self.connected:
         if self.current:
             cmd = self.current.out_queue.get()
             if cmd[0] == "quit":
                 print("quit on handle client")
                 break;
             else:
                 json_socket.send(cmd)
             #for cmd in self.current.queue.get():
                 #    json_socket.send(cmd)
                 #api.sleep(0)
         api.sleep(0)
     json_socket.close()
     if running:
         running.addCmd(["quit"])
         running = None
     sys.exit()
Esempio n. 12
0
 def test_waiting_for_event(self):
     evt = coros.event()
     value = 'some stuff'
     def send_to_event():
         evt.send(value)
     api.spawn(send_to_event)
     self.assertEqual(evt.wait(), value)
Esempio n. 13
0
    def test_pool_smash(self):
        # The premise is that a coroutine in a Pool tries to get a token out
        # of a token pool but times out before getting the token.  We verify
        # that neither pool is adversely affected by this situation.
        from eventlet import pools
        pool = self.klass(min_size=1, max_size=1)
        tp = pools.TokenPool(max_size=1)
        token = tp.get()  # empty pool
        def do_receive(tp):
            api.exc_after(0, RuntimeError())
            try:
                t = tp.get()
                self.fail("Shouldn't have recieved anything from the pool")
            except RuntimeError:
                return 'timed out'

        # the execute makes the token pool expect that coroutine, but then
        # immediately cuts bait
        e1 = pool.execute(do_receive, tp)
        self.assertEquals(e1.wait(), 'timed out')

        # the pool can get some random item back
        def send_wakeup(tp):
            tp.put('wakeup')
        api.spawn(send_wakeup, tp)

        # now we ask the pool to run something else, which should not
        # be affected by the previous send at all
        def resume():
            return 'resumed'
        e2 = pool.execute(resume)
        self.assertEquals(e2.wait(), 'resumed')

        # we should be able to get out the thing we put in there, too
        self.assertEquals(tp.get(), 'wakeup')
    def test_multiple_waiters(self):
        # tests that multiple waiters get their results back
        q = coros.queue()

        def waiter(q, evt):
            evt.send(q.wait())

        sendings = ['1', '2', '3', '4']
        evts = [coros.event() for x in sendings]
        for i, x in enumerate(sendings):
            api.spawn(waiter, q, evts[i])

        api.sleep(0.01) # get 'em all waiting

        results = set()
        def collect_pending_results():
            for i, e in enumerate(evts):
                timer = api.exc_after(0.001, api.TimeoutError)
                try:
                    x = e.wait()
                    results.add(x)
                    timer.cancel()
                except api.TimeoutError:
                    pass  # no pending result at that event
            return len(results)
        q.send(sendings[0])
        self.assertEquals(collect_pending_results(), 1)
        q.send(sendings[1])
        self.assertEquals(collect_pending_results(), 2)
        q.send(sendings[2])
        q.send(sendings[3])
        self.assertEquals(collect_pending_results(), 4)
Esempio n. 15
0
    def _enable_child_region(self, region_params):
        """ enables a child region. eligible simulators are sent in EnableSimulator over the event queue, and routed through the packet handler """

        # if this is the sim we are already connected to, skip it
        if self.region.sim_ip == region_params['IP'] and self.region.sim_port == region_params['Port']:
            #self.region.sendCompleteAgentMovement()
            logger.debug("Not enabling a region we are already connected to: %s" % (str(region_params['IP']) + ":" + str(region_params['Port'])))
            return

        child_region = Region(circuit_code = self.circuit_code, 
                            sim_ip = region_params['IP'], 
                            sim_port = region_params['Port'], 
                            handle = region_params['Handle'], 
                            agent = self, 
                            settings = self.settings, 
                            events_handler = self.events_handler)

        self.child_regions.append(child_region)

        logger.info("Enabling a child region with ip:port of %s" % (str(region_params['IP']) + ":" + str(region_params['Port'])))

        if self.settings.LOG_COROUTINE_SPAWNS: 
            logger.info("Spawning a coroutine for connecting to a neighboring region.")

        eventlet.spawn(child_region.connect_child)
Esempio n. 16
0
    def start_caps_proxy(self, seed_cap_url):
        """ start a caps proxy, serving the seed_cap first then all subsequent caps """

        # if we are already running a proxy for this, simply pass it's location back out
        if (seed_cap_url) in self.caps_proxied_hosts:
            logger.debug("CapabilitiesProxy already exists for %s at %s" %
                         (seed_cap_url, self.proxied_hosts[seed_cap_url]))
            return self.udp_proxied_hosts[(
                sim_ip, sim_port)][0], self.udp_proxied_hosts[(sim_ip,
                                                               sim_port)][1]

        # signal handler to capture erm signals
        if not self.signal_handler:
            self.signal_handler = signal.signal(signal.SIGINT,
                                                self.sigint_handler)

        self.caps_proxy_port_seed += 1

        caps_proxy = CapabilitiesProxy(seed_cap_url, '127.0.0.1',
                                       self.caps_proxy_port_seed, self)

        # populate our trackers
        self.caps_proxied_hosts[seed_cap_url] = "%s:%s" % (
            'http://127.0.0.1', self.caps_proxy_port_seed)
        self.caps_proxies.append(caps_proxy)

        api.spawn(caps_proxy.start_caps_proxy_service)

        return '127.0.0.1', self.caps_proxy_port_seed, caps_proxy.proxy_map[
            seed_cap_url]
Esempio n. 17
0
    def test_reset(self):
        evt = coros.event()

        # calling reset before send should throw
        self.assertRaises(AssertionError, evt.reset)

        value = 'some stuff'

        def send_to_event():
            evt.send(value)

        api.spawn(send_to_event)
        self.assertEqual(evt.wait(), value)

        # now try it again, and we should get the same exact value,
        # and we shouldn't be allowed to resend without resetting
        value2 = 'second stuff'
        self.assertRaises(AssertionError, evt.send, value2)
        self.assertEqual(evt.wait(), value)

        # reset and everything should be happy
        evt.reset()

        def send_to_event2():
            evt.send(value2)

        api.spawn(send_to_event2)
        self.assertEqual(evt.wait(), value2)
Esempio n. 18
0
File: simrt.py Progetto: b2rex/b2rex
 def read_client(self, json_socket):
     global running
     while True:
         api.sleep(0)
         data = json_socket.recv()
         if not data:
             # client disconnected, bail out
             if self.current:
                 self.current.out_queue.put(["quit"])
             break
         if data[0] == 'connect':
             if not running:
                 # initial connect command
                 running = GreenletsThread(*data[1:])
                 self.current = running
                 api.spawn(running.run)
                 for cmd in self.deferred_cmds:
                     running.addCmd(cmd)
                 self.deferred_cmds = []
                 json_socket.send(["hihi"])
             else:
                 running.addCmd(["bootstrap"])
         elif self.current:
             # forward command
             self.current.addCmd(data)
         else:
             if data[0] in ["throttle"]:
                 self.deferred_cmds.append(data)
     print("exit read client")
     # exit
     self.connected = False
    def test_senders_that_die(self):
        q = coros.queue()

        def do_send(q):
            q.send('sent')

        api.spawn(do_send, q)
        self.assertEquals(q.wait(), 'sent')
Esempio n. 20
0
def setup():
    global _threads
    for i in range(0,_nthreads):
        _threads[i] = threading.Thread(target=tworker)
        _threads[i].setDaemon(True)
        _threads[i].start()

    api.spawn(tpool_trampoline)
Esempio n. 21
0
    def test_spawn_is_not_cancelled(self):

        def func():
            spawn(self.lst.pop)
            # exiting immediatelly, but self.lst.pop must be called
        spawn(func)
        sleep(0.1)
        assert self.lst == [], self.lst
Esempio n. 22
0
    def test_spawn_is_not_cancelled(self):
        def func():
            spawn(self.lst.pop)
            # exiting immediatelly, but self.lst.pop must be called

        spawn(func)
        sleep(0.1)
        assert self.lst == [], self.lst
Esempio n. 23
0
    def test_timer_cancelled_upon_greenlet_exit(self):
        def func():
            call_after(0.1, self.lst.pop)

        spawn(func)
        assert self.lst == [1], self.lst
        sleep(0.2)
        assert self.lst == [1], self.lst
Esempio n. 24
0
def login():
    """ login an to a login endpoint """ 

    parser = OptionParser(usage="usage: %prog [options] firstname lastname")

    logger = logging.getLogger("client.example")

    parser.add_option("-l", "--loginuri", dest="loginuri", default="https://login.aditi.lindenlab.com/cgi-bin/login.cgi",
                      help="specified the target loginuri")
    parser.add_option("-r", "--region", dest="region", default=None,
                      help="specifies the region (regionname/x/y/z) to connect to")
    parser.add_option("-q", "--quiet", dest="verbose", default=True, action="store_false",
                    help="enable verbose mode")
    parser.add_option("-p", "--password", dest="password", default=None,
                      help="specifies password instead of being prompted for one")


    (options, args) = parser.parse_args()

    if len(args) != 2:
        parser.error("Expected arguments: firstname lastname")

    if options.verbose:
        console = logging.StreamHandler()
        console.setLevel(logging.DEBUG) # seems to be a no op, set it for the logger
        formatter = logging.Formatter('%(asctime)-30s%(name)-30s: %(levelname)-8s %(message)s')
        console.setFormatter(formatter)
        logging.getLogger('').addHandler(console)

        # setting the level for the handler above seems to be a no-op
        # it needs to be set for the logger, here the root logger
        # otherwise it is NOTSET(=0) which means to log nothing.
        logging.getLogger('').setLevel(logging.DEBUG)
    else:
        print "Attention: This script will print nothing if you use -q. So it might be boring to use it like that ;-)"

    # example from a pure agent perspective

    #grab a password!
    if options.password:
        password = options.password
    else:
        password = getpass.getpass()

    # let's disable inventory handling for this example
    settings = Settings()
    settings.ENABLE_INVENTORY_MANAGEMENT = False
    settings.ENABLE_EQ_LOGGING = False
    settings.ENABLE_CAPS_LOGGING = False

    #First, initialize the agent
    client = Agent(settings = settings)

    # Now let's log it in
    try:
        api.spawn(client.login, options.loginuri, args[0], args[1], password, start_location = options.region, connect_region = True)
    except LoginError, error:
        sys.exit()
Esempio n. 25
0
def main():

    parser = optparse.OptionParser(usage='%prog --port=PORT')
    parser.add_option('--port',
                      default='8080',
                      dest='login_port',
                      type='int',
                      help='Port to serve on (default 8080)')
    parser.add_option(
        '--loginuri',
        default='https://login.aditi.lindenlab.com/cgi-bin/login.cgi',
        dest='loginuri',
        help='Specifies the target loginuri to connect proxy to')
    parser.add_option(
        '-v',
        '--verbose',
        default=False,
        dest='verbose',
        action="store_true",
        help='enables logging, sets logging level to info, logs names of all \
            packets')
    parser.add_option(
        '-V',
        '--verboseverbose',
        default=False,
        dest='verboseverbose',
        action="store_true",
        help='enables logging, sets logging level to debug, logs contents \
            of all packets')

    options, args = parser.parse_args()

    # init logging
    if options.verbose or options.verboseverbose:
        console = logging.StreamHandler()
        console.setLevel(
            logging.DEBUG)  # seems to be a no op, set it for the logger
        formatter = logging.Formatter(
            '%(asctime)-30s%(name)-30s: %(levelname)-8s %(message)s')
        console.setFormatter(formatter)
        logging.getLogger('').addHandler(console)
        if options.verbose:
            logging.getLogger('').setLevel(logging.INFO)
        elif options.verboseverbose:
            logging.getLogger('').setLevel(logging.DEBUG)
        else:
            logging.getLogger('').setLevel(logging.WARNING)

    # init the viewer proxy
    viewer_proxy = ViewerProxyApp(options.loginuri, options.login_port)

    # spawn a coroutine which initially handles the login rpxy, then lives on
    api.spawn(viewer_proxy.proxy_login)

    # keep running until we intercept a signal
    while viewer_proxy._is_running:
        api.sleep(5)
Esempio n. 26
0
    def test_waiting_for_event(self):
        evt = coros.event()
        value = 'some stuff'

        def send_to_event():
            evt.send(value)

        api.spawn(send_to_event)
        self.assertEqual(evt.wait(), value)
Esempio n. 27
0
 def login(self, event=None):
     """ Logs in a pyogp agent """
     start_location = self.location.get()
     if start_location == "":
         start_location = None
     api.spawn(self.parent.login_agent, self.first_name.get(),
               self.last_name.get(), self.password.get(), start_location)
     self.parent.init_chat()
     self.frame.pack_forget()
Esempio n. 28
0
    def test_timer_cancelled_upon_greenlet_exit(self):
        
        def func():
            call_after(0.1, self.lst.pop)

        spawn(func)
        assert self.lst == [1], self.lst
        sleep(0.2)
        assert self.lst == [1], self.lst
Esempio n. 29
0
def init():
	cur = login_db.execute("select * from clients")
	for row in cur:
		if row[3] == "online":
			client = "/comet/client/" + row[1] 
			_client_queues[client] = ClientMessageQueue(row[0])
			_client_queues[client].last = row[2] 

	api.spawn(_check_timeout)
Esempio n. 30
0
    def test_timer_fired(self):
        def func():
            call_after(0.1, self.lst.pop)
            sleep(0.2)

        spawn(func)
        assert self.lst == [1], self.lst
        sleep(0.3)
        assert self.lst == [], self.lst
Esempio n. 31
0
    def login(self, key, loginuri, start_location=None):
        """ spawns a new agent via an eventlet coroutine """

        if self.settings.LOG_COROUTINE_SPAWNS: 
            logger.info("Spawning a coroutine for agent login for %s." % (self.agents[key].Name()))

        try:
            eventlet.spawn(self.agents[key].login, loginuri = loginuri, start_location = start_location)
        except LoginError, error:
            logger.error("Skipping agent with failed login: %s due to %s." % (self.agents[key].Name(), error))
Esempio n. 32
0
    def test_timer_fired(self):
        
        def func():
            call_after(0.1, self.lst.pop)
            sleep(0.2)

        spawn(func)
        assert self.lst == [1], self.lst
        sleep(0.3)
        assert self.lst == [], self.lst
Esempio n. 33
0
File: simrt.py Progetto: b2rex/b2rex
def main():
    """
    In stand alone mode we will open a port and accept commands.
    """
    server = eventlet.listen(('0.0.0.0', 11112))
    #pool = eventlet.GreenPool(1000)
    while run_main:
         new_sock, address = server.accept()
         client_handler = ClientHandler()
         api.spawn(client_handler.handle_client, JsonSocket(new_sock))
         api.sleep(0)
Esempio n. 34
0
def main():
    """
    In stand alone mode we will open a port and accept commands.
    """
    server = eventlet.listen(('0.0.0.0', 11112))
    #pool = eventlet.GreenPool(1000)
    while run_main:
        new_sock, address = server.accept()
        client_handler = ClientHandler()
        api.spawn(client_handler.handle_client, JsonSocket(new_sock))
        api.sleep(0)
    def test_send_last(self):
        q = coros.queue()
        def waiter(q):
            timer = api.exc_after(0.1, api.TimeoutError)
            self.assertEquals(q.wait(), 'hi2')
            timer.cancel()

        api.spawn(waiter, q)
        api.sleep(0)
        api.sleep(0)
        q.send('hi2')
Esempio n. 36
0
    def test_send(self):
        event1 = Event()
        event2 = Event()

        spawn(event1.send, 'hello event1')
        eventlet.Timeout(0, ValueError('interrupted'))
        try:
            result = event1.wait()
        except ValueError:
            X = object()
            result = with_timeout(DELAY, event2.wait, timeout_value=X)
            assert result is X, 'Nobody sent anything to event2 yet it received %r' % (result, )
Esempio n. 37
0
    def test_send(self):
        event1 = Event()
        event2 = Event()

        spawn(event1.send, 'hello event1')
        eventlet.Timeout(0, ValueError('interrupted'))
        try:
            result = event1.wait()
        except ValueError:
            X = object()
            result = with_timeout(DELAY, event2.wait, timeout_value=X)
            assert result is X, 'Nobody sent anything to event2 yet it received %r' % (result, )
    def test_start_and_stop(self):

        self.eq.cap = Capability('EventQueueGet', 'http://127.0.0.1')
        self.assertFalse(self.eq.stopped)
        eventlet.spawn(self.eq.start)
        eventlet.sleep(1)
        #self.eq.stop() #stop is broken atm
        self.eq.stopped = True
        eventlet.sleep(.1)
        self.assertTrue(self.eq.stopped)
        eventlet.sleep(1)
        self.assertFalse(self.eq._running)
Esempio n. 39
0
def main():
    try:
        server=api.tcp_listener(('0.0.0.0',3000))
        print 'Server started!'
        while True:
            conn,addr=server.accept()
            #print 'client %s connected!'%repr(addr)
            writer=conn.makefile('w')
            api.spawn(httpd,writer,conn.makefile('r'))
    except KeyboardInterrupt:
        pass
    return
Esempio n. 40
0
    def test_013_empty_return(self):
        from eventlet import httpc
        def wsgi_app(environ, start_response):
            start_response("200 OK", [])
            return [""]

        certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt')
        private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key')
        sock = api.ssl_listener(('', 4202), certificate_file, private_key_file)
        api.spawn(wsgi.server, sock, wsgi_app)

        res = httpc.get("https://localhost:4202/foo")
        self.assertEquals(res, '')
Esempio n. 41
0
    def login(self, loginuri, firstname=None, lastname=None, password=None, login_params = None, start_location=None, handler=None, connect_region = True):
        """ login to a login endpoint using the Login() class """

        if (re.search('auth.cgi$', loginuri)):

            self.grid_type = 'OGP'

        elif (re.search('login.cgi$', loginuri)):

            self.grid_type = 'Legacy'

        else:
            logger.warning('Unable to identify the loginuri schema. Stopping')
            sys.exit(-1)

        if firstname != None:
            self.firstname = firstname
        if lastname != None:
            self.lastname = lastname
        if password != None:
            self.password = password

        # handle either login params passed in, or, account info
        if login_params == None:

            if (self.firstname == '') or (self.lastname == '') or (self.password == ''):

                raise LoginError('Unable to login an unknown agent.')

            else:

                self._login_params = self._get_login_params(self.firstname, self.lastname, self.password)

        else:

            self._login_params = login_params

        # login and parse the response
        login = Login(settings = self.settings)

        self.login_response = login.login(loginuri, self._login_params, start_location, handler = handler)
        self._parse_login_response()

        # ToDo: what to do with self.login_response['look_at']?

        if self.settings.MULTIPLE_SIM_CONNECTIONS:
            eventlet.spawn(self._monitor_for_new_regions)

        if connect_region:
            self._enable_current_region()
            eventlet.spawn(self.agent_updater)
 def test_bounded(self):
     # this was originally semaphore's doctest
     sem = coros.BoundedSemaphore(2, limit=3)
     self.assertEqual(sem.acquire(), True)
     self.assertEqual(sem.acquire(), True)
     api.spawn(sem.release)
     self.assertEqual(sem.acquire(), True)
     self.assertEqual(-3, sem.balance)
     sem.release()
     sem.release()
     sem.release()
     api.spawn(sem.acquire)
     sem.release()
     self.assertEqual(3, sem.balance)
    def test_waiting(self):
        def do_wait(q, evt):
            result = q.wait()
            evt.send(result)

        q = coros.queue()
        e1 = coros.event()
        api.spawn(do_wait, q, e1)
        api.sleep(0)
        self.assertEquals(1, waiting(q))
        q.send('hi')
        api.sleep(0)
        self.assertEquals(0, waiting(q))
        self.assertEquals('hi', e1.wait())
        self.assertEquals(0, waiting(q))
Esempio n. 44
0
    def test_012_ssl_server(self):
        from eventlet import httpc
        def wsgi_app(environ, start_response):
            start_response('200 OK', {})
            return [environ['wsgi.input'].read()]

        certificate_file = os.path.join(os.path.dirname(__file__), 'test_server.crt')
        private_key_file = os.path.join(os.path.dirname(__file__), 'test_server.key')

        sock = api.ssl_listener(('', 4201), certificate_file, private_key_file)

        api.spawn(wsgi.server, sock, wsgi_app)

        result = httpc.post("https://localhost:4201/foo", "abc")
        self.assertEquals(result, 'abc')
Esempio n. 45
0
    def test_timeout_cancel(self):
        server = eventlet.listen(('0.0.0.0', 0))
        bound_port = server.getsockname()[1]

        done = [False]

        def client_closer(sock):
            while True:
                (conn, addr) = sock.accept()
                conn.close()

        def go():
            desc = eventlet.connect(('127.0.0.1', bound_port))
            try:
                api.trampoline(desc, read=True, timeout=0.1)
            except api.TimeoutError:
                assert False, "Timed out"

            server.close()
            desc.close()
            done[0] = True

        greenthread.spawn_after_local(0, go)

        server_coro = api.spawn(client_closer, server)
        while not done[0]:
            api.sleep(0)
        api.kill(server_coro)

        check_hub()
Esempio n. 46
0
    def test_killing_dormant(self):
        DELAY = 0.1
        state = []

        def test():
            try:
                state.append('start')
                api.sleep(DELAY)
            except:
                state.append('except')
                # catching GreenletExit
                pass
            # when switching to hub, hub makes itself the parent of this greenlet,
            # thus after the function's done, the control will go to the parent
            api.sleep(0)
            state.append('finished')

        g = api.spawn(test)
        api.sleep(DELAY / 2)
        self.assertEqual(state, ['start'])
        api.kill(g)
        # will not get there, unless switching is explicitly scheduled by kill
        self.assertEqual(state, ['start', 'except'])
        api.sleep(DELAY)
        self.assertEqual(state, ['start', 'except', 'finished'])
Esempio n. 47
0
    def test_blocks_on_pool(self):
        waiter = coros.queue(0)
        def greedy():
            self.pool.get()
            self.pool.get()
            self.pool.get()
            self.pool.get()
            # No one should be waiting yet.
            self.assertEquals(self.pool.waiting(), 0)
            # The call to the next get will unschedule this routine.
            self.pool.get()
            # So this send should never be called.
            waiter.send('Failed!')

        killable = api.spawn(greedy)

        # no one should be waiting yet.
        self.assertEquals(self.pool.waiting(), 0)

        ## Wait for greedy
        api.sleep(0)

        ## Greedy should be blocking on the last get
        self.assertEquals(self.pool.waiting(), 1)

        ## Send will never be called, so balance should be 0.
        self.assertFalse(waiter.ready())

        api.kill(killable)
Esempio n. 48
0
    def test_killing_dormant(self):
        DELAY = 0.1
        state = []

        def test():
            try:
                state.append('start')
                api.sleep(DELAY)
            except:
                state.append('except')
                # catching GreenletExit
                pass
            # when switching to hub, hub makes itself the parent of this greenlet,
            # thus after the function's done, the control will go to the parent
            api.sleep(0)
            state.append('finished')

        g = api.spawn(test)
        api.sleep(DELAY / 2)
        self.assertEqual(state, ['start'])
        api.kill(g)
        # will not get there, unless switching is explicitly scheduled by kill
        self.assertEqual(state, ['start', 'except'])
        api.sleep(DELAY)
        self.assertEqual(state, ['start', 'except', 'finished'])
Esempio n. 49
0
 def setUp(self):
     self.logfile = StringIO()
     self.victim = api.spawn(wsgi.server,
                             api.tcp_listener(('0.0.0.0', 31337)),
                             self.site_class(),
                             log=self.logfile,
                             max_size=128)
Esempio n. 50
0
 def setUp(self):
     self.logfile = StringIO()
     self.victim = api.spawn(wsgi.server,
                             api.tcp_listener(('0.0.0.0', 31337)),
                             self.site_class(),
                             log=self.logfile,
                             max_size=128)
Esempio n. 51
0
    def test_close_with_makefile(self):
        def accept_close_early(listener):
            # verify that the makefile and the socket are truly independent
            # by closing the socket prior to using the made file
            try:
                conn, addr = listener.accept()
                fd = conn.makeGreenFile()
                conn.close()
                fd.write('hello\n')
                fd.close()
                self.assertRaises(socket.error, fd.write, 'a')
                self.assertRaises(socket.error, conn.send, 'b')
            finally:
                listener.close()

        def accept_close_late(listener):
            # verify that the makefile and the socket are truly independent
            # by closing the made file and then sending a character
            try:
                conn, addr = listener.accept()
                fd = conn.makeGreenFile()
                fd.write('hello')
                fd.close()
                conn.send('\n')
                conn.close()
                self.assertRaises(socket.error, fd.write, 'a')
                self.assertRaises(socket.error, conn.send, 'b')
            finally:
                listener.close()
                
        def did_it_work(server):
            client = api.connect_tcp(('127.0.0.1', server.getsockname()[1]))
            fd = client.makeGreenFile()
            client.close()
            assert fd.readline() == 'hello\n'    
            assert fd.read() == ''
            fd.close()
            
        server = api.tcp_listener(('0.0.0.0', 0))
        killer = api.spawn(accept_close_early, server)
        did_it_work(server)
        api.kill(killer)
        
        server = api.tcp_listener(('0.0.0.0', 0))
        killer = api.spawn(accept_close_late, server)
        did_it_work(server)
        api.kill(killer)
Esempio n. 52
0
    def test_send_exc(self):
        log = []
        e = Event()

        def waiter():
            try:
                result = e.wait()
                log.append(('received', result))
            except Exception as ex:
                log.append(('catched', ex))
        spawn(waiter)
        sleep(0) # let waiter to block on e.wait()
        obj = Exception()
        e.send(exc=obj)
        sleep(0)
        sleep(0)
        assert log == [('catched', obj)], log