Example #1
0
async def _broadcast(app: web.Application,
                     sid: str,
                     exchange: str,
                     routing: str,
                     interval: int
                     ):
    publisher = events.get_publisher(app)
    spark_status = status.get_status(app)
    ctrl = device.get_controller(app)
    last_broadcast_ok = True

    while True:
        try:
            await spark_status.connected.wait()
            await asyncio.sleep(interval)
            obj = await ctrl.read_object({OBJECT_SID_KEY: sid})

            await publisher.publish(
                exchange=exchange,
                routing=routing,
                message=obj[OBJECT_DATA_KEY]
            )

            if not last_broadcast_ok:
                LOGGER.info(f'Remote publisher [{routing}] resumed Ok')
                last_broadcast_ok = True

        except CancelledError:
            break

        except Exception as ex:
            if last_broadcast_ok:
                warnings.warn(f'Remote publisher [{routing}] encountered an error: {strex(ex)}')
                last_broadcast_ok = False
Example #2
0
async def do_command(request: web.Request) -> web.Response:
    """
    ---
    summary: Do a specific command
    tags:
    - Debug
    operationId: controller.spark.debug.do
    produces:
    - application/json
    parameters:
    -
        in: body
        name: body
        description: command
        required: try
        schema:
            type: object
            properties:
                command:
                    type: string
                    example: list_objects
                data:
                    type: object
                    example: {"group_id":0}
    """
    request_args = await request.json()

    command = request_args['command']
    data = request_args['data']

    func = getattr(device.get_controller(request.app), command)
    return web.json_response(await func(**data))
Example #3
0
def test_main(mocker, app):
    mocker.patch(TESTED + '.service.run')
    mocker.patch(TESTED + '.service.create_app').return_value = app

    main.main()

    assert None not in [
        commander.get_commander(app),
        datastore.get_datastore(app),
        device.get_controller(app),
        events.get_listener(app),
        broadcaster.get_broadcaster(app)
    ]
async def test_slave_all(app, client, created, object_args, dummy_listener):
    ctrl = device.get_controller(app)
    await client.post('/remote/slave', json={
        'id': object_args[OBJECT_SID_KEY],
        'key': 'testface',
        'translations': {}
    })

    # No translation table: everything is used
    data = object_args[OBJECT_DATA_KEY]
    data['address'] = 'aa'.rjust(16, '0')

    await dummy_listener.on_message(None, 'testface', deepcopy(data))
    updated = await ctrl.read_object({OBJECT_SID_KEY: object_args[OBJECT_SID_KEY]})
    assert updated[OBJECT_DATA_KEY]['address'] == 'aa'.rjust(16, '0')
Example #5
0
async def _receive(app: web.Application,
                   sid: str,
                   translations: dict,
                   subscription: events.EventSubscription,
                   routing: str,
                   incoming: dict
                   ):
    ctrl = device.get_controller(app)
    obj = await ctrl.read_object({OBJECT_SID_KEY: sid})
    existing = obj[OBJECT_DATA_KEY]

    LOGGER.debug(f'existing={existing}\nincoming={incoming}')

    if translations:
        for remote_path, local_path in translations.items():
            with suppress(KeyError):
                val = dpath.util.get(incoming, glob.escape(remote_path))
                dpath.util.new(existing, local_path, val)
    else:
        # No translations -> use the remote object in its entirety
        obj[OBJECT_DATA_KEY] = incoming

    await ctrl.write_object(obj)
Example #6
0
def ctrl(app):
    return device.get_controller(app)
Example #7
0
 def __init__(self, app: web.Application, wait_sync=True):
     self._wait_sync = wait_sync
     self._status = status.get_status(app)
     self._ctrl: device.SparkController = device.get_controller(app)
     self._store: twinkeydict.TwinKeyDict = datastore.get_datastore(app)