def _verify(self, xprt, job=None, clk=None, component_id=0,
job_id="job_id", app_id="app_id",
job_start="job_start", job_end="job_end"):
set_names = [s for s in [job, clk] if s]
dir_resp = ldms.LDMS_xprt_dir(xprt)
self.assertEqual(set(dir_resp), set(set_names))
if not clk:
return
# snapshots of jobset and clkset
if job:
jsnap = []
csnap = []
if job:
jobset = ldms.LDMS_xprt_lookup(xprt, job, 0)
clkset = ldms.LDMS_xprt_lookup(xprt, clk, 0)
for i in range(0, 3):
if i:
time.sleep(1) # skip the 1st sleep
clkset.update() # blocking-update
if job:
jobset.update() # blocking-update
jsnap.append(ldms_set_as_dict(jobset))
csnap.append(ldms_set_as_dict(clkset))
# verify component_id
comp_id_set = set( c["component_id"] for c in csnap )
self.assertEqual(set([component_id]), comp_id_set)
# verify clk["tv_sec"] updates
ts_set = set( c["tv_sec"] for c in csnap )
self.assertEqual(2, len(ts_set))
ts_list = list(ts_set)
ts_list.sort()
self.assertEqual(2, ts_list[1] - ts_list[0])
# check job update (if applicable)
if not job:
return
for c, j in zip(csnap, jsnap):
self.assertNotEqual(0, c["app_id"])
self.assertNotEqual(0, c["job_id"])
self.assertLessEqual(abs(c["job_id"] - j[job_id]), 1)
self.assertLessEqual(abs(c["app_id"] - j[app_id]), 1)
job_ids = list(set( c["job_id"] for c in csnap ))
job_ids.sort()
d = adiff(job_ids)
self.assertGreater(len(d), 0)
self.assertEqual(d, [1 for i in range(0,len(d))])
app_ids = list(set( c["app_id"] for c in csnap ))
app_ids.sort()
d = adiff(app_ids)
self.assertGreater(len(d), 0)
self.assertEqual(d, [1 for i in range(0,len(d))])
def test_01_verify(self):
"""Verify data in the storage"""
x = ldms.LDMS_xprt_new(self.XPRT)
rc = ldms.LDMS_xprt_connect_by_name(x, "localhost", self.SMP_PORT)
if rc:
log.error("rc: %d" % rc)
assert(rc == 0)
dlist = ldms.LDMS_xprt_dir(x)
_sets = []
log.info("Looking up sets")
self.assertEqual(len(dlist), 1)
s = ldms.LDMS_xprt_lookup(x, dlist[0], 0)
log.info("Collecting data from LDMS for comparison")
data = set()
for i in range(0, 10):
# update first
s.update()
l = ldms_set_as_tuple(s)
data.add(l)
time.sleep(1)
time.sleep(1) # to make sure that the last data point has been stored
log.info("Verifying...")
csv_data = LdmsCsv("test_store_csv/csv")
csv_data = set(csv_data)
self.assertLessEqual(data, csv_data)
def test_ls_owner(self):
xprt = ldms.LDMS_xprt_new_with_auth(self.XPRT, self.AUTH,
self.AUTH_OPT)
rc = ldms.LDMS_xprt_connect_by_name(xprt, "localhost", self.PORT)
self.assertEqual(rc, 0)
_set = ldms.LDMS_xprt_lookup(xprt, "smp/meminfo", 0)
self.assertIsNotNone(_set)
def test_01_verify(self):
"""Verify data in the storage"""
x = ldms.LDMS_xprt_new(self.XPRT)
rc = ldms.LDMS_xprt_connect_by_name(x, "localhost", self.SMP_PORT)
if rc:
log.error("rc: %d" % rc)
assert (rc == 0)
dlist = ldms.LDMS_xprt_dir(x)
self.assertEqual(len(dlist), 1)
log.info("Looking up sets")
_set = ldms.LDMS_xprt_lookup(x, dlist[0], 0)
assert (_set)
log.info("Collecting data from LDMS for comparison")
data = []
for i in range(0, 10):
# update first
_set.update()
d = ldms_set_as_dict(_set)
data.append(d)
time.sleep(1)
time.sleep(1) # to make sure that the last data point has been stored
log.info("Verifying...")
keys = data[0].keys()
for d in data:
self.assertEqual(set(keys), set(d.keys()))
for d in self.amqp_sink.data:
self.assertEqual(set(keys), set(d.keys()))
data = set(tuple_from_dict(d, keys) for d in data)
amqp_data = set(tuple_from_dict(d, keys) for d in self.amqp_sink.data)
self.assertGreater(len(data), 0)
self.assertLessEqual(data, amqp_data)
def test_01_verify(self):
"""Verify data in the storage"""
x = ldms.LDMS_xprt_new(self.XPRT)
rc = ldms.LDMS_xprt_connect_by_name(x, "localhost", self.SMP_PORT)
if rc:
log.error("rc: %d" % rc)
assert (rc == 0)
dlist = ldms.LDMS_xprt_dir(x)
_sets = []
log.info("Looking up sets")
for name in dlist:
s = ldms.LDMS_xprt_lookup(x, name, 0)
assert (s)
_sets.append(s)
log.info("Collecting data from LDMS for comparison")
data = set()
for i in range(0, 10):
# update first
for s in _sets:
s.update()
for s in _sets:
l = ldms_set_as_tuple(s, with_ts=True)
data.add(l)
dlen = len(l)
time.sleep(1)
time.sleep(1) # to make sure that the last data point has been stored
log.info("Verifying...")
rf = ResultFile(self.STORE_PATH)
# Verify the computed results
rf.verify()
# Now, verify that the stored raw is good
names = [s.metric_name_get(k) for k, v in s.iter_items()]
names = ["#Time"] + names
csv_data = set(r.as_tuple(names) for r in rf)
self.assertLessEqual(data, csv_data)
def test_lookup_owner(self):
xprt = ldms.LDMS_xprt_new_with_auth(self.XPRT, self.AUTH,
self.AUTH_OPT)
rc = ldms.LDMS_xprt_connect_by_name(xprt, "localhost", self.PORT)
if rc:
raise RuntimeError("LDMS connect failed: %d" % rc)
for _name, _perm in zip(self.SETS, self.PERMS):
_set = ldms.LDMS_xprt_lookup(xprt, _name,
ldms.LDMS_LOOKUP_BY_INSTANCE)
self.assertIsNotNone(_set)
ldms.ldms_xprt_close(xprt)
def __init__(self, port, xprt="sock", hostname="localhost"):
self.xprt = ldms.LDMS_xprt_new(xprt)
rc = ldms.LDMS_xprt_connect_by_name(self.xprt, hostname, port)
assert (rc == 0)
self.sets = []
self._dict = {}
_dirs = ldms.LDMS_xprt_dir(self.xprt)
for d in _dirs:
s = ldms.LDMS_xprt_lookup(self.xprt, d,
ldms.LDMS_LOOKUP_BY_INSTANCE)
self.sets.append(s)
self._dict[d] = s
def test_tsampler(self):
time.sleep(1) # wait for sampler to populate the set
x = ldms.LDMS_xprt_new(self.XPRT)
rc = ldms.LDMS_xprt_connect_by_name(x, "localhost", self.SMP_PORT)
self.assertEqual(rc, 0)
s = ldms.LDMS_xprt_lookup(x, "smp/hfclock", 0)
s.update()
clk = s["clock"]
DEBUG.clk = clk
tmp = s["clock_timeval"]
clk_tv = [ tmp[2*i] + tmp[2*i+1]*1e-6 for i in range(0, len(tmp)/2) ]
DEBUG.clk_tv = clk_tv
for (a, b) in zip(clk, clk_tv):
self.assertGreater(a, 0)
self.assertLess(abs(a-b), 0.001)
def test_lookup_other(self):
auth_opt = {"uid": "5555", "gid": "5555"}
xprt = ldms.LDMS_xprt_new_with_auth(self.XPRT, self.AUTH, auth_opt)
rc = ldms.LDMS_xprt_connect_by_name(xprt, "localhost", self.PORT)
if rc:
raise RuntimeError("LDMS connect failed: %d" % rc)
for _name, _perm in zip(self.SETS, self.PERMS):
_set = ldms.LDMS_xprt_lookup(xprt, _name,
ldms.LDMS_LOOKUP_BY_INSTANCE)
DEBUG.name = _name
DEBUG.perm = _perm
DEBUG.set = _set
if _perm[3] != "0":
self.assertIsNotNone(_set)
else:
self.assertIsNone(_set)
ldms.ldms_xprt_close(xprt)
def test_000(self):
"""Verify that the agg collects from both smp0 and smp1"""
x = ldms.LDMS_xprt_new(self.XPRT)
rc = ldms.LDMS_xprt_connect_by_name(x, "localhost",
str(self.AGG_PORT_BASE))
self.assertEqual(rc, 0)
dirs = ldms.LDMS_xprt_dir(x)
self.assertEqual(
set(dirs),
set(["smp%d/meminfo" % i for i in range(0, self.SMP_NUM)]))
sets = {d: ldms.LDMS_xprt_lookup(x, d, 0) for d in dirs}
for k, s in sets.iteritems():
s.update()
grp = re.match(r"smp(\d+)/meminfo", k).groups()
comp_id = int(grp[0])
self.assertEqual(s['component_id'], comp_id)
ts = s.ts_get()
self.assertGreater(ts.sec, 0)
pass
def test_update(self):
x = ldms.LDMS_xprt_new(self.XPRT)
rc = ldms.LDMS_xprt_connect_by_name(x, "localhost", self.SMP_PORT)
self.assertEqual(rc, 0)
s = ldms.LDMS_xprt_lookup(x, self.SET_NAME, 0)
time.sleep(self.UPD_INT * uS)
log.info("First update ...")
ts_list0 = self.__update(s)
time.sleep(self.UPD_INT * uS)
log.info("Second update ...")
ts_list1 = self.__update(s)
ts_list = ts_list0 + ts_list1
DEBUG.ts_list = ts_list
DEBUG.ts_list0 = ts_list0
DEBUG.ts_list1 = ts_list1
log.info("Verifying data ...")
for a, b in zip(ts_list, ts_list[1:]):
DEBUG.a = a
DEBUG.b = b
self.assertLess(a, b)
d = b - a
self.assertLess(abs(d - self.SMP_INT * uS), 0.001)
log.info("%d data timestamps verified" % len(ts_list))
pass
