Example #1
0
def set_connection(con):
    if con.has_key('mode'):
        con['mode'] = {'bypass': mapper.MO_BYPASS,
                       'linear': mapper.MO_LINEAR,
                       'calibrate': mapper.MO_CALIBRATE,
                       'expression': mapper.MO_EXPRESSION}[con['mode']]
    monitor.modify(con)

monitor.db.add_device_callback(on_device)
monitor.db.add_signal_callback(on_signal)
monitor.db.add_link_callback(on_link)
monitor.db.add_mapping_callback(on_connection)

server.add_command_handler("all_devices",
                           lambda x: ("all_devices",
                                      list(monitor.db.all_devices())))

server.add_command_handler("all_signals",
                           lambda x: ("all_signals",
                                      list(monitor.db.all_inputs())
                                      + list(monitor.db.all_outputs())))

server.add_command_handler("all_links",
                           lambda x: ("all_links",
                                      list(monitor.db.all_links())))

server.add_command_handler("all_connections",
                           lambda x: ("all_connections",
                                      list(monitor.db.all_mappings())))
Example #2
0
    if con.has_key("mode"):
        con["mode"] = {
            "bypass": mapper.MO_BYPASS,
            "linear": mapper.MO_LINEAR,
            "calibrate": mapper.MO_CALIBRATE,
            "expression": mapper.MO_EXPRESSION,
        }[con["mode"]]
    monitor.modify(con)


monitor.db.add_device_callback(on_device)
monitor.db.add_signal_callback(on_signal)
monitor.db.add_link_callback(on_link)
monitor.db.add_mapping_callback(on_connection)

server.add_command_handler("all_devices", lambda x: ("all_devices", list(monitor.db.all_devices())))

server.add_command_handler(
    "all_signals", lambda x: ("all_signals", list(monitor.db.all_inputs()) + list(monitor.db.all_outputs()))
)

server.add_command_handler("all_links", lambda x: ("all_links", list(monitor.db.all_links())))

server.add_command_handler("all_connections", lambda x: ("all_connections", list(monitor.db.all_mappings())))

server.add_command_handler("set_connection", set_connection)

server.add_command_handler("link", lambda x: monitor.link(*map(str, x)))

server.add_command_handler("unlink", lambda x: monitor.unlink(*map(str, x)))
Example #3
0
def on_load(mapping_json):
    mapperstorage.deserialise(monitor, mapping_json)


def init_monitor():
    monitor.request_devices()
    monitor.db.add_device_callback(on_device)
    monitor.db.add_signal_callback(on_signal)
    monitor.db.add_link_callback(on_link)
    monitor.db.add_connection_callback(on_connection)


init_monitor()

server.add_command_handler(
    "all_devices", lambda x: ("all_devices", list(monitor.db.all_devices())))

server.add_command_handler(
    "all_signals", lambda x: ("all_signals", list(monitor.db.all_inputs()) +
                              list(monitor.db.all_outputs())))

server.add_command_handler(
    "all_links", lambda x: ("all_links", list(monitor.db.all_links())))

server.add_command_handler(
    "all_connections", lambda x:
    ("all_connections", list(monitor.db.all_connections())))

server.add_command_handler("set_connection", set_connection)

server.add_command_handler("link", lambda x: monitor.link(*map(str, x)))
Example #4
0
        addrs = netifaces.ifaddresses(i)
        if location in addrs:       # Test to see if the interface is actually connected
            connectedInterfaces.append(i)
    server.send_command("available_networks", connectedInterfaces)
    networkInterfaces['available'] = connectedInterfaces
    server.send_command("active_network", networkInterfaces['active'])

def init_database(arg):
    global db
    db.subscribe(mapper.OBJ_DEVICES | mapper.OBJ_LINKS)
    db.add_device_callback(on_device)
    db.add_link_callback(on_link)
    db.add_signal_callback(on_signal)
    db.add_map_callback(on_map)

server.add_command_handler("add_devices",
                           lambda x: ("add_devices", map(dev_props, db.devices())))

def subscribe(device):
    if device == "all_devices":
        db.subscribe(mapper.OBJ_DEVICES | mapper.OBJ_LINKS)
    else:
        # todo: only subscribe to inputs and outputs as needed
        dev = db.device(device)
        if dev:
            db.subscribe(dev, mapper.OBJ_ALL)

def new_map(args):
    srckeys, dstkey, props = args
    srcs = [find_sig(k) for k in srckeys]
    dst = find_sig(dstkey)
    if not (all(srcs) and dst): 
Example #5
0
    print networkInterfaces['active']
    server.send_command("active_network", networkInterfaces['active'])


def init_monitor():
    monitor.db.add_device_callback(on_device)
    monitor.db.add_signal_callback(on_signal)
    monitor.db.add_link_callback(on_link)
    monitor.db.add_connection_callback(on_connection)
    monitor.request_devices()
    monitor.request_links_by_src_device_name("/*")

init_monitor()

server.add_command_handler("all_devices",
                           lambda x: ("all_devices",
                                      list(monitor.db.all_devices())))

def sync_device(name, is_src):
    device = monitor.db.get_device_by_name(name)
    if not device:
        return
    sigs_reported = 0
    sigs_recorded = 0
    if is_src:
        sigs_reported = device["n_outputs"]
        sigs_recorded = sum(1 for _ in monitor.db.outputs_by_device_name(name))
    else:
        sigs_reported = device["n_inputs"]
        sigs_recorded = sum(1 for _ in monitor.db.inputs_by_device_name(name))
    if sigs_reported != sigs_recorded:
Example #6
0
    return fn, mapperstorage.serialise(monitor, arg['dev'])

def on_load(mapping_json):
    mapperstorage.deserialise(monitor, mapping_json)

def init_monitor():
    monitor.request_devices()
    monitor.db.add_device_callback(on_device)
    monitor.db.add_signal_callback(on_signal)
    monitor.db.add_link_callback(on_link)
    monitor.db.add_connection_callback(on_connection)

init_monitor()

server.add_command_handler("all_devices",
                           lambda x: ("all_devices",
                                      list(monitor.db.all_devices())))

server.add_command_handler("all_signals",
                           lambda x: ("all_signals",
                                      list(monitor.db.all_inputs())
                                      + list(monitor.db.all_outputs())))

server.add_command_handler("all_links",
                           lambda x: ("all_links",
                                      list(monitor.db.all_links())))

server.add_command_handler("all_connections",
                           lambda x: ("all_connections",
                                      list(monitor.db.all_connections())))
        db.add_device_callback(on_device)
        db.add_link_callback(on_link)
        db.add_signal_callback(on_signal)
        db.add_map_callback(on_map)
        initialized = True
    else:
        server.send_command("add_devices",
                            [dev_props(d) for d in db.devices()])
        server.send_command("add_links", [link_props(l) for l in db.links()])
        server.send_command("add_signals",
                            [sig_props(s) for s in db.signals()])
        server.send_command("add_maps", [map_props(m) for m in db.maps()])


server.add_command_handler(
    "add_devices", lambda x:
    ("add_devices", [dev_props(d) for d in db.devices()]))


def subscribe(name):
    if name == "all_devices":
        db.subscribe(mapper.OBJ_DEVICES | mapper.OBJ_LINKS)
    else:
        # todo: only subscribe to inputs and outputs as needed
        dev = db.device(name)
        if dev:
            db.subscribe(dev, mapper.OBJ_ALL)


def new_map(args):
    srckeys, dstkey, props = args
Example #8
0
    # (re)subscribe: currently this does nothing but could refresh graph database?
    g.subscribe(None, mpr.Type.OBJECT, -1)

    for d in g.devices():
        server.send_command("add_devices", [dev_props(d)])
    for s in g.signals():
        server.send_command("add_signals", [sig_props(s)])
    for m in g.maps():
        server.send_command("add_maps", [map_props(m)])


init_graph(0)

server.add_command_handler(
    "add_devices", lambda x:
    ("add_devices", [dev_props(d) for d in g.devices()]))


def subscribe(device):
    if device == 'all_devices':
        g.subscribe(None, mpr.Type.DEVICE, -1)
    else:
        # todo: only subscribe to inputs and outputs as needed
        dev = g.devices().filter(mpr.Property.NAME, device)
        if dev:
            g.subscribe(dev.next(), mpr.Type.OBJECT, -1)
        else:
            print("no device matching name", device)