def publish_gpx_files(client: pynats.NATSClient,
                      files: List[map_point.GpxFile]):
    publisher_name = "gpx_files.gpx_file"
    for i, f in enumerate(files):
        logger.info("publishing file",
                    extra=logging_utils.wrap_props({
                        "file_name": f.name,
                        "file_number": i
                    }))

        payload = nats_payload.Payload(sender="pg_pull_nats_push",
                                       data={"file_id": f.id})
        payload_bytes = payload.to_payload()
        publish_name = publisher_name
        client.publish(subject=publish_name, payload=payload_bytes)
Exemple #2
0
def test_request(nats_plain_url):
    def worker():
        with NATSClient(nats_plain_url, socket_timeout=2) as client:

            def callback(message):
                client.publish(message.reply, payload=b"test-callback-payload")

            client.subscribe("test-subject",
                             callback=callback,
                             queue="test-queue",
                             max_messages=2)
            client.wait(count=2)

    t = threading.Thread(target=worker)
    t.start()

    time.sleep(1)

    with NATSClient(nats_plain_url, socket_timeout=2) as client:
        # request without payload
        resp = client.request("test-subject")
        assert resp.subject.startswith("_INBOX.")
        assert resp.reply == ""
        assert resp.payload == b"test-callback-payload"

        # request with payload
        resp = client.request("test-subject", payload=b"test-payload")
        assert resp.subject.startswith("_INBOX.")
        assert resp.reply == ""
        assert resp.payload == b"test-callback-payload"

    t.join()
Exemple #3
0
def test_subscribe_unsubscribe(nats_plain_url):
    with NATSClient(nats_plain_url, socket_timeout=2) as client:
        sub = client.subscribe("test-subject",
                               callback=lambda x: x,
                               queue="test-queue",
                               max_messages=2)
        client.unsubscribe(sub)
Exemple #4
0
def sub(que):
    def push_in_queue(msg):
        que.put(msg.payload.decode())

    with NATSClient(name=name + "sub") as client:
        client.subscribe(str(room), callback=push_in_queue)
        client.wait()
def test_subscribe_timeout(nats_url):
    with NATSClient(nats_url, socket_timeout=2) as client:
        sub = client.subscribe(
            "test-subject", callback=lambda x: x, queue="test-queue", max_messages=1
        )

        with pytest.raises(socket.timeout):
            client.wait(count=1)

        client.unsubscribe(sub)
    def worker():
        with NATSClient(nats_url, socket_timeout=2) as client:

            def callback(message):
                received.append(message)

            client.subscribe(
                "test-subject", callback=callback, queue="test-queue", max_messages=2
            )
            client.wait(count=2)
Exemple #7
0
def test_graceful_shutdown(nats_plain_url):
    def worker(client, connected_event):
        client.connect()
        connected_event.set()
        try:
            client.wait()
        except NATSReadSocketError:
            assert True
        except Exception:
            raise AssertionError("unexpected Exception raised")

    client = NATSClient(nats_plain_url)
    connected_event = threading.Event()
    thread = threading.Thread(target=worker, args=[client, connected_event])
    thread.start()
    assert connected_event.wait(5), "unable to connect"
    client.close()
    thread.join(5)
    assert not thread.is_alive(), "thread did not finish"
    def worker():
        with NATSClient(nats_url, socket_timeout=2) as client:

            def callback(message):
                client.publish(message.reply, payload=b"test-callback-payload")

            client.subscribe(
                "test-subject", callback=callback, queue="test-queue", max_messages=2
            )
            client.wait(count=2)
Exemple #9
0
def read_temp(signum, frame):
    with open(device_file, 'r') as f:
        temp_s = f.readline()
        temp = float(temp_s) / 1000.0
    cas = time.strftime("%Y-%m-%dT%H:%M:%S")
    data = {'time': cas, 'data': {'temperature': temp}}
    payload = dumps(data)
    try:
        with NATSClient("nats://rpi3:4222") as client:
            client.publish("rpi3", payload=payload.encode())
        pause()
    except ConnectionRefusedError:
        read_temp(14, None)
Exemple #10
0
def add(todo: str = Form(...)):
    ### ... means todo param is required
    if len(todo) <= 140:
        logger.info(f"Adding todo: {todo}")
        with conn:
            with conn.cursor() as cur:
                cur.execute(f"INSERT INTO todos(todo) VALUES ('{todo}')")
        with NATSClient(os.environ["NATS_URL"]) as client:
            message = {"msg": todo, "type": "inserted"}
            client.publish("broadcaster", payload=json.dumps(message))
    else:
        logger.warn(f"Todo message too long, not added")

    return RedirectResponse("/todos", status_code=status.HTTP_303_SEE_OTHER)
Exemple #11
0
    def __init__(
        self,
        run_panini: typing.Callable = lambda *args, **kwargs: None,
        panini_service_name: str = "*",
        panini_client_id: str = "*",
        use_web_server: bool = False,
        use_web_socket: bool = False,
        base_web_server_url: str = "http://127.0.0.1:8080",
        base_nats_url: str = "nats://127.0.0.1:4222",
        socket_timeout: int = 5,
        name: str = "__".join([
            "test_client",
            str(random.randint(1, 10000000)),
            str(random.randint(1, 10000000)),
        ]),
    ):
        self.run_panini = run_panini
        self.panini_service_name = panini_service_name
        self.panini_client_id = panini_client_id
        self.base_web_server_url = base_web_server_url
        self.use_web_server = use_web_server
        self.use_web_socket = use_web_socket
        self.nats_client = NATSClient(
            url=base_nats_url,
            name=name,
            socket_timeout=socket_timeout,
        )
        self.nats_client.connect()

        if use_web_server:
            self.http_session = HTTPSessionTestClient(
                base_url=base_web_server_url)

        if use_web_socket:
            self.websocket_session = websocket.WebSocket()

        self.panini_process = None
Exemple #12
0
def update(todo_id: int = Form(...)):
    try:
        with conn:
            with conn.cursor() as cur:
                cur.execute(
                    f"UPDATE todos SET done='t' WHERE id = {todo_id} RETURNING todo"
                )
                todo = cur.fetchone()[0]
        with NATSClient(os.environ["NATS_URL"]) as client:
            message = {"msg": todo, "type": "updated"}
            client.publish("broadcaster", payload=json.dumps(message))
    except Exception as e:
        print(e)
        raise HTTPException(status_code=500, detail="Server error")
    return RedirectResponse("/todos", status_code=status.HTTP_303_SEE_OTHER)
Exemple #13
0
    def worker():
        with NATSClient(nats_plain_url, socket_timeout=2) as client:

            def callback(message):
                client.publish(
                    message.reply,
                    payload=msgpack.packb(
                        {b"v": 3338} if message.payload else {b"v": 32}),
                )

            client.subscribe("test-subject",
                             callback=callback,
                             queue="test-queue",
                             max_messages=2)
            client.wait(count=2)
Exemple #14
0
def test_publish(nats_plain_url):
    received = []

    def worker():
        with NATSClient(nats_plain_url, socket_timeout=2) as client:

            def callback(message):
                received.append(message)

            client.subscribe("test-subject",
                             callback=callback,
                             queue="test-queue",
                             max_messages=2)
            client.wait(count=2)

    t = threading.Thread(target=worker)
    t.start()

    time.sleep(1)

    with NATSClient(nats_plain_url, socket_timeout=2) as client:
        # publish without payload
        client.publish("test-subject")
        # publish with payload
        client.publish("test-subject", payload=b"test-payload")

    t.join()

    assert len(received) == 2

    assert received[0].subject == "test-subject"
    assert received[0].reply == ""
    assert received[0].payload == b""

    assert received[1].subject == "test-subject"
    assert received[1].reply == ""
    assert received[1].payload == b"test-payload"
Exemple #15
0
def test_request_msgpack(nats_plain_url):
    def worker():
        with NATSClient(nats_plain_url, socket_timeout=2) as client:

            def callback(message):
                client.publish(
                    message.reply,
                    payload=msgpack.packb(
                        {b"v": 3338} if message.payload else {b"v": 32}),
                )

            client.subscribe("test-subject",
                             callback=callback,
                             queue="test-queue",
                             max_messages=2)
            client.wait(count=2)

    t = threading.Thread(target=worker)
    t.start()

    time.sleep(1)

    with NATSClient(nats_plain_url, socket_timeout=2) as client:
        # request without payload
        resp = client.request("test-subject")
        assert resp.subject.startswith("_INBOX.")
        assert resp.reply == ""
        assert msgpack.unpackb(resp.payload) == {b"v": 32}

        # request with payload
        resp = client.request("test-subject",
                              payload=msgpack.packb("test-payload"))
        assert resp.subject.startswith("_INBOX.")
        assert resp.reply == ""
        assert msgpack.unpackb(resp.payload) == {b"v": 3338}

    t.join()
Exemple #16
0
def send_message(data, channel=None):
    if channel is None:
        channel = settings.NATS_CHANNEL_OUT
    status = False
    # nc = SyncClient(settings.NATS_HOST_PORT)
    nc = SyncClient(f'nats://{settings.NATS_HOST_PORT}')
    try:
        nc.connect()
        data_enc = dumps(data).encode('utf-8')
        response_data = {}
        try:
            # payload = json.dumps(data_enc)
            nc.publish(channel, payload=data_enc)
            # response_data = json.loads(_response.payload)
        except ErrTimeout:
            print("Request timed out")

        # response = response_data.get('subject', '')
        status = response_data.get('received', False)
        status = True
    except Exception as e:
        print(f'{str(e)}')
    nc.close()
    return status
here = Path(__file__).absolute().parent
csv_file = here / 'taxi.csv.bz2'

conversions = [
    ('VendorID', 'vendor', int),
    ('tpep_pickup_datetime', 'pickup', str),
    ('tpep_dropoff_datetime', 'dropoff', str),
    ('passenger_count', 'passengers', int),
    ('trip_distance', 'distance', float),
    ('tip_amount', 'tip', float),
    ('total_amount', 'amount', float),
]


def iter_rides():
    with bz2.open(csv_file, 'rt') as fp:
        for row in csv.DictReader(fp):
            record = {}
            for src, dest, conv in conversions:
                record[dest] = conv(row[src])
            yield record


client = NATSClient('nats://localhost:4222')
client.connect()
for ride in iter_rides():
    sleep(random())
    payload = json.dumps(ride)
    client.publish('rides', payload=payload)
Exemple #18
0
def test_invalid_scheme():
    client = NATSClient("http://127.0.0.1:4224")

    with pytest.raises(NATSInvalidSchemeError):
        client.connect()
Exemple #19
0
def test_tls_connect(nats_tls_url):
    client = NATSClient(nats_tls_url, socket_timeout=2)

    client.connect()
    client.ping()
    client.close()
Exemple #20
0
def test_reconnect(nats_plain_url):
    client = NATSClient(nats_plain_url, socket_timeout=2)

    client.connect()
    client.ping()

    client.reconnect()
    client.ping()

    client.close()
Exemple #21
0
def test_connect_timeout():
    client = NATSClient("nats://127.0.0.1:4223", socket_timeout=2)

    with pytest.raises(socket.error):
        client.connect()
Exemple #22
0
def test_connect_and_close_using_context_manager(nats_plain_url):
    with NATSClient(nats_plain_url, socket_timeout=2) as client:
        client.ping()
def nats_publish(nats_url, msg, topic):
    # TODO fix the settings reading
    msg_to_send = msg.SerializeToString()
    with NATSClient(nats_url) as client:
        client.publish(topic, payload=msg_to_send)
Exemple #24
0
def test_request_timeout(nats_plain_url):
    with NATSClient(nats_plain_url, socket_timeout=2) as client:
        with pytest.raises(socket.timeout):
            client.request("test-subject")
Exemple #25
0
#!/usr/bin/python3
from pynats import NATSClient
import argparse
import json

subject = 'message/sensor/92868a'
msg = {
    "device_code": "92868a-vr88",
    "date_add": "2020-06-07 10:10:10",
    "gyro": {
        "x": 11.1,
        "y": 12.4,
        "z": 15
    },
    "proximity": 111.5,
    "rssi": 10.5
}
msg = json.dumps(msg)
if __name__ == '__main__':
    client = NATSClient("nats://103.56.148.215:4222",
                        socket_timeout=2,
                        verbose=True)
    client.connect()
    #client.ping()
    client.publish(subject, payload=msg)
    client.close()
Exemple #26
0
from pynats import NATSClient
import argparse
import json
from datetime import datetime

broker = "127.0.0.1"  #"161.117.58.227"
port = "4222"
subject = 'message/sensor/xzhu2l'

client = NATSClient("nats://" + broker + ":" + port,
                    socket_timeout=2,
                    verbose=True)
client.connect()
today = datetime.today()  #current-datetime
msg = {
    "device_code": "xzhu2l-cq91",
    "date_add": round(datetime.today().timestamp() *
                      1000),  #today.strftime("%Y-%m-%d %H:%M:%S"),
    "gps": {
        "latitude": -7.575973,
        "longitude": 112.878304
    },
    "temperature": 25.5,
    "fuel": 1000
}
payload = json.dumps(msg)
client.publish(subject, payload=payload)
client.close()
Exemple #27
0
def generate_blocking_client(host=DEFAULT_HOST, port=DEFAULT_PORT):
    client = BlockingNATSClient('nats://{}:{}'.format(host, port))
    client.connect()
    return client
Exemple #28
0
#!/usr/bin/python3
from pynats import NATSClient
import argparse
import json
import sys, json, time

broker_address = "103.56.148.215"
port = "4222"
client = NATSClient("nats://"+broker_address+":"+port,verbose=True)

def publish(topic,message):
	try:
		print(topic)
		print(message)
		sys.stdout.flush()
		client.connect()
		client.publish(topic, payload=json.dumps(message))
		client.close()
	except:
		print("failed")
	return
Exemple #29
0
here = Path(__file__).absolute().parent
csv_file = here / os.path.join(THIS_FOLDER, "taxi.csv.bz2")


conversions = [
    ("VendorID", "vendor", int),
    ("tpep_pickup_datetime", "pickup", str),
    ("tpep_dropoff_datetime", "dropoff", str),
    ("passenger_count", "passengers", int),
    ("trip_distance", "distance", float),
    ("tip_amount", "tip", float),
    ("total_amount", "amount", float),
]


def iter_rides():
    with bz2.open(csv_file, "rt") as fp:
        for row in csv.DictReader(fp):
            record = {}
            for src, dest, conv in conversions:
                record[dest] = conv(row[src])
            yield record


client = NATSClient("nats://localhost:4222")
client.connect()
for ride in iter_rides():
    sleep(random())
    payload = json.dumps(ride)
    client.publish("rides", payload=payload)
Exemple #30
0
        client.subscribe(str(room), callback=push_in_queue)
        client.wait()


ps = Process(target=sub, args=(in_queue, ))
ps.start()

layout = [[sg.Output((100, 20), key='out')],
          [sg.Text('mesg'), sg.InputText(key='msg')], [sg.Ok()]]
window = sg.Window('room' + str(room) + ':' + str(name), layout)

while True:
    event, values = window.read(100)
    if event in (sg.WIN_CLOSED, 'Cancel'):
        break
    if event == 'Ok':
        txt = values.get('msg', None)
        if txt is not None and len(txt) > 0:
            with NATSClient(name=name + "pub") as client:
                client.publish(str(room),
                               payload=str(name + ": " + txt).encode())
    try:
        t = in_queue.get(block=False)
        print(t)
    except Exception:
        pass

window.close()
ps.kill()
ps.join()