def __init__(self, host, port, xprt, max_recv_len=MAX_RECV_LEN, auth=None, auth_opt=None): try: from ovis_ldms import ldms except: raise ImportError( "Failed to import ovis_ldms.ldms. " "Please make sure that ldms is built with --enable-swig") else: self.ldms_module = ldms if xprt is None: raise ArgumentError("xprt is required to create an LDMS transport") self.socket = None self.host = host self.port = port self.xprt = xprt self.state = "INIT" self.ldms = None self.ldms = ldms.Xprt(name=self.xprt, auth=auth, auth_opts=auth_opt) if not self.ldms: raise ValueError("Failed to create LDMS transport") self.state = "NEW" self.max_recv_len = self.ldms.msg_max self.ldms.connect(host=self.host, port=self.port) self.type = "inband" self.state = "CONNECTED"
def __init__(self, xprt, host, port, auth=None, auth_opt=None): """Create a communicator interface with an LDMS Daemon (LDMSD) Parameters: - The transport name: 'sock', 'rdma', 'ugni', or 'fabric' - The host name - The port number Keyword Parameters: auth - The authentication plugin name auth_opt - Options (if any) to pass to the authentication plugin """ self.INIT = Communicator.INIT self.CONNECTED = Communicator.CONNECTED self.CLOSED = Communicator.CLOSED self.host = host self.port = port self.xprt = xprt self.state = self.INIT self.auth = auth self.auth_opt = auth_opt self.ldms = ldms.Xprt(name=self.xprt, auth=auth, auth_opts=auth_opt) if not self.ldms: raise ValueError(f"Failed to create LDMS transport " f"{xprt}, {host}, {port}, {auth}, {auth_opt}") self.max_recv_len = self.ldms.msg_max
def __init__(self, name, level): _host, _port = name.rsplit("-", 1) self.name = name self.host = _host self.port = int(_port) self.level = level self.xprt = ldms.Xprt(name = XPRT)
def do_agg(samp_port, agg_port, *args, **kwargs): # agg-1 routine D.x = x = ldms.Xprt() x.connect(host="localhost", port = samp_port) agg_change_base_value(x, 1) # initial time.sleep(1) D.dlist = dlist = x.dir() # lookup sets = do_lookup(x) grps = [ s for s in sets if type(s) == ldms.Grp ] ASSERT(len(grps) == 1, "expect 1 group") D.grp = grp = grps[0] INFO("==== 1st grp update ====") do_update(grp, [ grp ]) # The first update will update only grp. # This is because grp is inconsistent. INFO("==== 2nd grp update ====") do_update(grp, D.sets) # This update will update all members. verify_sets(sets) # Change the BASE_VALUE and update INFO("==== change base value, then grp update ====") agg_change_base_value(x, 10) time.sleep(2) do_update(grp, D.sets) verify_sets(sets) do_agg_grp(x) do_remote_member_change()
def reconnect(self): if self.ldms: self.close() self.ldms = ldms.Xprt(name=self.xprt, auth=self.auth, auth_opts=self.auth_opt) if self.ldms is None: return False self.max_recv_len = self.ldms.msg_max return self.connect()
from ovis_ldms import ldms from record_common import * LOG_FMT = "%(asctime)s.%(msecs)03d %(levelname)s %(module)s %(message)s" logging.basicConfig(datefmt="%F-%T", format=LOG_FMT, level=logging.INFO) log = logging.getLogger() ldms.init(16*1024*1024) set1 = add_set("node-1/set1") set3_p = add_set("node-1/set3_p", array_card=SET_BUFFER) set3_c = add_set("node-1/set3_c", array_card=SET_BUFFER) set3_c.data_copy_set(1) # turn on data copy update_set(set1, 1) update_set(set3_p, 2) update_set(set3_c, 3) verify_set(set1) verify_set(set3_p) verify_set(set3_c) x = ldms.Xprt(name="sock") def listen_cb(ep, ev, arg): log.debug("{}: {}".format(ev.type.name, ep)) G.ep = ep G.ev = ev rc = x.listen(host="0.0.0.0", port=412, cb=listen_cb)
import set_test ldms.init(16*1024*1024) def on_SIGTERM(*args): os._exit(0) signal.signal(signal.SIGTERM, on_SIGTERM) # Request SIGHUP our process when parent exited libc = ctypes.CDLL(None) # prctl(PR_SET_PDEATHSIG, SIGHUP) libc.prctl(1, 1) # create the transport lx = ldms.Xprt() # listen lx.listen(port=10001) # create and publish set set_name = "sync/" + set_test.SET_NAME lset = ldms.Set(name=set_name, schema=set_test.SCHEMA) lset.producer_name = "sync" lset.publish() # populate set data set_test.populate_data(lset) while True: x = lx.accept()
psr.add_argument("-x", "--xprt", default="sock", help="Transport type (default: sock)") psr.add_argument("-p", "--port", default="20001", help="Port to listen or to connect (default: 20001)") psr.add_argument("-h", "--host", default=socket.gethostname(), help="Port to listen or to connect (default: ${HOSTNAME})") psr.add_argument("-m", "--mem", type=int, default=16*1024*1024, help="Memory allocation (default: 16000000)") psr.add_argument("-i", "--interval", default=1.0, type=float, help="Interval (1.0 sec)") psr.add_argument("-?", "--help", action="help", help="Show help message") g = psr.parse_args() ldms.init(g.mem) g.x = ldms.Xprt(name=g.xprt) g.sets = dict() g.cond = thread.Condition() g.num_lookups = 0 g.num_updates = 0 g.num_sets = 0 g.done_dir = False def interval_block(interval, offset): t0 = time.time() t1 = (t0 + interval)//interval*interval + offset dt = t1 - t0 time.sleep(dt) def client_lookup_cb(x, status, more, lset, arg): g.sets[lset.name] = lset
#!/usr/bin/python3 -i import os import sys from ovis_ldms import ldms from record_common import * ldms.init(16 * 1024 * 1024) x0 = ldms.Xprt(name="sock") x0.connect(host="localhost", port=411) x1 = ldms.Xprt(name="sock") x1.connect(host="localhost", port=412) d0 = x0.dir() d1 = x1.dir() record_sampler = x0.lookup(d0[0].name) set1 = x1.lookup("node-1/set1") set3_p = x1.lookup("node-1/set3_p") set3_c = x1.lookup("node-1/set3_c") record_sampler.update() set1.update() set3_p.update() set3_c.update() verify_set(record_sampler) verify_set(set1)
import time import logging import json import threading from set_array_common import G, set_dict, print_set, jprint, PORT, dict_list from ovis_ldms import ldms LOG_FMT = "%(asctime)s.%(msecs)03d %(levelname)s %(module)s %(message)s" logging.basicConfig(datefmt="%F-%T", format=LOG_FMT, level=logging.INFO) log = logging.getLogger() ldms.init(16 * 1024 * 1024) x = ldms.Xprt("sock") x.connect(host="localhost", port=PORT) dirs = x.dir() names = [d.name for d in dirs] assert (set(names) == set(["set1", "set3"])) s1 = x.lookup("set1") s3 = x.lookup("set3") update_rec = list() sem = threading.Semaphore(1) def update_cb(s, fl, a): #print("flag:", fl) _set = set_dict(s)
def connect(self): if self._conn: self._conn.close() self._conn = ldms.Xprt(self.xprt) self._conn.connect(host=self.host, port=self.port)
if D.ev.type == ldms.EVENT_CONNECTED: check(" xprt_cb({}) CONNECTED arg check".format(xprt), arg == 10) D.connected = 1 xprt.dir(cb=dir_cb, cb_arg=arg + 10) elif D.ev.type == ldms.EVENT_DISCONNECTED: check(" xprt_cb({}) DISCONNECTED arg check".format(xprt), arg == 10) D.connected = 0 async_cond.acquire() async_cond.notify() async_cond.release() elif D.ev.type == ldms.EVENT_RECV: global recv_queue recv_queue.put(ev.data) x = ldms.Xprt() x.connect(host="localhost", port=10002, cb=xprt_cb, cb_arg=10) t0 = time.time() DT = 3.0 while D.updated < 2 and (time.time() - t0 < DT): async_cond.acquire() async_cond.wait(timeout=1.0) check(" async update completed", D.updated == 2) check(" dir result check", set(async_dlist) == \ set(["async/"+SET_NAME, "sync/"+SET_NAME])) check(" schema name check", set(s.schema_name for s in async_slist) == \ set([ 'simple' ])) for s in async_slist: check(" {} data check".format(s.name), s.as_dict() == EXPECTED_DATA) check(" {} units check".format(s.name), [s.units(i) for i in range(0, len(s))] == UNITS)
def do_listen(port): lx = ldms.Xprt() lx.listen(port=port, cb=passive_xprt_cb, cb_arg=lx)