def notification_forever_stored(qty_stored=32,
                                ttl=300,
                                notif_delay=30,
                                run_once=0,
                                *args,
                                **kwargs):
    """Connects, registers, disconnects and then repeats every delay interval:
    1. send notifications x qty_stored (# of notifications to store)
    2. connects
    3. receive notifications x qty_stored

    Repeats forever.
    """
    yield connect()
    response = yield hello(None)
    reg, endpoint = yield register(random_channel_id())
    uaid = response["uaid"]
    yield disconnect()

    while True:
        message_ids = []
        length, data = random_data(min_length=2048, max_length=4096)

        for i in range(qty_stored):
            response, content = yield send_notification(
                endpoint, data, headers={"TTL": str(ttl)})
            yield counter("notification.throughput.bytes", length)
            yield counter("notification.sent", 1)

        yield wait(5)

        yield connect()
        response = yield hello(uaid)
        assert response["uaid"] == uaid

        while True:
            # Pull as many notifications as we can get
            notif = yield expect_notification(reg["channelID"], 2)
            if notif:
                yield counter("notification.received", 1)
                message_ids.append(notif["version"])

            if message_ids:
                while message_ids:
                    message_id = message_ids.pop()
                    yield ack(channel_id=reg["channelID"], version=message_id)
                    yield counter("notification.ack", 1)
            else:
                break

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
        else:
            yield disconnect()
            yield wait(notif_delay)
def connect_and_idle_forever():
    """Connects without ever disconnecting"""
    yield connect()
    yield hello(None)

    while True:
        yield wait(100)
예제 #3
0
def connect_and_idle_forever():
    """Connects without ever disconnecting"""
    yield connect()
    yield hello(None)

    while True:
        yield wait(100)
예제 #4
0
def notification_forever_bad_tokens(notif_delay=30, run_once=0,
                                    token_length=140):
    """Connects, then repeats every delay interval:
    1. send notification with invalid token

    Repeats forever.
    """
    yield connect()
    yield hello(None)

    # register only to retrieve valid endpoint path
    # (we'll replace valid token with invalid one)
    reg, endpoint = yield register(random_channel_id())

    while True:
        endpoint = bad_push_endpoint(endpoint, token_length)
        length, data = random_data(min_length=2048, max_length=4096)
        response, content = yield send_notification(endpoint, data, 60)
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)

        yield wait(notif_delay)
        if run_once:
            yield disconnect()
            break
예제 #5
0
def notification_forever_unsubscribed(notif_delay=30, run_once=0):
    """Connects, registers, unregisters, then repeat following steps
    every delay interval (ignoring 4XXs):
    1. send notification
    2. receive notification

    Repeats forever.
    """
    yield connect()
    yield hello(None)
    reg, endpoint = yield register(random_channel_id())
    unregister(reg["channelID"])

    while True:
        length, data = random_data(min_length=2048, max_length=4096)
        yield timer_start("update.latency")
        response, content = yield send_notification(endpoint, data, 60)
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)
        notif = yield expect_notification(reg["channelID"], 5)
        yield counter("notification.received", 1)
        yield timer_end("update.latency")
        yield ack(channel_id=notif["channelID"], version=notif["version"])
        yield counter("notification.ack", 1)
        yield wait(notif_delay)

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
def notification_forever_unsubscribed(notif_delay=30, run_once=0):
    """Connects, registers, unregisters, then repeat following steps
    every delay interval (ignoring 4XXs):
    1. send notification
    2. receive notification

    Repeats forever.
    """
    yield connect()
    yield hello(None)
    reg, endpoint = yield register(random_channel_id())
    unregister(reg["channelID"])

    while True:
        length, data = random_data(min_length=2048, max_length=4096)
        yield timer_start("update.latency")
        response, content = yield send_notification(endpoint,
                                                    data,
                                                    headers={"TTL": "60"})
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)
        notif = yield expect_notification(reg["channelID"], 5)
        yield counter("notification.received", 1)
        yield timer_end("update.latency")
        yield ack(channel_id=notif["channelID"], version=notif["version"])
        yield counter("notification.ack", 1)
        yield wait(notif_delay)

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
def notification_forever_bad_tokens(notif_delay=30,
                                    run_once=0,
                                    token_length=140):
    """Connects, then repeats every delay interval:
    1. send notification with invalid token

    Repeats forever.
    """
    yield connect()
    yield hello(None)

    # register only to retrieve valid endpoint path
    # (we'll replace valid token with invalid one)
    reg, endpoint = yield register(random_channel_id())

    while True:
        endpoint = bad_push_endpoint(endpoint, token_length)
        length, data = random_data(min_length=2048, max_length=4096)
        response, content = yield send_notification(endpoint,
                                                    data,
                                                    headers={"TTL": "60"})
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)

        yield wait(notif_delay)
        if run_once:
            yield disconnect()
            break
예제 #8
0
def notification_forever_stored(qty_stored=1000, ttl=300, flood_delay=30,
                                notif_delay=30, run_once=0):
    """Connects, then repeats every delay interval:
    1. register
    2. send notifications x qty_stored (# of notifications to store)
    3. wait for flood_delay (seconds)
    4. receive notifications x qty_stored

    Repeats forever.
    """
    yield connect()
    yield hello(None)
    reg, endpoint = yield register(random_channel_id())

    while True:
        message_ids = []
        length, data = random_data(min_length=2048, max_length=4096)

        for i in range(qty_stored):
            response, content = yield send_notification(endpoint, data, ttl)
            yield counter("notification.throughput.bytes", length)
            yield counter("notification.sent", i)
            notif = yield expect_notification(reg["channelID"], ttl)
            yield counter("notification.received", 1)
            message_ids.append(notif["version"])
            yield wait(notif_delay)

        yield wait(flood_delay)

        for i in range(qty_stored):
            yield ack(channel_id=notif["channelID"], version=message_ids[i])
            yield counter("notification.ack", i)
            yield wait(notif_delay)

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
def register_forever(reg_delay=30, run_once=0):
    """Connects, then repeats every delay interval:
    1. register

    Repeats forever.
    """
    yield connect()
    yield hello(None)
    while True:
        reg, endpoint = yield register(random_channel_id())
        yield wait(reg_delay)

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
예제 #10
0
def register_forever(reg_delay=30, run_once=0):
    """Connects, then repeats every delay interval:
    1. register

    Repeats forever.
    """
    yield connect()
    yield hello(None)
    while True:
        reg, endpoint = yield register(random_channel_id())
        yield wait(reg_delay)

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
def reconnect_forever(reconnect_delay=30, run_once=0):
    """Connects, then repeats every delay interval:
    1. send notification
    2. receive notification
    3. disconnect
    4. reconnect

    Repeats forever.
    """
    yield connect()
    response = yield hello(None)

    reg, endpoint = yield register(random_channel_id())
    assert "uaid" in response
    uaid = response["uaid"]

    while True:
        length, data = random_data(min_length=2048, max_length=4096)
        yield timer_start("update.latency")
        response, content = yield send_notification(endpoint,
                                                    data,
                                                    headers={"TTL": "60"})
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)
        notif = yield expect_notification(reg["channelID"], 5)
        yield counter("notification.received", 1)
        yield ack(channel_id=notif["channelID"], version=notif["version"])
        yield counter("notification.ack", 1)
        yield timer_end("update.latency")
        yield wait(reconnect_delay)
        yield disconnect()
        try:
            yield connect()
            response = yield hello(uaid)
            assert response["uaid"] == uaid
        except Exception as ex:
            # Connect may not properly reconnect during some testing, the
            # following work-around ensures that tests pass for now until
            # the race condition can be identified.
            print(ex)
            break

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
def notification_forever_direct_store(cycle_delay=10, run_once=0):
    """Connects, registers, then repeats the following steps even cycle
    delay:
    1. send notification
    2. receive notification
    3. disconnect
    4. wait cycle_delay
    5. connect
    6. receive notification
    7. ack notification

    """
    yield connect()
    response = yield hello(None)
    reg, endpoint = yield register(random_channel_id())
    uaid = response["uaid"]
    ttl = 600

    while True:
        length, data = random_data(min_length=2048, max_length=4096)
        response, content = yield send_notification(endpoint,
                                                    data,
                                                    headers={"TTL": str(ttl)})
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)
        notif = yield expect_notification(reg["channelID"], 2)
        if not notif:
            raise Exception("Needed notification")

        yield disconnect()
        yield wait(cycle_delay)
        yield connect()
        resp = yield hello(uaid)
        assert resp["uaid"] == uaid
        notif = yield expect_notification(reg["channelID"], 10)
        if not notif:
            raise Exception("Needed notification")
        yield ack(channel_id=reg["channelID"], version=notif["version"])

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
예제 #13
0
def notification_forever_bad_endpoints(notif_delay=30, run_once=0):
    """Connects, repeats every delay interval:
    1. send notification with invalid endpoint.

    Repeats forever.
    """
    yield connect()
    yield hello(None)

    while True:
        endpoint = bad_push_endpoint()
        length, data = random_data(min_length=2048, max_length=4096)
        response, content = yield send_notification(endpoint, data, 60)
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)

        yield wait(notif_delay)
        if run_once:
            yield disconnect()
            break
def notification_forever_bad_endpoints(notif_delay=30, run_once=0):
    """Connects, repeats every delay interval:
    1. send notification with invalid endpoint.

    Repeats forever.
    """
    yield connect()
    yield hello(None)

    while True:
        endpoint = bad_push_endpoint()
        length, data = random_data(min_length=2048, max_length=4096)
        response, content = yield send_notification(endpoint,
                                                    data,
                                                    headers={"TTL": "60"})
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)

        yield wait(notif_delay)
        if run_once:
            yield disconnect()
            break
예제 #15
0
def reconnect_forever(reconnect_delay=30, run_once=0):
    """Connects, then repeats every delay interval:
    1. send notification
    2. receive notification
    3. disconnect
    4. reconnect

    Repeats forever.
    """
    yield connect()
    response = yield hello(None)

    reg, endpoint = yield register(random_channel_id())
    assert "uaid" in response
    uaid = response["uaid"]

    while True:
        length, data = random_data(min_length=2048, max_length=4096)
        yield timer_start("update.latency")
        response, content = yield send_notification(endpoint, data, 60)
        yield counter("notification.throughput.bytes", length)
        yield counter("notification.sent", 1)
        notif = yield expect_notification(reg["channelID"], 5)
        yield counter("notification.received", 1)
        yield ack(channel_id=notif["channelID"], version=notif["version"])
        yield counter("notification.ack", 1)
        yield timer_end("update.latency")
        yield wait(reconnect_delay)
        yield disconnect()
        yield connect()
        response = yield hello(uaid)
        assert response["uaid"] == uaid

        if run_once:
            yield unregister(reg["channelID"])
            yield disconnect()
            break
예제 #16
0
def _wait_multiple():
    from aplt.commands import wait
    yield wait(0.1)
    yield wait(0.1)
    yield wait(0.1)
예제 #17
0
def _stack_gens():
    from aplt.commands import wait
    yield _wait_multiple()
    yield wait(0.1)
예제 #18
0
def _wait_multiple():
    from aplt.commands import wait
    yield wait(0.1)
    yield wait(0.1)
    yield wait(0.1)
예제 #19
0
def _stack_gens():
    from aplt.commands import wait
    yield _wait_multiple()
    yield wait(0.1)