示例#1
0
def main(argv=None):

    _usage = """Usage: %prog [options]"""
    parser = optparse.OptionParser(usage=_usage)
    parser.add_option("-a", dest="server", type="string",
                      default="amqp://0.0.0.0:5672",
                      help="The address of the server [amqp://0.0.0.0:5672]")
    parser.add_option("--idle", dest="idle_timeout", type="int",
                      default=0,
                      help="Idle timeout for connection (seconds).")
    parser.add_option("--debug", dest="debug", action="store_true",
                      help="enable debug logging")
    parser.add_option("--source", dest="source_addr", type="string",
                      help="Address for link source.")
    parser.add_option("--target", dest="target_addr", type="string",
                      help="Address for link target.")
    parser.add_option("--trace", dest="trace", action="store_true",
                      help="enable protocol tracing")
    parser.add_option("-f","--forever", action="store_true",
                      help="don't stop receiving")
    parser.add_option("--ca",
                      help="Certificate Authority PEM file")
    parser.add_option("--ssl-cert-file",
                      help="Self-identifying certificate (PEM file)")
    parser.add_option("--ssl-key-file",
                      help="Key for self-identifying certificate (PEM file)")
    parser.add_option("--ssl-key-password",
                      help="Password to unlock SSL key file")
    parser.add_option("--username", type="string",
                      help="User Id for authentication")
    parser.add_option("--password", type="string",
                      help="User password for authentication")
    parser.add_option("--sasl-mechs", type="string",
                      help="The list of acceptable SASL mechs")
    parser.add_option("--sasl-config-dir", type="string",
                      help="Path to directory containing sasl config")
    parser.add_option("--sasl-config-name", type="string",
                      help="Name of the sasl config file (without '.config')")

    opts, extra = parser.parse_args(args=argv)
    if opts.debug:
        LOG.setLevel(logging.DEBUG)
    host, port = get_host_port(opts.server)
    my_socket = connect_socket(host, port)

    # create AMQP Container, Connection, and SenderLink
    #
    container = pyngus.Container(uuid.uuid4().hex)
    conn_properties = {'hostname': host,
                       'x-server': False}
    if opts.trace:
        conn_properties["x-trace-protocol"] = True
    if opts.ca:
        conn_properties["x-ssl-ca-file"] = opts.ca
    if opts.ssl_cert_file:
        conn_properties["x-ssl-identity"] = (opts.ssl_cert_file,
                                             opts.ssl_key_file,
                                             opts.ssl_key_password)
    if opts.idle_timeout:
        conn_properties["idle-time-out"] = opts.idle_timeout
    if opts.username:
        conn_properties['x-username'] = opts.username
    if opts.password:
        conn_properties['x-password'] = opts.password
    if opts.sasl_mechs:
        conn_properties['x-sasl-mechs'] = opts.sasl_mechs
    if opts.sasl_config_dir:
        conn_properties["x-sasl-config-dir"] = opts.sasl_config_dir
    if opts.sasl_config_name:
        conn_properties["x-sasl-config-name"] = opts.sasl_config_name

    c_handler = ConnectionEventHandler()
    connection = container.create_connection("receiver",
                                             c_handler,
                                             conn_properties)
    connection.open()

    target_address = opts.target_addr or uuid.uuid4().hex
    cb = ReceiverEventHandler()
    receiver = connection.create_receiver(target_address,
                                          opts.source_addr,
                                          cb)
    receiver.add_capacity(1)
    receiver.open()


    while True:

        # Poll connection until something arrives
        while not cb.done:
            process_connection(connection, my_socket)
            if c_handler.error:
                break
            if connection.closed:
                break

        if cb.done:
            print("Receive done, message=%s" % str(cb.message) if cb.message
                  else "ERROR: no message received")
            if cb.handle:
                receiver.message_accepted(cb.handle)
        else:
            print("Receive failed due to connection failure: %s" %
                  c_handler.error or "remote closed unexpectedly")
            break

        if not opts.forever:
            break

        cb.done = False
        receiver.add_capacity(1)

    # Poll connection until close completes:
    while not c_handler.error and not connection.closed:
        process_connection(connection, my_socket)

    receiver.destroy()
    connection.destroy()
    container.destroy()
    my_socket.close()
    return 0
示例#2
0
def main(argv=None):

    _usage = """Usage: %prog [options]"""
    parser = optparse.OptionParser(usage=_usage)
    parser.add_option("-a",
                      dest="server",
                      type="string",
                      default="amqp://0.0.0.0:5672",
                      help="The address of the server [amqp://0.0.0.0:5672]")
    parser.add_option("--node",
                      type='string',
                      default='amq.topic',
                      help='Name of source/target node')
    parser.add_option("--count",
                      type='int',
                      default=100,
                      help='Send N messages (send forever if N==0)')
    parser.add_option("--debug",
                      dest="debug",
                      action="store_true",
                      help="enable debug logging")
    parser.add_option("--trace",
                      dest="trace",
                      action="store_true",
                      help="enable protocol tracing")

    opts, _ = parser.parse_args(args=argv)
    if opts.debug:
        LOG.setLevel(logging.DEBUG)
    host, port = get_host_port(opts.server)
    my_socket = connect_socket(host, port)

    # create AMQP Container, Connection, and SenderLink
    #
    container = pyngus.Container(uuid.uuid4().hex)
    conn_properties = {'hostname': host, 'x-server': False}
    if opts.trace:
        conn_properties["x-trace-protocol"] = True

    c_handler = ConnectionEventHandler()
    connection = container.create_connection("perf_tool", c_handler,
                                             conn_properties)

    r_handler = ReceiverHandler(opts.count, opts.count or 1000)
    receiver = connection.create_receiver(opts.node, opts.node, r_handler)

    s_handler = SenderHandler(opts.count)
    sender = connection.create_sender(opts.node, opts.node, s_handler)

    connection.open()
    receiver.open()
    while not receiver.active:
        process_connection(connection, my_socket)

    sender.open()

    # Run until all messages transfered
    while not sender.closed or not receiver.closed:
        process_connection(connection, my_socket)
    connection.close()
    while not connection.closed:
        process_connection(connection, my_socket)

    duration = s_handler.stop_time - s_handler.start_time
    thru = s_handler.calls / duration
    permsg = duration / s_handler.calls
    ack = s_handler.total_ack_latency / s_handler.calls
    lat = r_handler.tx_total_latency / r_handler.receives
    print("Stats:\n"
          " TX Avg Calls/Sec: %f Per Call: %f Ack Latency %f\n"
          " RX Latency: %f" % (thru, permsg, ack, lat))

    sender.destroy()
    receiver.destroy()
    connection.destroy()
    container.destroy()
    my_socket.close()
    return 0
示例#3
0
def main(argv=None):

    _usage = """Usage: %prog [options] [message content string]"""
    parser = optparse.OptionParser(usage=_usage)
    parser.add_option("-a", dest="server", type="string",
                      default="amqp://127.0.0.1:8888",
                      help="The address of the server [amqp://127.0.0.1:8888]")
    parser.add_option("--idle", dest="idle_timeout", type="int",
                      default=0,
                      help="Idle timeout for connection (seconds).")
    parser.add_option("--debug", dest="debug", action="store_true",
                      help="enable debug logging")
    parser.add_option("--source", dest="source_addr", type="string",
                      help="Address for link source.")
    parser.add_option("--target", dest="target_addr", type="string",
                      help="Address for link target.")
    parser.add_option("--trace", dest="trace", action="store_true",
                      help="enable protocol tracing")
    parser.add_option("--ca",
                      help="Certificate Authority PEM file")

    opts, payload = parser.parse_args(args=argv)
    if not payload:
        payload = "Hi There!"
    if opts.debug:
        LOG.setLevel(logging.DEBUG)

    host, port = get_host_port(opts.server)
    my_socket = connect_socket(host, port)

    # create AMQP Container, Connection, and SenderLink
    #
    container = pyngus.Container("Sender")
    conn_properties = {'hostname': host}
    if opts.trace:
        conn_properties["x-trace-protocol"] = True
    if opts.ca:
        conn_properties["x-ssl-ca-file"] = opts.ca
    if opts.idle_timeout:
        conn_properties["idle-time-out"] = opts.idle_timeout

    connection = container.create_connection("sender",
                                             None,  # no events
                                             conn_properties)
    connection.pn_sasl.mechanisms("ANONYMOUS")
    connection.pn_sasl.client()
    connection.open()

    source_address = opts.source_addr or uuid.uuid4().hex
    sender = connection.create_sender(source_address,
                                      opts.target_addr)
    sender.open()

    # Send a single message:
    msg = Message()
    msg.body = str(payload)

    class SendCallback(object):
        def __init__(self):
            self.done = False
            self.status = None

        def __call__(self, link, handle, status, error):
            self.done = True
            self.status = status

    cb = SendCallback()
    sender.send(msg, cb)

    # Poll connection until SendCallback is invoked:
    while not cb.done and not connection.closed:
        process_connection(connection, my_socket)

    if cb.done:
        print("Send done, status=%s" % SEND_STATUS.get(cb.status,
                                                       "???"))
    else:
        print("Send failed due to connection failure!")

    sender.close()
    connection.close()

    # Poll connection until close completes:
    while not connection.closed:
        process_connection(connection, my_socket)

    sender.destroy()
    connection.destroy()
    container.destroy()
    my_socket.close()
    return 0
示例#4
0
def main(argv=None):

    _usage = """Usage: %prog [options] [message content string]"""
    parser = optparse.OptionParser(usage=_usage)
    parser.add_option("-a", dest="server", type="string",
                      default="amqp://0.0.0.0:5672",
                      help="The address of the server [amqp://0.0.0.0:5672]")
    parser.add_option("--idle", dest="idle_timeout", type="int",
                      default=0,
                      help="Idle timeout for connection (seconds).")
    parser.add_option("--debug", dest="debug", action="store_true",
                      help="enable debug logging")
    parser.add_option("--source", dest="source_addr", type="string",
                      help="Address for link source.")
    parser.add_option("--target", dest="target_addr", type="string",
                      help="Address for link target.")
    parser.add_option("--trace", dest="trace", action="store_true",
                      help="enable protocol tracing")
    parser.add_option("-f", "--forever", action="store_true",
                      help="Keep sending forever")
    parser.add_option("--ca",
                      help="Certificate Authority PEM file")
    parser.add_option("--ssl-cert-file",
                      help="Self-identifying certificate (PEM file)")
    parser.add_option("--ssl-key-file",
                      help="Key for self-identifying certificate (PEM file)")
    parser.add_option("--ssl-key-password",
                      help="Password to unlock SSL key file")
    parser.add_option("--username", type="string",
                      help="User Id for authentication")
    parser.add_option("--password", type="string",
                      help="User password for authentication")
    parser.add_option("--sasl-mechs", type="string",
                      help="The list of acceptable SASL mechs")
    parser.add_option("--sasl-config-dir", type="string",
                      help="Path to directory containing sasl config")
    parser.add_option("--sasl-config-name", type="string",
                      help="Name of the sasl config file (without '.config')")

    opts, payload = parser.parse_args(args=argv)
    if not payload:
        payload = "Hi There!"
    if opts.debug:
        LOG.setLevel(logging.DEBUG)

    host, port = get_host_port(opts.server)
    my_socket = connect_socket(host, port)

    # create AMQP Container, Connection, and SenderLink
    #
    container = pyngus.Container(uuid.uuid4().hex)
    conn_properties = {'hostname': host,
                       'x-server': False}
    if opts.trace:
        conn_properties["x-trace-protocol"] = True
    if opts.ca:
        conn_properties["x-ssl-ca-file"] = opts.ca
    if opts.ssl_cert_file:
        
        conn_properties["x-ssl-identity"] = (opts.ssl_cert_file,
                                             opts.ssl_key_file,
                                             opts.ssl_key_password)
    if opts.idle_timeout:
        conn_properties["idle-time-out"] = opts.idle_timeout
    if opts.username:
        conn_properties['x-username'] = opts.username
    if opts.password:
        conn_properties['x-password'] = opts.password
    if opts.sasl_mechs:
        conn_properties['x-sasl-mechs'] = opts.sasl_mechs
    if opts.sasl_config_dir:
        conn_properties["x-sasl-config-dir"] = opts.sasl_config_dir
    if opts.sasl_config_name:
        conn_properties["x-sasl-config-name"] = opts.sasl_config_name

    c_handler = ConnectionEventHandler()
    connection = container.create_connection("sender",
                                             c_handler,
                                             conn_properties)
    connection.open()

    source_address = opts.source_addr or uuid.uuid4().hex
    s_handler = SenderEventHandler()
    sender = connection.create_sender(source_address,
                                      opts.target_addr,
                                      s_handler)
    sender.open()

    class SendCallback(object):
        def __init__(self):
            self.done = False
            self.status = None

        def __call__(self, link, handle, status, error):
            self.done = True
            self.status = status

    while True:

        # Send a single message:
        msg = Message()
        msg.body = str(payload)

        cb = SendCallback()
        sender.send(msg, cb)

        # Poll connection until SendCallback is invoked:
        while not cb.done:
            process_connection(connection, my_socket)
            if c_handler.error:
                break
            if connection.closed:
                break

        if cb.done:
            print("Send done, status=%s" % SEND_STATUS.get(cb.status,
                                                       "???"))
        else:
            print("Send failed due to connection failure: %s" %
                  c_handler.error or "remote closed unexpectedly")
            break

        if not opts.forever:
            break

    if not sender.closed:
        sender.close()
    if not connection.closed:
        connection.close()

    # Poll connection until close completes:
    while not c_handler.error and not connection.closed:
        process_connection(connection, my_socket)

    sender.destroy()
    connection.destroy()
    container.destroy()
    my_socket.close()
    return 0
示例#5
0
    def __init__(self, server, ca, ssl_cert_file, ssl_key_file,
                 ssl_key_password, source):

        # opts, extra = parser.parse_args(args=argv)
        # if opts.debug:
        #    LOG.setLevel(logging.DEBUG)
        #self.server = server
        host, port = get_host_port(server)
        my_socket = connect_socket(host, port, blocking=False)

        # create AMQP Container, Connection, and SenderLink
        #
        container = pyngus.Container(uuid.uuid4().hex)
        conn_properties = {'hostname': host, 'x-server': False}
        conn_properties["x-trace-protocol"] = True
        conn_properties["x-ssl-ca-file"] = ca
        conn_properties["x-ssl-identity"] = (ssl_cert_file, ssl_key_file,
                                             ssl_key_password)
        # if opts.idle_timeout:
        #     conn_properties["idle-time-out"] = opts.idle_timeout
        # if opts.username:
        #     conn_properties['x-username'] = opts.username
        # if opts.password:
        #     conn_properties['x-password'] = opts.password
        # if opts.sasl_mechs:
        #     conn_properties['x-sasl-mechs'] = opts.sasl_mechs
        # if opts.sasl_config_dir:
        #     conn_properties["x-sasl-config-dir"] = opts.sasl_config_dir
        # if opts.sasl_config_name:
        #     conn_properties["x-sasl-config-name"] = opts.sasl_config_name
        #conn_properties["x-force-sasl"] = True
        with open(ca, "r") as f:
            print("reading first line from certificate to ensure we have it")
            print(f.readline())

        conn_properties["x-ssl-verify-mode"] = "no-verify"
        c_handler = ConnectionEventHandler()
        connection = container.create_connection("receiver", c_handler,
                                                 conn_properties)
        connection.open()

        target_address = uuid.uuid4().hex
        cb = ReceiverEventHandler()
        receiver = connection.create_receiver(target_address, source, cb)
        receiver.add_capacity(1)
        receiver.open()

        # Poll connection until something arrives
        while not cb.done and not connection.closed:
            process_connection(connection, my_socket)

        if cb.done:
            print("Receive done, message=%s" % str(cb.message) if cb.
                  message else "ERROR: no message received")
            if cb.handle:
                receiver.message_accepted(cb.handle)
        else:
            print("Receive failed due to connection failure!")

        # flush any remaining output before closing (optional)
        while connection.has_output > 0:
            process_connection(connection, my_socket)

        receiver.close()
        connection.close()

        # Poll connection until close completes:
        while not connection.closed:
            process_connection(connection, my_socket)

        receiver.destroy()
        connection.destroy()
        container.destroy()
        my_socket.close()
示例#6
0
def main(argv=None):

    _usage = """Usage: %prog [options]"""
    parser = optparse.OptionParser(usage=_usage)
    parser.add_option("-a", dest="server", type="string",
                      default="amqp://127.0.0.1:8888",
                      help="The address of the server [amqp://127.0.0.1:8888]")
    parser.add_option("--idle", dest="idle_timeout", type="int",
                      default=0,
                      help="Idle timeout for connection (seconds).")
    parser.add_option("--debug", dest="debug", action="store_true",
                      help="enable debug logging")
    parser.add_option("--source", dest="source_addr", type="string",
                      help="Address for link source.")
    parser.add_option("--target", dest="target_addr", type="string",
                      help="Address for link target.")
    parser.add_option("--trace", dest="trace", action="store_true",
                      help="enable protocol tracing")
    parser.add_option("--ca",
                      help="Certificate Authority PEM file")

    opts, extra = parser.parse_args(args=argv)
    if opts.debug:
        LOG.setLevel(logging.DEBUG)
    host, port = get_host_port(opts.server)
    my_socket = connect_socket(host, port)

    # create AMQP Container, Connection, and SenderLink
    #
    container = pyngus.Container(uuid.uuid4().hex)
    conn_properties = {'hostname': host}
    if opts.trace:
        conn_properties["x-trace-protocol"] = True
    if opts.ca:
        conn_properties["x-ssl-ca-file"] = opts.ca
    if opts.idle_timeout:
        conn_properties["idle-time-out"] = opts.idle_timeout

    connection = container.create_connection("receiver",
                                             None,  # no events
                                             conn_properties)
    connection.pn_sasl.mechanisms("ANONYMOUS")
    connection.pn_sasl.client()
    connection.open()

    class ReceiveCallback(pyngus.ReceiverEventHandler):
        def __init__(self):
            self.done = False
            self.message = None
            self.handle = None

        def message_received(self, receiver, message, handle):
            self.done = True
            self.message = message
            self.handle = handle

    target_address = opts.target_addr or uuid.uuid4().hex
    cb = ReceiveCallback()
    receiver = connection.create_receiver(target_address,
                                          opts.source_addr,
                                          cb)
    receiver.add_capacity(1)
    receiver.open()

    # Poll connection until something arrives
    while not cb.done and not connection.closed:
        process_connection(connection, my_socket)

    if cb.done:
        print("Receive done, message=%s" % str(cb.message))
        receiver.message_accepted(cb.handle)
    else:
        print("Receive failed due to connection failure!")

    receiver.close()
    connection.close()

    # Poll connection until close completes:
    while not connection.closed:
        process_connection(connection, my_socket)

    receiver.destroy()
    connection.destroy()
    container.destroy()
    my_socket.close()
    return 0
示例#7
0
def main(argv=None):

    _usage = """Usage: %prog [options]"""
    parser = optparse.OptionParser(usage=_usage)
    parser.add_option("-a", dest="server", type="string",
                      default="amqp://0.0.0.0:5672",
                      help="The address of the server [amqp://0.0.0.0:5672]")
    parser.add_option("--node", type='string', default='amq.topic',
                      help='Name of source/target node')
    parser.add_option("--count", type='int', default=100,
                      help='Send N messages (send forever if N==0)')
    parser.add_option("--debug", dest="debug", action="store_true",
                      help="enable debug logging")
    parser.add_option("--trace", dest="trace", action="store_true",
                      help="enable protocol tracing")

    opts, _ = parser.parse_args(args=argv)
    if opts.debug:
        LOG.setLevel(logging.DEBUG)
    host, port = get_host_port(opts.server)
    my_socket = connect_socket(host, port)

    # create AMQP Container, Connection, and SenderLink
    #
    container = pyngus.Container(uuid.uuid4().hex)
    conn_properties = {'hostname': host,
                       'x-server': False}
    if opts.trace:
        conn_properties["x-trace-protocol"] = True

    c_handler = ConnectionEventHandler()
    connection = container.create_connection("perf_tool",
                                             c_handler,
                                             conn_properties)

    r_handler = ReceiverHandler(opts.count, opts.count or 1000)
    receiver = connection.create_receiver(opts.node, opts.node, r_handler)

    s_handler = SenderHandler(opts.count)
    sender = connection.create_sender(opts.node, opts.node, s_handler)

    connection.open()
    receiver.open()
    while not receiver.active:
        process_connection(connection, my_socket)

    sender.open()

    # Run until all messages transfered
    while not sender.closed or not receiver.closed:
        process_connection(connection, my_socket)
    connection.close()
    while not connection.closed:
        process_connection(connection, my_socket)

    duration = s_handler.stop_time - s_handler.start_time
    thru = s_handler.calls / duration
    permsg = duration / s_handler.calls
    ack = s_handler.total_ack_latency / s_handler.calls
    lat = r_handler.tx_total_latency / r_handler.receives
    print("Stats:\n"
          " TX Avg Calls/Sec: %f Per Call: %f Ack Latency %f\n"
          " RX Latency: %f" % (thru, permsg, ack, lat))

    sender.destroy()
    receiver.destroy()
    connection.destroy()
    container.destroy()
    my_socket.close()
    return 0
示例#8
0
def main(argv=None):

    _usage = """Usage: %prog [options]"""
    parser = optparse.OptionParser(usage=_usage)
    parser.add_option("-a", dest="server", type="string",
                      default="amqp://0.0.0.0:5672",
                      help="The address of the server [amqp://0.0.0.0:5672]")
    parser.add_option("--idle", dest="idle_timeout", type="int",
                      default=0,
                      help="Idle timeout for connection (seconds).")
    parser.add_option("--debug", dest="debug", action="store_true",
                      help="enable debug logging")
    parser.add_option("--source", dest="source_addr", type="string",
                      help="Address for link source.")
    parser.add_option("--target", dest="target_addr", type="string",
                      help="Address for link target.")
    parser.add_option("--trace", dest="trace", action="store_true",
                      help="enable protocol tracing")
    parser.add_option("--ca",
                      help="Certificate Authority PEM file")
    parser.add_option("--ssl-cert-file",
                      help="Self-identifying certificate (PEM file)")
    parser.add_option("--ssl-key-file",
                      help="Key for self-identifying certificate (PEM file)")
    parser.add_option("--ssl-key-password",
                      help="Password to unlock SSL key file")
    parser.add_option("--username", type="string",
                      help="User Id for authentication")
    parser.add_option("--password", type="string",
                      help="User password for authentication")
    parser.add_option("--sasl-mechs", type="string",
                      help="The list of acceptable SASL mechs")
    parser.add_option("--sasl-config-dir", type="string",
                      help="Path to directory containing sasl config")
    parser.add_option("--sasl-config-name", type="string",
                      help="Name of the sasl config file (without '.config')")

    opts, extra = parser.parse_args(args=argv)
    if opts.debug:
        LOG.setLevel(logging.DEBUG)
    host, port = get_host_port(opts.server)
    my_socket = connect_socket(host, port)

    # create AMQP Container, Connection, and SenderLink
    #
    container = pyngus.Container(uuid.uuid4().hex)
    conn_properties = {'hostname': host,
                       'x-server': False}
    if opts.trace:
        conn_properties["x-trace-protocol"] = True
    if opts.ca:
        conn_properties["x-ssl-ca-file"] = opts.ca
    if opts.ssl_cert_file:
        conn_properties["x-ssl-identity"] = (opts.ssl_cert_file,
                                             opts.ssl_key_file,
                                             opts.ssl_key_password)
    if opts.idle_timeout:
        conn_properties["idle-time-out"] = opts.idle_timeout
    if opts.username:
        conn_properties['x-username'] = opts.username
    if opts.password:
        conn_properties['x-password'] = opts.password
    if opts.sasl_mechs:
        conn_properties['x-sasl-mechs'] = opts.sasl_mechs
    if opts.sasl_config_dir:
        conn_properties["x-sasl-config-dir"] = opts.sasl_config_dir
    if opts.sasl_config_name:
        conn_properties["x-sasl-config-name"] = opts.sasl_config_name

    c_handler = ConnectionEventHandler()
    connection = container.create_connection("receiver",
                                             c_handler,
                                             conn_properties)
    connection.open()

    target_address = opts.target_addr or uuid.uuid4().hex
    cb = ReceiverEventHandler()
    receiver = connection.create_receiver(target_address,
                                          opts.source_addr,
                                          cb)
    receiver.add_capacity(1)
    receiver.open()

    # Poll connection until something arrives
    while not cb.done and not connection.closed:
        process_connection(connection, my_socket)

    if cb.done:
        print("Receive done, message=%s" % str(cb.message) if cb.message
              else "ERROR: no message received")
        if cb.handle:
            receiver.message_accepted(cb.handle)
    else:
        print("Receive failed due to connection failure!")

    # flush any remaining output before closing (optional)
    while connection.has_output > 0:
        process_connection(connection, my_socket)

    receiver.close()
    connection.close()

    # Poll connection until close completes:
    while not connection.closed:
        process_connection(connection, my_socket)

    receiver.destroy()
    connection.destroy()
    container.destroy()
    my_socket.close()
    return 0