def init_connection(self): # initiate logging # zenoh.init_logger() L.warning("[ZENOH] Openning session...") self.z_session = Zenoh(self.conf) L.warning("[ZENOH] Create New workspace...") self.workspace = self.z_session.workspace()
def test_create_delete_storage(self): y = Zenoh.login(ZSERVER) admin = y.admin() stid = '123' res1 = admin.add_storage(stid, {'selector': '/myzenoh/**'}) time.sleep(1) # TODO remove res2 = admin.remove_storage(stid) y.logout() self.assertTrue(res1) self.assertTrue(res2)
def test_create_delete_workspace(self): y = Zenoh.login(ZSERVER) admin = y.admin() stid = '123' admin.add_storage(stid, {'selector': '/myzenoh/**'}) time.sleep(1) # TODO remove workspace = y.workspace('/myzenoh') self.assertEqual(workspace.path, Path('/myzenoh')) admin.remove_storage(stid) y.logout()
def test_put_get_remove(self): y = Zenoh.login(ZSERVER) admin = y.admin() stid = '123' admin.add_storage(stid, {'selector': '/myzenoh/**'}) time.sleep(1) # TODO remove workspace = y.workspace('/myzenoh') d = Value('hello!', encoding=Encoding.STRING) self.assertTrue(workspace.put('/myzenoh/key1', d)) data = workspace.get('/myzenoh/key1')[0] self.assertEqual(data.get_value(), d) self.assertEqual(data.get_path(), '/myzenoh/key1') self.assertTrue(workspace.remove('/myzenoh/key1')) self.assertEqual(workspace.get('/myzenoh/key1'), []) admin.remove_storage(stid) y.logout()
def test__big_put_get_remove(self): y = Zenoh.login('127.0.0.1') admin = y.admin() stid = '123' admin.add_storage(stid, {'selector': '/myzenoh/**'}) time.sleep(1) # TODO remove workspace = y.workspace('/myzenoh') for i in range(0, 100): v = 'x{}'.format(i) * 512 workspace.put('/myzenoh/big/{}'.format(i), Value(v, encoding=Encoding.STRING)) dataset = workspace.get('/myzenoh/big/**') self.assertEqual(len(dataset), 100) admin.remove_storage(stid) y.logout()
def test_eval(self): y = Zenoh.login(ZSERVER) admin = y.admin() stid = '123' admin.add_storage(stid, {'selector': '/myzenoh/**'}) time.sleep(1) # TODO remove workspace = y.workspace('/myzenoh') def cb(path, args): return Value('{} World!'.format(args['hello']), encoding=Encoding.STRING) workspace.register_eval('/myzenoh/key1', cb) dataset = workspace.get('/myzenoh/key1?(hello=mondo)') self.assertEqual(dataset[0].get_path(), '/myzenoh/key1') self.assertEqual(dataset[0].get_value(), Value('mondo World!', encoding=Encoding.STRING)) workspace.unregister_eval('/myzenoh/key1') admin.remove_storage(stid) y.logout()
def test_sub_remove(self): y = Zenoh.login(ZSERVER) admin = y.admin() stid = '123' admin.add_storage(stid, {'selector': '/myzenoh/**'}) time.sleep(1) # TODO remove workspace = y.workspace('/myzenoh') local_var = mvar.MVar() workspace.put('/myzenoh/key1', Value('123', encoding=Encoding.STRING)) def cb(kvs): self.assertEqual(kvs[0].get_path(), '/myzenoh/key1') self.assertEqual(kvs[0].get_kind(), ChangeKind.REMOVE) local_var.put(kvs) sid = workspace.subscribe('/myzenoh/key1', cb) workspace.remove('/myzenoh/key1') self.assertTrue(workspace.unsubscribe(sid)) admin.remove_storage(stid) y.logout()
def login(locator, properties=None): ''' Establish a session with the Yaks instance reachable via provided Zenoh locator. If the provided locator is ``None``, :func:`login` will perform some dynamic discovery and try to establish the session automatically. When not ``None``, the locator must have the format: ``tcp/<ip>:<port>``. :param locator: a Zenoh locator or ``None``. :param properties: the Properties to be used for this session (e.g. "user", "password", ...). Can be ``None``. :returns: a Yaks object. ''' zprops = {} if properties is None else { zenoh.Z_USER_KEY if k == "user" else zenoh.Z_PASSWORD_KEY: val for k, val in properties.items() if k == "user" or key == "password" } return Yaks(Zenoh.open(locator, zprops))
def main(address, selector): # client configuration conf = { 'mode': 'client', 'peer': '{}'.format(address), } print("Openning session...") zenoh = Zenoh(conf) print("New workspace...") workspace = zenoh.workspace() # getting the data from zenoh, it can come from a storage or an eval print("Get Data from '{}'...".format(selector)) output_data = [] for data in workspace.get(selector): _, _, m, s, n = data.path.split('/') m = int(m) s = int(s) n = int(n) output_entry = { 'm': m, 's': s, 'n': n, 'value': data.value.get_content(), 'timestamp': data.timestamp } output_data.append(output_entry) sorted_output_data = sorted(output_data, key=lambda k: k['n']) for data in sorted_output_data: print(data) zenoh.close()
# http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 # which is available at https://www.apache.org/licenses/LICENSE-2.0. # # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 # # Contributors: # ADLINK zenoh team, <*****@*****.**> import sys from zenoh import Zenoh, Selector, Path, Workspace, Encoding, Value selector = '/demo/example/**' if len(sys.argv) > 1: selector = sys.argv[1] locator = None if len(sys.argv) > 2: locator = sys.argv[2] print('Login to Zenoh (locator={})...'.format(locator)) z = Zenoh.login(locator) print('Use Workspace on "/"') w = z.workspace('/') print('Get from {}'.format(selector)) for data in w.get(selector): print(' {} : {}'.format(data.path, data.value)) z.logout()
from zenoh import Zenoh if __name__ == "__main__": z = Zenoh({}) w = z.workspace('/') results = w.get('/myhome/kitcken/temp') key, value = results[0].path, results[0].value print(' {} : {}'.format(key, value))
def main(stdscr): # --- Command line argument parsing --- --- --- --- --- --- parser = argparse.ArgumentParser(prog='zn_sub', description='zenoh-net sub example') parser.add_argument('--mode', '-m', dest='mode', choices=['peer', 'client'], type=str, help='The zenoh session mode.') parser.add_argument( '--peer', '-e', dest='peer', metavar='LOCATOR', action='append', type=str, help='Peer locators used to initiate the zenoh session.') parser.add_argument('--listener', '-l', dest='listener', metavar='LOCATOR', action='append', type=str, help='Locators to listen on.') parser.add_argument('--config', '-c', dest='config', metavar='FILE', type=str, help='A configuration file.') parser.add_argument('--cmd_vel', dest='cmd_vel', default='/rt/turtle1/cmd_vel', type=str, help='The "cmd_vel" ROS2 topic.') parser.add_argument('--rosout', dest='rosout', default='/rt/rosout', type=str, help='The "rosout" ROS2 topic.') parser.add_argument('--angular_scale', '-a', dest='angular_scale', default='2.0', type=float, help='The angular scale.') parser.add_argument('--linear_scale', '-x', dest='linear_scale', default='2.0', type=float, help='The linear scale.') args = parser.parse_args() conf = zenoh.config_from_file( args.config) if args.config is not None else {} if args.mode is not None: conf["mode"] = args.mode if args.peer is not None: conf["peer"] = ",".join(args.peer) if args.listener is not None: conf["listener"] = ",".join(args.listener) cmd_vel = args.cmd_vel rosout = args.rosout angular_scale = args.angular_scale linear_scale = args.linear_scale # zenoh-net code --- --- --- --- --- --- --- --- --- --- --- # initiate logging zenoh.init_logger() print("Openning session...") z = Zenoh(conf) workspace = z.workspace() def rosout_callback(change): if change.value is not None: log = Log.deserialize(change.value.get_content()) print('[{}.{}] [{}]: {}'.format(log.stamp.sec, log.stamp.nanosec, log.name, log.msg)) print("Subscriber on '{}'...".format(rosout)) sub = workspace.subscribe(rosout, rosout_callback) def pub_twist(linear, angular): print("Pub twist: {} - {}".format(linear, angular)) t = Twist(linear=Vector3(x=linear, y=0.0, z=0.0), angular=Vector3(x=0.0, y=0.0, z=angular)) workspace.put(cmd_vel, t.serialize()) while True: c = stdscr.getch() if c == curses.KEY_UP: pub_twist(1.0 * linear_scale, 0.0) elif c == curses.KEY_DOWN: pub_twist(-1.0 * linear_scale, 0.0) elif c == curses.KEY_LEFT: pub_twist(0.0, 1.0 * angular_scale) elif c == curses.KEY_RIGHT: pub_twist(0.0, -1.0 * angular_scale) elif c == 27 or c == ord('q'): break sub.close() zenoh.close()
parser.add_argument('--selector', '-s', dest='selector', default='/demo/example/**', type=str, help='The selection of resources to get.') args = parser.parse_args() conf = { "mode": args.mode } if args.peer is not None: conf["peer"] = ",".join(args.peer) if args.listener is not None: conf["listener"] = ",".join(args.listener) selector = args.selector # zenoh-net code --- --- --- --- --- --- --- --- --- --- --- # initiate logging zenoh.init_logger() print("Openning session...") zenoh = Zenoh(conf) print("New workspace...") workspace = zenoh.workspace() print("Get Data from '{}'...".format(selector)) for data in workspace.get(selector): print(' {} : {} (encoding: {} , timestamp: {})'.format( data.path, data.value.get_content(), data.value.encoding_descr(), data.timestamp)) zenoh.close()
def test_create_close_api(self): y = Zenoh.login(ZSERVER) self.assertTrue(y.rt.running) y.logout() self.assertFalse(y.rt.running)
description='Produces float values') parser.add_argument('--path', '-p', dest='path', default='/zenoh/examples/native/float', type=str, help='the path representing the float resource') parser.add_argument( '--locator', '-l', dest='locator', default=None, type=str, help='The locator to be used to boostrap the zenoh session.' ' By default dynamic discovery is used') args = parser.parse_args() # zenoh code --- --- --- --- --- --- --- --- --- --- --- z = Zenoh.login(args.locator) w = z.workspace() while (True): v = input("Insert value (\'.\' to exit): ") if v != '.': w.put(args.path, float(v)) else: z.logout() break
if len(res) > 0 and res[0] == 'y': torch.save( global_model.state_dict(), 'global.pt' ) # be aware that this can overwrite a smarter model if this application is stopped and restarted else: global_model.load_state_dict(torch.load('global.pt')) else: torch.save( global_model.state_dict(), 'global.pt' ) # be aware that this can overwrite a smarter model if this application is stopped and restarted # initiate logging zenoh.init_logger() print("Opening session...") z = Zenoh(conf) print("New workspace...") workspace = z.workspace() # 0 - Put global model to a path where clients can get it print("Put global model in /federated/nodes/global") save_and_put_global_parameters(global_model.state_dict()) # 1 - Listen for notifications notification_selector = selector + '/notifications' print("Subscribed to '{}'...".format(notification_selector)) notification_subscriber = workspace.subscribe(notification_selector, notification_listener) print("Press q to stop...")
class ZenohNative(ServiceABC): """ A higher level API providing the same abstractions as the zenoh-net API in a simpler and more data-centric oriented manner as well as providing all the building blocks to create a distributed storage. The zenoh layer is aware of the data content and can apply content-based filtering and transcoding. (source: http://zenoh.io/docs/getting-started/key-concepts/) Available functionalities: [1] put : push live data to the matching subscribers and storages. (equivalent of zenoh-net write) [2] subscribe : subscriber to live data. (equivalent of zenoh-net subscribe) [3] get : get data from the matching storages and evals. (equivalent of zenoh-net query) [4] storage : the combination of a zenoh-net subscriber to listen for live data to store and a zenoh-net queryable to reply to matching get requests. [5] eval : an entity able to reply to get requests. Typically used to provide data on demand or build a RPC system. (equivalent of zenoh-net queryable) Implemented scenarios: 1. Zenoh SUBSCRIBER Sample input: listener=None, mode='peer', peer=None, selector='/demo2/**' 2. Zenoh PUT Sample input: listener=None, mode='peer', path='/demo2/example/test', peer=None, value='Hello World' 3. Zenoh GET Sample input: listener=None, mode='peer', peer=None, selector='/demo/example/**' """ class ZenohMode(Enum): PEER = "peer" CLIENT = "client" class SessionType(Enum): SUBSCRIBER = "SUBSCRIBER" PUT = "PUT" GET = "GET" def __init__(self, _listener=None, _mode="peer", _peer=None, _selector=None, _path=None, _session_type=None): super().__init__() self.listener = _listener # Locators to listen on. self.mode = _mode # The zenoh session mode. self.peer = _peer # Peer locators used to initiate the zenoh session. self.selector = _selector # The selection of resources to subscribe. self.path = _path # The name of the resource to put. self.session_type = self._get_session_type( _session_type) # Type of Zenoh connection # setup configuration self.conf = {"mode": self.mode} if self.peer is not None: self.conf["peer"] = self.peer if self.listener is not None: self.conf["listener"] = self.listener self.workspace = None self.z_session = None self.pub = None self.sub = None def _get_session_type(self, _type): if _type.upper() == self.SessionType.PUT.value: return self.SessionType.PUT.value elif _type.upper() == self.SessionType.SUBSCRIBER.value: return self.SessionType.SUBSCRIBER.value elif _type.upper() == self.SessionType.GET.value: return self.SessionType.GET.value else: return None def init_connection(self): # initiate logging # zenoh.init_logger() L.warning("[ZENOH] Openning session...") self.z_session = Zenoh(self.conf) L.warning("[ZENOH] Create New workspace...") self.workspace = self.z_session.workspace() def close_connection(self, _subscriber=None): self.z_session.close() L.warning("[ZENOH] `{}` session has been closed".format( self.session_type)) def register_subscriber(self, listener): L.warning("[ZENOH] Registering new consumer") self.sub = self.workspace.subscribe(self.selector, listener) def register_publisher(self): pass # nothing to do here def publish_data(self, val): L.warning("[ZENOH] Publish data") self.workspace.put(self.path, val)
if __name__ == "__main__": if len(sys.argv) < 5: print( "Usage <address of zenohd router> <rostopic> <rostopic hz> <replay secs>" ) address = sys.argv[1] rostopic = sys.argv[2] sample_rate = int(sys.argv[3]) duration = int(sys.argv[4]) conf = { 'mode': 'client', 'peer': '{}'.format(address), } print("Opening Zenoh session...") zenoh = Zenoh(conf) print( "Server connected to Zenoh router {}, publishing on rostopic {}, at rate {}" .format(address, rostopic, sample_rate)) # Zenoh workspace creation print("New Zenoh workspace...") workspace = zenoh.workspace(storage_path) app = create_app(workspace, rostopic, sample_rate, duration) app.register_blueprint(route_blueprint) app.run(host='0.0.0.0', port=5000, debug=True) # Shutting down Zenoh zenoh.close()
def faces_listener(change): # print('[DEBUG] Received face to recognize: {}'.format(change.path)) chunks = change.path.split('/') cam = chunks[-2] face = int(chunks[-1]) if cam not in cams: cams[cam] = {} cams[cam][face] = bytes(change.value.get_content()) print('[INFO] Open zenoh session...') zenoh.init_logger() z = Zenoh(conf) w = z.workspace() time.sleep(0.5) print('[INFO] Retrieve faces vectors...') for vector in w.get(args['prefix'] + '/vectors/**'): add_face_to_data(data, vector.path, vector.value.get_content()) print('[INFO] Start recognition...') sub1 = w.subscribe(args['prefix'] + '/vectors/**', update_face_data) sub2 = w.subscribe(args['prefix'] + '/faces/*/*', faces_listener) while True: for cam in list(cams): faces = cams[cam] for face in list(faces):