Python Waldo.tcp_accept方法代码示例

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def spawn_acceptor():
    '''
    Starts the TCP accept thread and spins as connections are brought up.
    '''
    Waldo.tcp_accept(InnerPong, HOST, PORT_INNER, throw_func)
    while True:
        pass

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_chatter_a():
  # runs in accept mode
  global quit
  Waldo.tcp_accept(ChatterA, HOSTNAME, PORT, display_msg,
      connected_callback=listen_for_user_input)
  while True:
    if quit:
      break
    time.sleep(SLEEP_TIME)

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_server():
  '''
  Runs the multi-connection chat server.
  '''
  global server
  server = Waldo.no_partner_create(Server, display_msg)
  print server
  Waldo.tcp_accept(ClientHandler, HOSTNAME, PORT, server, display_msg)
  while True:
    time.sleep(SLEEP_TIME)

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    '''
    Tests Waldo's ability to detect an application exception on the partner
    endpoint mid-sequence and propagate that exception back to the root endpoint
    for handling.
    
    Returns true if the exception is caught and handled, and false otherwise.
    '''
    Waldo.tcp_accept(Pong,HOST,PORT)
    connector = Waldo.tcp_connect(Ping,HOST,PORT)
    return connector.testPropagateException()

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    Waldo.tcp_accept(Pt2, HOST, PORT, connected_callback=pt2_connected)
    pt1 = Waldo.tcp_connect(Pt1, HOST, PORT,createList);

    pt2 = pt2_wait_queue.get()
    returned_list = pt1.start_seq()
    time.sleep(1)
    list_to_return.append('wo')
    if returned_list != list_to_return:
        return False

    return True

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    '''
    Tests Waldo's ability to propagate an exception back through a sequence within
    an endpoint call.
    
    Returns true if the exception is caught and handled, and false otherwise.
    '''
    Waldo.tcp_accept(Pong,HOST,PORT)
    connector = Waldo.tcp_connect(Ping,HOST,PORT)
    catcher = Waldo.no_partner_create(Catcher)
    catcher.addEndpoint(connector)
    return catcher.testCatchApplicationExceptionFromSequence()

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def start_coordinator():
    math_endpoint = Waldo.math_endpoint_lib()
    
    coordinator_master = Waldo.no_partner_create(
        CoordinatorMaster, util_funcs.between,
        util_funcs.rand_uuid,math_endpoint,
        conf.MAX_NUMBER_FINGER_TABLE_ENTRIES)

    # begin listening for connections to coordinator master
    Waldo.tcp_accept(
        Coordinator, conf.COORDINATOR_HOST_PORT_PAIR.host,
        conf.COORDINATOR_HOST_PORT_PAIR.port, coordinator_master)
    
    return coordinator_master

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    '''
    Tests Waldo's capability of propagating an exception back through nested
    sequences. Here we have two pairs of endpoints: (a,b), (c,d). Endpoint a 
    begins a sequence with b, which makes and endpoint call to c, which 
    initiates a sequence with d, which raises an exception.

    Returns true if the exception is propagated back to the root of the
    event and handled and false otherwise.
    '''
    Waldo.tcp_accept(InnerPong, HOST, PORT_INNER, throw_func)
    inner_ping = Waldo.tcp_connect(InnerPing, HOST, PORT_INNER)
    Waldo.tcp_accept(OuterPong, HOST, PORT_OUTER, inner_ping)
    outer_ping = Waldo.tcp_connect(OuterPing, HOST, PORT_OUTER)
    return outer_ping.testNestedSequencePropagation()

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    accept_stoppable = Waldo.tcp_accept(
        SideA, SIDEA_HOST, SIDEA_PORT,
        connected_callback=sidea_connected)
    
    sideb = Waldo.tcp_connect(
        SideB,SIDEA_HOST,SIDEA_PORT)

    sidea = sidea_wait_queue.get()

    sidea.do_nothing()
    sideb.do_nothing()

    sidea.stop()
    time.sleep(1)

    # ensure that stop fires on single host.
    try:
        sidea.do_nothing()
        return False
    except Waldo.StoppedException as inst:
        pass

    # ensure that the other side also sees the stop.
    try:
        sideb.do_nothing()
        return False
    except Waldo.StoppedException as inst:
        pass

    return True

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    accept_stoppable = Waldo.tcp_accept(
        SideA, SIDEA_HOST, SIDEA_PORT,
        connected_callback=sidea_connected)
    
    sideb = Waldo.tcp_connect(
        SideB,SIDEA_HOST,SIDEA_PORT)

    sidea = sidea_wait_queue.get()

    sidea.add_stop_listener(sidea_stop_listener)
    sideb.add_stop_listener(sideb_stop_listener_1)
    sideb.add_stop_listener(sideb_stop_listener_2)
    listener_id = sideb.add_stop_listener(sideb_stop_listener_2)
    sideb.remove_stop_listener(listener_id)
    sideb.remove_stop_listener(listener_id)
    
    sidea.do_nothing()
    sideb.do_nothing()
    sidea.stop()
    time.sleep(1)

    if sidea_stop_counter != 1:
        return False
    
    if sideb_stop_counter != 3:
        return False

    return True

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def add_single_dht_node(node_host_port_pair):

    # first: connect to discovery service
    requester = Waldo.tcp_connect(
        Requester,
        conf.COORDINATOR_HOST_PORT_PAIR.host,
        conf.COORDINATOR_HOST_PORT_PAIR.port,
        # the host and port that our new dht node will listen on for
        # connections to other dht nodes.
        node_host_port_pair.host,
        node_host_port_pair.port)

    # request request addresses of other nodes to contact from
    # discovery service, plus register self with discovery service.
    uuid, finger_table, next, prev = requester.register()
    dht_node = Waldo.no_partner_create(
        Node,uuid,util_funcs.distance,util_funcs.hashed_uuid,
        util_funcs.between, util_funcs.debug_print)
    
    # listen for connections to my node
    def on_connected(sidea_endpoint):
        sidea_endpoint.add_connection_to_node()

    Waldo.tcp_accept(
        NodeSideA, node_host_port_pair.host,
        node_host_port_pair.port, dht_node,
        node_host_port_pair.host,
        node_host_port_pair.port,
        connected_callback = on_connected)
    
    # connect to other nodes in my finger table
    for uuid in finger_table.keys():
        # table_entry has form:
        #   host: <text>
        #   port: <number>
        #   valid: <bool>
        #   uuid: <text>
        table_entry = finger_table[uuid]
        host_to_connect_to = table_entry['host']
        port_to_connect_to = table_entry['port']
        
        connection_to_finger_table_node = Waldo.tcp_connect(
            NodeSideB, host_to_connect_to, port_to_connect_to,
            dht_node,node_host_port_pair.host, node_host_port_pair.port)
    
    return dht_node

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    '''
    Tests Waldo's ability to propagate an ApplicationException back through an
    endpoint call on the remote partner in a sequence. The exception should be
    passed back to the root endpoint which initiates the sequence.
    
    Returns true if the exception is caught and handled, and false otherwise.
    '''
    thrower = Waldo.no_partner_create(Pong,None)
    catcher_partner = Waldo.tcp_accept(Pong,HOST,PORT,thrower)
    catcher = Waldo.tcp_connect(Ping,HOST,PORT)
    return catcher.testExceptionPropagation()

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_anagram_server():
    anagram_server = Waldo.no_partner_create(AnagramServer)
    Waldo.tcp_accept(PlayerHelper, HOSTNAME, ANAGRAM_PORT, anagram_server)
    load_solutions()
    while True:
        print 'Waiting for players....'
        while anagram_server.get_player_count() <= 0:
            time.sleep(0.1)
        print 'Player entered.  Game will begin in 10 seconds.'
        set_solutions(anagram_server)
        anagram_server.broadcastWaitingMessage('Game will begin in %d seconds. Type "/ready" to join.\n' %ANAGRAM_WAITTIME)
        for i in range(ANAGRAM_WAITTIME):
            if (i == ANAGRAM_WAITTIME/2):
                anagram_server.broadcastMessage('Game will begin in %d seconds\n' %i)
            time.sleep(1)
        print 'Game has begun!'
        anagram_server.start_game()
        time.sleep(20)#Change to GAMETIME after testing
        anagram_server.end_game()
        time.sleep(ANAGRAM_WAITTIME/2)
        anagram_server.restart_server()

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    '''
    Tests Waldo's capability of propagating a network exception back through
    a sequence. Here we have two pairs of endpoints: (a,b), (c,d). Endpoint a 
    begins a sequence with b, which makes and endpoint call to c, which 
    initiates a sequence with d. Endpoint d is in a separate process which is
    manually terminated mid-sequence, thus a network exception should be
    detected by c and propagated back to a.

    Returns true if the exception is propagated back to the root of the
    event and handled and false otherwise.
    '''
    global acceptor_proc
    Waldo.set_default_heartbeat_period(1)
    Waldo.set_default_partner_timeout(2)
    acceptor_proc.start()
    time.sleep(SLEEP_TIME) # make sure process is ready for tcp_connect
    inner_ping = Waldo.tcp_connect(InnerPing, HOST, PORT_INNER)
    Waldo.tcp_accept(OuterPong, HOST, PORT_OUTER, inner_ping)
    outer_ping = Waldo.tcp_connect(OuterPing, HOST, PORT_OUTER)
    result = outer_ping.testNestedSequencePropagation()
    acceptor_proc.terminate()
    return result

# 需要导入模块: from waldo.lib import Waldo [as 别名]
# 或者: from waldo.lib.Waldo import tcp_accept [as 别名]
def run_test():
    original_sidea_num = 13
    original_sideb_num = 135.1
    
    accept_stoppable = Waldo.tcp_accept(
        SideA, SIDEA_HOST, SIDEA_PORT,original_sidea_num,
        connected_callback=sidea_connected)
    
    sideb = Waldo.tcp_connect(
        SideB,SIDEA_HOST,SIDEA_PORT,original_sideb_num)

    sidea = sidea_wait_queue.get()

    # check if each  initialized correctly
    if sidea.get_other_val() != original_sideb_num:
        print '\nErr: symmetric did not initialize correctly'
        return False
    if sideb.get_other_val() != original_sidea_num:
        print '\nErr: symmetric did not initialize correctly'
        return False
    
    
    sidea_num = 39
    sideb_num = 41
    # write endpoint number to each side
    sidea.set_other_val(sideb_num)
    sideb.set_other_val(sidea_num)

    if sidea.get_other_val() != sideb_num:
        print '\nErr: symmetric did not set other side correctly'
        return False
    if sideb.get_other_val() != sidea_num:
        print '\nErr: symmetric did not set other side correctly'
        return False
    
    
    accept_stoppable.stop()
    
    return True