def testAddUpdateChannelsWithProperties(self):
'''
This is to check that existing properties of channels are not affected.
'''
unaffectedProperty = Property('unaffectedProperty', self.owner, 'unchanged')
# create default client
client = ChannelFinderClient(BaseURL=self.baseURL, username=self.username, password=self.password)
client.set(property=unaffectedProperty)
# add new pv's
t1 = str(time())
hostName1 = 'update-test-hostname' + t1
iocName1 = 'update-test-iocName' + t1
# New Channels added
client = ChannelFinderClient(BaseURL=self.baseURL, username=self.username, password=self.password);
client.set(channel=Channel('cf-update-pv1', 'cf-update', properties=[unaffectedProperty]))
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName1, \
iocName1, \
owner=self.owner, \
time=t1, \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(property=[('hostName', hostName1), ('iocName', iocName1), ('time', t1)])
self.assertTrue(len(channels) == 2, 'failed to create the channels with appropriate properties')
channels = client.find(name='cf-update-pv1')
self.assertTrue(len(channels) == 1)
self.assertTrue(len(channels[0].Properties) == 5)
# Cleanup
client.delete(channelName='cf-update-pv1')
client.delete(channelName='cf-update-pv2')
client.delete(propertyName=unaffectedProperty.Name)
def testAddUpdateChannels(self):
# Check the method finds the error conditions and raises exceptions
self.assertRaises(Exception, updateChannelFinder, [[], None, None])
self.assertRaises(Exception, updateChannelFinder,
[[], None, 'iocname'])
self.assertRaises(Exception, updateChannelFinder,
[[], 'hostName', None])
# create default client
client = ChannelFinderClient()
# add new pv's
t1 = str(time())
hostName1 = 'update-test-hostname' + t1
iocName1 = 'update-test-iocName' + t1
channels = client.find(property=[('hostName',
hostName1), ('iocName', iocName1)])
self.assertTrue(channels == None or len(channels) == 0,
'channels already present')
# New Channels added
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName1, \
iocName1, \
owner=self.owner, \
time=t1, \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(property=[('hostName',
hostName1), ('iocName',
iocName1), ('time',
t1)])
self.assertTrue(
len(channels) == 2,
'failed to create the channels with appropriate properties')
t2 = str(time())
hostName2 = 'update-test-hostname' + t2
iocName2 = 'update-test-iocName' + t2
# Existing channels are updated
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName2, \
iocName2, \
owner=self.owner, \
time=t2, \
service=self.baseURL , \
username=self.username, \
password=self.password)
# no channels should have the old proerty values
self.assertTrue(not client.find(property=[('hostName', hostName1), ('iocName', iocName1), ('time', t1)]), \
'failed to update the channels with appropriate properties, old values found')
# channels should be updated to the new values
self.assertTrue(len(client.find(property=[('hostName', hostName2), ('iocName', iocName2), ('time', t2)])) == 2, \
'failed to update the channels with appropriate properties')
# Cleanup
client = ChannelFinderClient(BaseURL=self.baseURL,
username=self.username,
password=self.password)
client.delete(channelName='cf-update-pv1')
client.delete(channelName='cf-update-pv2')
pass
def _downloadCfs(self, cfsurl, **kwargs):
"""Get daya from channel finder web service
:param cfsurl:
:param kwargs:
:return:
"""
keep_prpts = kwargs.pop('keep', None)
converter = kwargs.pop('converter', {})
from channelfinder import ChannelFinderClient
cf = ChannelFinderClient(BaseURL = cfsurl)
if len(kwargs) == 0:
chs = cf.find(name='*')
else:
#print kwargs
chs = cf.find(**kwargs)
if not chs:
return
if keep_prpts is None:
# use all possible property names
keep_prpts = [p.Name for p in cf.getAllProperties()]
#print "# include properties", properties
for ch in chs:
# keep only known properties
prptdict = ch.getProperties()
# prpts is known part from prptdict, otherwise empty dict
if prptdict is not None:
prpts = dict([v for v in prptdict.iteritems()])
# convert the data type
else:
prpts = None
# the empty tags could be None
if self.use_unicode:
self.results.append([unicode(ch.Name),
dict([(unicode(k), unicode(v))
for k,v in prpts.iteritems()]),
[unicode(v) for v in ch.getTags()]])
else:
self.results.append([ch.Name.encode('ascii'),
dict([(k.encode('ascii'), v.encode('ascii'))
for k,v in prpts.iteritems()]),
[v.encode('ascii') for v in ch.getTags()]])
if self.results[-1][1]:
for k in converter:
self.results[-1][1][k] = converter[k](prpts[k])
# warn if hostName or iocName does not present
if self.host_name not in self.results[-1][1]:
_logger.warn("no 'hostName' for {0}".format(self.results[-1]))
if self.ioc_name not in self.results[-1][1]:
_logger.warn("no 'iocName' for {0}".format(self.results[-1]))
del prptdict
def testAddUpdateChannels(self):
# Check the method finds the error conditions and raises exceptions
self.assertRaises(Exception, updateChannelFinder, [[], None, None])
self.assertRaises(Exception, updateChannelFinder, [[], None, 'iocname'])
self.assertRaises(Exception, updateChannelFinder, [[], 'hostName', None])
# create default client
client = ChannelFinderClient()
# add new pv's
t1 = str(time())
hostName1 = 'update-test-hostname' + t1
iocName1 = 'update-test-iocName' + t1
channels = client.find(property=[('hostName', hostName1), ('iocName', iocName1)])
self.assertTrue(channels == None or len(channels) == 0, 'channels already present')
# New Channels added
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName1, \
iocName1, \
owner=self.owner, \
time=t1, \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(property=[('hostName', hostName1), ('iocName', iocName1), ('time', t1)])
self.assertTrue(len(channels) == 2, 'failed to create the channels with appropriate properties')
t2 = str(time())
hostName2 = 'update-test-hostname' + t2
iocName2 = 'update-test-iocName' + t2
# Existing channels are updated
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName2, \
iocName2, \
owner=self.owner, \
time=t2, \
service=self.baseURL , \
username=self.username, \
password=self.password)
# no channels should have the old proerty values
self.assertTrue(client.find(property=[('hostName', hostName1), ('iocName', iocName1), ('time', t1)]) == None, \
'failed to update the channels with appropriate properties, old values found')
# channels should be updated to the new values
self.assertTrue(len(client.find(property=[('hostName', hostName2), ('iocName', iocName2), ('time', t2)])) == 2, \
'failed to update the channels with appropriate properties')
# Cleanup
client = ChannelFinderClient(BaseURL=self.baseURL, username=self.username, password=self.password)
client.delete(channelName='cf-update-pv1')
client.delete(channelName='cf-update-pv2')
pass
def simple_test():
cf = ChannelFinderClient(**cfinput)
#cf.set(property=Property('test-prop1', 'lyyang', 'v1'))
#cf.set(property=Property('test-prop2', 'cf-asd', 'v2'))
#cf.set(property=Property('test-prop3', 'lyyang'))
#cf.set(property=Property('test-prop4', 'lyyang'))
#cf.delete(propertyName='test-prop1')
#cf.delete(propertyName='test-prop3')
pvname1='SR:C00-BI:G00{DCCT:00}CUR-RB'
pvname2='SR:C00-Glb:G00{CHROM:00}RB-X'
pvname3='SR:C00-Glb:G00{CHROM:00}RB-Y'
cf.update(property=Property('test-prop2', 'cf-asd', 'v1'),
channelNames=[pvname1, pvname2, pvname3])
#chs = cf.find(property=[('test-prop2', '*')])
#if chs is not None:
# for ch in chs:
# print ch.Name
# for p in ch.Properties:
# print " ", p.Name,"=",p.Value, p.Owner, ", "
# print "/"
cf.delete(property=Property('test-prop2', 'cf-asd', 'v1'),
channelNames=[pvname2, pvname3])
chs = cf.find(property=[('test-prop2', '*')])
if chs is not None:
for ch in chs:
print ch.Name,
for p in ch.Properties:
print p.Name,"=",p.Value,", ",
print " /"
def simple_test():
cf = ChannelFinderClient(**cfinput)
#cf.set(property=Property('test-prop1', 'lyyang', 'v1'))
#cf.set(property=Property('test-prop2', 'cf-asd', 'v2'))
#cf.set(property=Property('test-prop3', 'lyyang'))
#cf.set(property=Property('test-prop4', 'lyyang'))
#cf.delete(propertyName='test-prop1')
#cf.delete(propertyName='test-prop3')
pvname1 = 'SR:C00-BI:G00{DCCT:00}CUR-RB'
pvname2 = 'SR:C00-Glb:G00{CHROM:00}RB-X'
pvname3 = 'SR:C00-Glb:G00{CHROM:00}RB-Y'
cf.update(property=Property('test-prop2', 'cf-asd', 'v1'),
channelNames=[pvname1, pvname2, pvname3])
#chs = cf.find(property=[('test-prop2', '*')])
#if chs is not None:
# for ch in chs:
# print ch.Name
# for p in ch.Properties:
# print " ", p.Name,"=",p.Value, p.Owner, ", "
# print "/"
cf.delete(property=Property('test-prop2', 'cf-asd', 'v1'),
channelNames=[pvname2, pvname3])
chs = cf.find(property=[('test-prop2', '*')])
if chs is not None:
for ch in chs:
print ch.Name,
for p in ch.Properties:
print p.Name, "=", p.Value, ", ",
print " /"
def init_cor(elems, url, patl, fname):
cf = ChannelFinderClient(BaseURL=url)
f = open(fname, "w")
for pvpat, hdl, name, idx, etp, fld in patl:
chs = cf.find(name=pvpat, property=[("hostName", "*"),
("iocName","*")])
for ch in chs:
pv = ch.Name
g = re.match(r"SR:(C[0-9][0-9]?)-MG{PS:([A-Z]+[0-9]+)([AB]?)}.*",
ch.Name)
if not g:
raise RuntimeError("unknown PV: '{0}'".format(ch.Name))
cell, fam = g.group(1), g.group(2)
matched = []
for e in elems:
if e[6] != cell: continue
if e[9].find(fam) < 0: continue
if g.group(3) and e[8] != g.group(3): continue
matched.append(e)
logging.info("found {0} COR records for '{1}', cell={2}, fam={3}".format(
len(matched), pv, cell, fam))
if not matched:
logging.warn("element not found for {0}".format(pv))
raise RuntimeError("unmatched quad PV: {0}".format(ch.Name))
if len(matched) > 1:
msg = "duplicate data for {0}: {1}".format(pv, matched)
logging.error(msg)
raise RuntimeError(msg)
e = matched[0]
logging.info("pick {0}".format(e))
f.write("%s,%s,%s,%s,COR,%s\n" % (ch.Name, hdl, e[0], e[1], fld))
f.close()
def testPVUpdate(self):
'''
Test condition
IOC turned on with ch1, ch2
IOC turned on with ch1 only
IOC turned on with ch1, ch2
'''
try:
updateChannelFinder(['ch1', 'ch2'], \
'testHost', \
'testIOC', \
owner=self.owner, \
time=time(), \
service=self.baseURL, \
username=self.username, password=self.password)
client = ChannelFinderClient(BaseURL=self.baseURL, username=self.username, password=self.password)
chs = client.find(property=[('hostName', 'testHost'), ('iocName', 'testIOC'), ('pvStatus', 'Active')])
self.assertEqual(len(chs), 2, 'Expected 2 positive matches but found ' + str(len(chs)))
updateChannelFinder(['ch1'], \
'testHost', \
'testIOC', \
owner=self.owner, \
time=time(), \
service=self.baseURL, \
username=self.username, password=self.password)
chs = client.find(property=[('hostName', 'testHost'), ('iocName', 'testIOC'), ('pvStatus', 'Active')])
self.assertEqual(len(chs), 1, 'Expected 1 positive matches but found ' + str(len(chs)))
self.assertTrue(chs[0].Name == 'ch1', 'channel with name ch1 not found')
chs = client.find(property=[('hostName', 'testHost'), ('iocName', 'testIOC'), ('pvStatus', 'InActive')])
self.assertEqual(len(chs), 1, 'Expected 1 positive matches but found ' + str(len(chs)))
self.assertTrue(chs[0].Name == 'ch2', 'channel with name ch2 not found')
updateChannelFinder(['ch1', 'ch2'], \
'testHost', \
'testIOC', \
owner=self.owner, \
time=time(), \
service=self.baseURL, \
username=self.username, password=self.password)
chs = client.find(property=[('hostName', 'testHost'), ('iocName', 'testIOC'), ('pvStatus', 'Active')])
self.assertEqual(len(chs), 2, 'Expected 2 positive matches but found ' + str(len(chs)))
finally:
client.delete(channelName='ch1')
client.delete(channelName='ch2')
def download_cfs(cfsurl, **cfinput):
cf = ChannelFinderClient(BaseURL = cfsurl)
chs = cf.find(**cfinput)
ret = chanData.ChannelFinderData()
for ch in chs:
pv = ch.Name
prpt = dict([(p.Name, p.Value) for p in ch.Properties])
tags = [t.Name for t in ch.Tags]
ret.update(pv = pv, properties = prpt, tags = tags)
return ret
def download_cfs(cfsurl, **cfinput):
cf = ChannelFinderClient(BaseURL = cfsurl)
chs = cf.find(**cfinput)
ret = chanData.ChannelFinderData()
for ch in chs:
pv = ch.Name
prpt = dict([(p.Name, p.Value) for p in ch.Properties])
tags = [t.Name for t in ch.Tags]
ret.update(pv = pv, properties = prpt, tags = tags)
return ret
def run_simple_task():
cf = ChannelFinderClient(**cfinput)
chs = cf.find(property=[('elemType', 'RFCAVITY')])
if chs is not None:
for ch in chs:
print ch.Name,
for p in ch.Properties:
print p.Name, "=", p.Value, ", ",
print " /"
#addPvProperty(cf, ch.Name, "elemPosition", "633.566", PRPTOWNER)
#addPvProperty(cf, ch.Name, "elemIndex", "2928", PRPTOWNER)
#addPvProperty(cf, ch.Name, "elemLength", "0.0", PRPTOWNER)
#addPvProperty(cf, ch.Name, "cell", "C24", PRPTOWNER)
addPvProperty(cf, ch.Name, "girder", "G", PRPTOWNER)
else:
print "did not found RFCAVITY"
def run_simple_task():
cf = ChannelFinderClient(**cfinput)
chs = cf.find(property=[('elemType', 'RFCAVITY')])
if chs is not None:
for ch in chs:
print ch.Name,
for p in ch.Properties:
print p.Name,"=",p.Value,", ",
print " /"
#addPvProperty(cf, ch.Name, "elemPosition", "633.566", PRPTOWNER)
#addPvProperty(cf, ch.Name, "elemIndex", "2928", PRPTOWNER)
#addPvProperty(cf, ch.Name, "elemLength", "0.0", PRPTOWNER)
#addPvProperty(cf, ch.Name, "cell", "C24", PRPTOWNER)
addPvProperty(cf, ch.Name, "girder", "G", PRPTOWNER)
else:
print "did not found RFCAVITY"
def init_bpm(elems, url, patl, fname):
# sort BPM names in lattice
bpms = {}
for e in elems:
if e[2] != "BPM": continue
# ignore User BPM
if e[0].startswith("pu"): continue
k = "C%d" % (int(e[6][1:]), )
bpms.setdefault(k, []).append((
e[0],
e[1],
))
for k, v in bpms.items():
print k, v
cf = ChannelFinderClient(BaseURL=url)
f = open(fname, "w")
for pvpat, hdl, name, idx, etp, fld in patl:
# for each pattern, sort PV and check against with elements.
bpmpvs = {}
chs = cf.find(name=pvpat,
property=[("hostName", "*"), ("iocName", "*")])
for ch in chs:
g = re.match(r"SR:(C[0-9][0-9]?)-BI{BPM:([0-9]+)}.*", ch.Name)
if not g:
raise RuntimeError("unknown PV: '{0}'".format(ch.Name))
bpmpvs.setdefault(g.group(1), []).append(ch.Name)
for k, pvs in bpmpvs.items():
#print k, pvs
names = bpms.get(k, [])
if len(names) != len(pvs):
#raise RuntimeError("BPM in {0} does not agree {1} != {2}".format(k, len(pvs), len(names)))
print "ERROR: BPM in {0} does not agree {1} != {2}".format(
k, len(pvs), len(names))
for pv in pvs:
g = re.match(r"SR:(C[0-9][0-9]?)-BI{BPM:([0-9]+)}.*", pv)
r = bpms[k][int(g.group(2)) - 1]
f.write("%s,%s,%s,%s,BPM,%s\n" % (pv, hdl, r[0], r[1], fld))
f.close()
def init_skquad(elems, url, patl, fname):
cf = ChannelFinderClient(BaseURL=url)
f = open(fname, "w")
for pvpat, hdl, name, idx, etp, fld in patl:
chs = cf.find(name=pvpat,
property=[("hostName", "*"), ("iocName", "*")])
for ch in chs:
pv = ch.Name
g = re.match(r"SR:(C[0-9][0-9]?)-MG{PS:SQK([A-Z][0-9])([AB]?)}.*",
ch.Name)
if not g:
raise RuntimeError("unknown PV: '{0}'".format(ch.Name))
cell, fam = g.group(1), g.group(2)
matched = []
for e in elems:
if e[2] != "SKQUAD": continue
# cell
if e[6] != cell: continue
# symmetry
if g.group(3) and e[8] != g.group(3): continue
matched.append(e)
logging.info(
"found {0} SKQUAD records for '{1}', cell={2}, fam={3}".format(
len(matched), pv, cell, fam))
if not matched:
logging.warn("element not found for {0}".format(pv))
raise RuntimeError("unmatched quad PV: {0}".format(ch.Name))
if len(matched) > 1:
msg = "duplicate data for {0}: {1}".format(pv, matched)
logging.error(msg)
raise RuntimeError(msg)
e = matched[0]
logging.info("pick {0}".format(e))
f.write("%s,%s,%s,%s,SKQUAD,%s\n" %
(ch.Name, hdl, e[0], e[1], fld))
f.close()
def init_sext(elems, url, patl, fname):
cf = ChannelFinderClient(BaseURL=url)
skquad = re.compile(r"SR:(C[0-9]+)-MG{PS:(SQ[A-Z0-9]+)}.*")
sxt_dw = re.compile(r"SR:(C[0-9]+)-MG{PS:(S[HLM][0-9])-(DW[0-9]+)}.*")
f = open(fname, "w")
for pvpat, hdl, name, idx, etp, fld in patl:
chs = cf.find(name=pvpat, property=[("hostName", "*"),
("iocName","*")])
for ch in chs:
if skquad.match(ch.Name): continue
if sxt_dw.match(ch.Name): continue
matched = match_sextupoles(elems, ch.Name)
logging.info("elements found for pv '{0}': {1}".format(
ch.Name, [elems[i][0] for i in matched]))
if not matched:
raise RuntimeError("unknown Sextupole PV: '{0}'".format(pv))
if len(matched) != 6:
raise RuntimeError("should be 6 sextupoles, {0} found".format(
len(matched)))
for e in [elems[i] for i in matched]:
f.write("%s,%s,%s,%s,SEXT,%s\n" % (ch.Name, hdl, e[0], e[1], fld))
f.close()
def init_sext(elems, url, patl, fname):
cf = ChannelFinderClient(BaseURL=url)
skquad = re.compile(r"SR:(C[0-9]+)-MG{PS:(SQ[A-Z0-9]+)}.*")
sxt_dw = re.compile(r"SR:(C[0-9]+)-MG{PS:(S[HLM][0-9])-(DW[0-9]+)}.*")
f = open(fname, "w")
for pvpat, hdl, name, idx, etp, fld in patl:
chs = cf.find(name=pvpat,
property=[("hostName", "*"), ("iocName", "*")])
for ch in chs:
if skquad.match(ch.Name): continue
if sxt_dw.match(ch.Name): continue
matched = match_sextupoles(elems, ch.Name)
logging.info("elements found for pv '{0}': {1}".format(
ch.Name, [elems[i][0] for i in matched]))
if not matched:
raise RuntimeError("unknown Sextupole PV: '{0}'".format(pv))
if len(matched) != 6:
raise RuntimeError("should be 6 sextupoles, {0} found".format(
len(matched)))
for e in [elems[i] for i in matched]:
f.write("%s,%s,%s,%s,SEXT,%s\n" %
(ch.Name, hdl, e[0], e[1], fld))
f.close()
def init_bpm(elems, url, patl, fname):
# sort BPM names in lattice
bpms = {}
for e in elems:
if e[2] != "BPM": continue
# ignore User BPM
if e[0].startswith("pu"): continue
k = "C%d" % (int(e[6][1:]),)
bpms.setdefault(k, []).append((e[0], e[1],))
for k,v in bpms.items(): print k, v
cf = ChannelFinderClient(BaseURL=url)
f = open(fname, "w")
for pvpat, hdl, name, idx, etp, fld in patl:
# for each pattern, sort PV and check against with elements.
bpmpvs = {}
chs = cf.find(name=pvpat, property=[("hostName", "*"),
("iocName","*")])
for ch in chs:
g = re.match(r"SR:(C[0-9][0-9]?)-BI{BPM:([0-9]+)}.*", ch.Name)
if not g:
raise RuntimeError("unknown PV: '{0}'".format(ch.Name))
bpmpvs.setdefault(g.group(1), []).append(ch.Name)
for k,pvs in bpmpvs.items():
#print k, pvs
names = bpms.get(k, [])
if len(names) != len(pvs):
#raise RuntimeError("BPM in {0} does not agree {1} != {2}".format(k, len(pvs), len(names)))
print "ERROR: BPM in {0} does not agree {1} != {2}".format(k, len(pvs), len(names))
for pv in pvs:
g = re.match(r"SR:(C[0-9][0-9]?)-BI{BPM:([0-9]+)}.*", pv)
r = bpms[k][int(g.group(2)) - 1]
f.write("%s,%s,%s,%s,BPM,%s\n" % (pv, hdl, r[0], r[1], fld))
f.close()
def testPreservingOfAttributes(self):
'''
This test is to ensure that existing properties and tags are left untouched.
Case1:
first time the cf-update comes across these channels and adds hostName and iocName
Case2:
the hostName is changed
Case3:
the iocName is changed
Case4:
both hostName and iocName are changed
Case5:
the channel is removed
in all cases the existing unaffected* property and tag should remain with the channel
'''
unaffectedProperty = {u'name':u'unaffectedProperty', u'owner':self.owner, u'value':u'unchanged'}
unaffectedTag = {u'name':u'unaffectedTag', u'owner':self.owner}
# create default client
client = ChannelFinderClient(BaseURL=self.baseURL, username=self.username, password=self.password)
client.set(property=unaffectedProperty)
client.set(tag=unaffectedTag)
client.set(channel={u'name':u'cf-update-pv1', u'owner':u'cf-update', u'properties':[unaffectedProperty], u'tags':[unaffectedTag]})
client.set(channel={u'name':u'cf-update-pv2', u'owner':u'cf-update', u'properties':[unaffectedProperty], u'tags':[unaffectedTag]})
# Case1:
hostName = 'initialHost'
iocName = 'initialIoc'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel['properties'] and unaffectedTag in channel['tags'])
self.assertTrue(self.__check4properties({u'name':u'hostName', u'value':hostName}, channel['properties']) and
self.__check4properties({u'name':u'iocName', u'value':iocName}, channel['properties']) and
self.__check4properties({u'name':u'pvStatus', u'value':u'Active'}, channel['properties']),
'Failed to update channels with the correct hostName and/or iocName')
# Case2:
hostName = 'newHost'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel['properties'] and unaffectedTag in channel['tags'])
self.assertTrue(self.__check4properties({u'name':u'hostName', u'value':hostName}, channel['properties']) and
self.__check4properties({u'name':u'iocName', u'value':iocName}, channel['properties']) and
self.__check4properties({u'name':u'pvStatus', u'value':u'Active'}, channel['properties']),
'Failed to update channels with the correct hostName and/or iocName')
self.assertTrue(not client.find(property=[('hostName', 'initialHost')]), 'Failed to cleanup old property')
# Case 3:
iocName = 'newIoc'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel['properties'] and unaffectedTag in channel['tags'])
self.assertTrue(self.__check4properties({u'name':u'hostName', u'value':hostName}, channel['properties']) and
self.__check4properties({u'name':u'iocName', u'value':iocName}, channel['properties']) and
self.__check4properties({u'name':u'pvStatus', u'value':u'Active'}, channel['properties']),
'Failed to update channels with the correct hostName and/or iocName')
self.assertTrue(not client.find(property=[('hostName', 'initialHost')]), 'Failed to cleanup old property')
self.assertTrue(not client.find(property=[('iocName', 'initialIoc')]), 'Failed to cleanup old property')
# Case 4:
updateChannelFinder([], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel['properties'] and unaffectedTag in channel['tags'])
self.assertTrue(self.__check4properties({u'name':u'hostName', u'value':hostName}, channel['properties']) and
self.__check4properties({u'name':u'iocName', u'value':iocName}, channel['properties']) and
self.__check4properties({u'name':u'pvStatus', u'value':u'Inactive'}, channel['properties']),
'Failed to update channels with the correct hostName and/or iocName')
self.assertTrue(not client.find(property=[('hostName', 'initialHost')]), 'Failed to cleanup old property')
self.assertTrue(not client.find(property=[('iocName', 'initialIoc')]), 'Failed to cleanup old property')
# Cleanup
'''
TODO this cleanup code should not be contingent to the successful completion of all checks...
This could pollute CF
'''
client.delete(channelName='cf-update-pv1')
client.delete(channelName='cf-update-pv2')
client.delete(propertyName=unaffectedProperty[u'name'])
client.delete(tagName=unaffectedTag[u'name'])
def downloadCfs(self, cfsurl, **kwargs):
"""
downloads data from channel finder service.
:param cfsurl: the URL of channel finder service.
:type cfsurl: str
:param keep: if present, it only downloads specified properties.
:type keep: list
:param converter: convert properties from string to other format.
:type converter: dict
:Example:
>>> prpt_list = ['elemName', 'sEnd']
>>> conv_dict = {'sEnd', float}
>>> downloadCfs(URL, keep = prpt_list, converter = conv_dict)
>>> downloadCfs(URL, property=[('hostName', 'virtac2')])
>>> downloadCfs(URL, property=[('hostName', 'virtac')], tagName='aphla.*')
The channel finder client API provides *property* and *tagName* as
keywords parameters.
"""
keep_prpts = kwargs.pop('keep', None)
converter = kwargs.pop('converter', {})
self.source = cfsurl
from channelfinder import ChannelFinderClient
cf = ChannelFinderClient(BaseURL=cfsurl)
if len(kwargs) == 0:
chs = cf.find(name='*')
else:
#print kwargs
chs = cf.find(**kwargs)
if not chs: return
if keep_prpts is None:
# use all possible property names
keep_prpts = [p.Name for p in cf.getAllProperties()]
#print "# include properties", properties
for ch in chs:
# keep only known properties
prptdict = ch.getProperties()
# prpts is known part from prptdict, otherwise empty dict
if prptdict is not None:
prpts = dict([v for v in prptdict.iteritems()])
# convert the data type
else:
prpts = None
# the empty tags could be None
if self.use_unicode:
self.rows.append([
unicode(ch.Name),
dict([(unicode(k), unicode(v))
for k, v in prpts.iteritems()]),
[unicode(v) for v in ch.getTags()]
])
else:
self.rows.append([
ch.Name.encode('ascii'),
dict([(k.encode('ascii'), v.encode('ascii'))
for k, v in prpts.iteritems()]),
[v.encode('ascii') for v in ch.getTags()]
])
if self.rows[-1][1]:
for k in converter:
self.rows[-1][1][k] = converter[k](prpts[k])
# warn if hostName or iocName does not present
if "hostName" not in self.rows[-1][1]:
_logger.warn("no 'hostName' for {0}".format(self.rows[-1]))
if "iocName" not in self.rows[-1][1]:
_logger.warn("no 'iocName' for {0}".format(self.rows[-1]))
del prptdict
def cfs_append_from_sqlite(fname, update_only):
sq = ap.chanfinder.ChannelFinderAgent()
sq.loadSqlite(fname)
cf = ChannelFinderClient(**cfinput)
all_prpts = [p.Name for p in cf.getAllProperties()]
all_tags = [t.Name for t in cf.getAllTags()]
ignore_prpts = ['hostName', 'iocName']
allpvs = []
tag_owner = OWNER
prpt_owner = PRPTOWNER
prpt_data, tag_data = {}, {}
# the data body
for pv, prpts, tags in sq.rows:
if not pv: continue
if pv in allpvs: continue
if pv.find("SR:") != 0: continue
logging.info("updating '{0}'".format(pv))
allpvs.append(pv)
prpt_list, tag_list = [], []
for k,v in prpts.items():
if k not in ["elemIndex", "system", "elemType", "elemHandle",
"elemName", "elemField"]: continue
prpt_data.setdefault((k, v), [])
prpt_data[(k, v)].append(pv)
for tag in tags:
if not tag.startswith("aphla."): continue
tag_data.setdefault(tag, [])
tag_data[tag].append(pv)
#tag_list.append(Tag(r.strip()), tag_owner)
logging.info("{0}: {1} ({2})".format(pv, tag, tag_owner))
#addPvTag(cf, pv, tag, tag_owner)
errpvs = []
for pv in allpvs:
chs = cf.find(name=pv)
if not chs:
errpvs.append(pv)
print "PV '%s' does not exist" % pv
continue
elif len(chs) != 1:
print "Find two results for pv=%s" % pv
continue
prpts = chs[0].getProperties()
if not prpts: continue
for prpt,val in prpts.items():
pvlst = prpt_data.get((prpt, val), [])
if not pvlst: continue
try:
j = pvlst.index(pv)
prpt_data[(prpt,val)].pop(j)
except:
# the existing data is not in the update list, skip
pass
#if errpvs:
# #raise RuntimeError("PVs '{0}' are missing".format(errpvs))
# print
logging.warn("{0} does not exist in DB".format(errpvs))
for k,v in prpt_data.iteritems():
vf = [pv for pv in v if pv not in errpvs]
if not vf:
logging.info("no valid PVs for {0}".format(k))
continue
updatePropertyPvs(cf, k[0], prpt_owner, k[1], vf)
logging.info("add property {0} for pvs {1}".format(k, vf))
for k,v in tag_data.iteritems():
vf = [pv for pv in v if pv not in errpvs]
addTagPvs(cf, k, vf, tag_owner)
logging.info("add tag {0} for pvs {1}".format(k, vf))
def testPVMove(self):
'''
ch1, ch2 on host1, ioc1
ch1 on host1, ioc1; ch2 on host1, ioc2 (case1)
ch1, ch2 on host1, ioc1 (reset)
ch1 on host1, ioc1; ch2 on host2, ioc2 (case2)
ch1, ch2 on host1, ioc1 (reset)
'''
try:
updateChannelFinder(['ch1', 'ch2'], \
'host1', \
'ioc1', \
owner=self.owner, \
time=time(),\
service=self.baseURL, \
username=self.username, password=self.password)
client = ChannelFinderClient(BaseURL=self.baseURL, username=self.username, password=self.password)
chs = client.find(property=[('hostName', 'host1'), ('iocName', 'ioc1')])
self.assertEqual(len(chs), 2, 'Expected 2 positive matches but found ' + str(len(chs)))
'''CASE1'''
updateChannelFinder(['ch1'], \
'host1', \
'ioc1', \
time=time(), \
owner=self.owner, service=self.baseURL, \
username=self.username, password=self.password)
updateChannelFinder(['ch2'], \
'host1', \
'ioc2', \
time=time(), \
owner=self.owner, service=self.baseURL, \
username=self.username, password=self.password)
chs = client.find(property=[('hostName', 'host1')])
self.assertEqual(len(chs), 2, 'Expected 1 positive matches but found ' + str(len(chs)))
self.assertEqual(client.find(property=[('hostName', 'host1'), ('iocName', 'ioc1')])[0].Name, 'ch1', \
'Failed to find the expected channel _ch1_ with prop host1, ioc1')
self.assertEqual(client.find(property=[('hostName', 'host1'), ('iocName', 'ioc2')])[0].Name, 'ch2', \
'Failed to find the expected channel _ch2_ with prop host1, ioc2')
'''RESET'''
updateChannelFinder(['ch1', 'ch2'], \
'host1', \
'ioc1', \
time=time(), \
owner=self.owner, service=self.baseURL, \
username=self.username, password=self.password)
self.assertEqual(len(client.find(property=[('hostName', 'host1'), ('iocName', 'ioc1')])), 2, \
'Failed to reset the channels')
'''CASE2'''
updateChannelFinder(['ch1'], \
'host1', \
'ioc1', \
owner=self.owner, \
time=time(), \
service=self.baseURL, username=self.username, \
password=self.password)
updateChannelFinder(['ch2'], \
'host2', \
'ioc2', \
owner=self.owner, service=self.baseURL, \
time=time(), \
username=self.username, password=self.password)
self.assertEqual(client.find(property=[('hostName', 'host1'), ('iocName', 'ioc1')])[0].Name, 'ch1', \
'Failed to find the expected channel _ch1_ with prop host1, ioc1')
self.assertEqual(client.find(property=[('hostName', 'host2'), ('iocName', 'ioc2')])[0].Name, 'ch2', \
'Failed to find the expected channel _ch2_ with prop host1, ioc2')
'''RESET'''
updateChannelFinder(['ch1', 'ch2'], \
'host1', \
'ioc1', \
owner=self.owner, \
time=time(), \
service=self.baseURL, \
username=self.username, password=self.password)
self.assertEqual(len(client.find(property=[('hostName', 'host1'), ('iocName', 'ioc1')])), 2, \
'Failed to reset the channels')
finally:
client.delete(channelName='ch1')
client.delete(channelName='ch2')
def testPreservingOfAttributes(self):
'''
This test is to ensure that existing properties and tags are left untouched.
Case1:
first time the cf-update comes across these channels and adds hostName and iocName
Case2:
the hostName is changed
Case3:
the iocName is changed
Case4:
both hostName and iocName are changed
Case5:
the channel is removed
in all cases the existing unaffected* property and tag should remain with the channel
'''
unaffectedProperty = Property('unaffectedProperty', self.owner, 'unchanged')
unaffectedTag = Tag('unaffectedTag', self.owner)
# create default client
client = ChannelFinderClient(BaseURL=self.baseURL, username=self.username, password=self.password)
client.set(property=unaffectedProperty)
client.set(tag=unaffectedTag)
client.set(channel=Channel('cf-update-pv1', 'cf-update', properties=[unaffectedProperty], tags=[unaffectedTag]))
client.set(channel=Channel('cf-update-pv2', 'cf-update', properties=[unaffectedProperty], tags=[unaffectedTag]))
# Case1:
hostName = 'initialHost'
iocName = 'initialIoc'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel.Properties and unaffectedTag in channel.Tags)
self.assertTrue(channel.getProperties()['hostName'] == hostName and \
channel.getProperties()['iocName'] == iocName and \
channel.getProperties()['pvStatus'] == 'Active', \
'Failed to update channels with the correct hostName and/or iocName')
# Case2:
hostName = 'newHost'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel.Properties and unaffectedTag in channel.Tags)
self.assertTrue(channel.getProperties()['hostName'] == hostName and \
channel.getProperties()['iocName'] == iocName and \
channel.getProperties()['pvStatus'] == 'Active', \
'Failed to update channels with the correct hostName and/or iocName')
self.assertTrue(client.find(property=[('hostName', 'initialHost')]) == None, 'Failed to cleanup old property')
# Case 3:
iocName = 'newIoc'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel.Properties and unaffectedTag in channel.Tags)
self.assertTrue(channel.getProperties()['hostName'] == hostName and \
channel.getProperties()['iocName'] == iocName and \
channel.getProperties()['pvStatus'] == 'Active', 'Failed to update channels with the correct hostName and/or iocName')
self.assertTrue(client.find(property=[('hostName', 'initialHost')]) == None, 'Failed to cleanup old property')
self.assertTrue(client.find(property=[('iocName', 'initialIoc')]) == None, 'Failed to cleanup old property')
# Case 4:
updateChannelFinder([], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel.Properties and unaffectedTag in channel.Tags)
self.assertTrue(channel.getProperties()['hostName'] == hostName and \
channel.getProperties()['iocName'] == iocName and \
channel.getProperties()['pvStatus'] == 'InActive', \
'Failed to update channels with the correct hostName and/or iocName')
self.assertTrue(client.find(property=[('hostName', 'initialHost')]) == None, 'Failed to cleanup old property')
self.assertTrue(client.find(property=[('iocName', 'initialIoc')]) == None, 'Failed to cleanup old property')
# Cleanup
client.delete(channelName='cf-update-pv1')
client.delete(channelName='cf-update-pv2')
client.delete(propertyName=unaffectedProperty.Name)
client.delete(tagName=unaffectedTag.Name)
def testPreservingOfAttributes(self):
'''
This test is to ensure that existing properties and tags are left untouched.
Case1:
first time the cf-update comes across these channels and adds hostName and iocName
Case2:
the hostName is changed
Case3:
the iocName is changed
Case4:
both hostName and iocName are changed
Case5:
the channel is removed
in all cases the existing unaffected* property and tag should remain with the channel
'''
unaffectedProperty = {
u'name': u'unaffectedProperty',
u'owner': self.owner,
u'value': u'unchanged'
}
unaffectedTag = {u'name': u'unaffectedTag', u'owner': self.owner}
# create default client
client = ChannelFinderClient(BaseURL=self.baseURL,
username=self.username,
password=self.password)
client.set(property=unaffectedProperty)
client.set(tag=unaffectedTag)
client.set(
channel={
u'name': u'cf-update-pv1',
u'owner': u'cf-update',
u'properties': [unaffectedProperty],
u'tags': [unaffectedTag]
})
client.set(
channel={
u'name': u'cf-update-pv2',
u'owner': u'cf-update',
u'properties': [unaffectedProperty],
u'tags': [unaffectedTag]
})
# Case1:
hostName = 'initialHost'
iocName = 'initialIoc'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel['properties']
and unaffectedTag in channel['tags'])
self.assertTrue(
self.__check4properties(
{
u'name': u'hostName',
u'value': hostName
}, channel['properties']) and self.__check4properties(
{
u'name': u'iocName',
u'value': iocName
}, channel['properties']) and self.__check4properties(
{
u'name': u'pvStatus',
u'value': u'Active'
}, channel['properties']),
'Failed to update channels with the correct hostName and/or iocName'
)
# Case2:
hostName = 'newHost'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel['properties']
and unaffectedTag in channel['tags'])
self.assertTrue(
self.__check4properties(
{
u'name': u'hostName',
u'value': hostName
}, channel['properties']) and self.__check4properties(
{
u'name': u'iocName',
u'value': iocName
}, channel['properties']) and self.__check4properties(
{
u'name': u'pvStatus',
u'value': u'Active'
}, channel['properties']),
'Failed to update channels with the correct hostName and/or iocName'
)
self.assertTrue(
not client.find(property=[('hostName', 'initialHost')]),
'Failed to cleanup old property')
# Case 3:
iocName = 'newIoc'
updateChannelFinder(['cf-update-pv1', 'cf-update-pv2'], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel['properties']
and unaffectedTag in channel['tags'])
self.assertTrue(
self.__check4properties(
{
u'name': u'hostName',
u'value': hostName
}, channel['properties']) and self.__check4properties(
{
u'name': u'iocName',
u'value': iocName
}, channel['properties']) and self.__check4properties(
{
u'name': u'pvStatus',
u'value': u'Active'
}, channel['properties']),
'Failed to update channels with the correct hostName and/or iocName'
)
self.assertTrue(
not client.find(property=[('hostName', 'initialHost')]),
'Failed to cleanup old property')
self.assertTrue(not client.find(property=[('iocName', 'initialIoc')]),
'Failed to cleanup old property')
# Case 4:
updateChannelFinder([], \
hostName, \
iocName, \
owner=self.owner, \
time=time(), \
service=self.baseURL , \
username=self.username, \
password=self.password)
channels = client.find(name='cf-update-pv*')
for channel in channels:
self.assertTrue(unaffectedProperty in channel['properties']
and unaffectedTag in channel['tags'])
self.assertTrue(
self.__check4properties(
{
u'name': u'hostName',
u'value': hostName
}, channel['properties']) and self.__check4properties(
{
u'name': u'iocName',
u'value': iocName
}, channel['properties']) and self.__check4properties(
{
u'name': u'pvStatus',
u'value': u'Inactive'
}, channel['properties']),
'Failed to update channels with the correct hostName and/or iocName'
)
self.assertTrue(
not client.find(property=[('hostName', 'initialHost')]),
'Failed to cleanup old property')
self.assertTrue(not client.find(property=[('iocName', 'initialIoc')]),
'Failed to cleanup old property')
# Cleanup
'''
TODO this cleanup code should not be contingent to the successful completion of all checks...
This could pollute CF
'''
client.delete(channelName='cf-update-pv1')
client.delete(channelName='cf-update-pv2')
client.delete(propertyName=unaffectedProperty[u'name'])
client.delete(tagName=unaffectedTag[u'name'])
def cfs_append_from_csv2(rec_list, update_only):
cf = ChannelFinderClient(**cfinput)
all_prpts = [p.Name for p in cf.getAllProperties()]
all_tags = [t.Name for t in cf.getAllTags()]
ignore_prpts = ['hostName', 'iocName']
import csv
rd = csv.reader(rec_list)
allpvs = []
tag_owner = OWNER
prpt_owner = PRPTOWNER
prpt_data, tag_data = {}, {}
# the data body
for s in rd:
if not s: continue
if not s[0].strip(): continue
if s[0].strip().startswith('#'): continue
pv = s[0].strip()
logging.info("updating '{0}'".format(pv))
#cf.update(property=Property('elemType', PRPTOWNER, 'QUAD'),
# channelNames = [pv])
#chs = cf.find(name=pv)
#sys.exit(0)
#logging.info("{0} and {1}".format(chs[0].Name, type(chs[0].Name)))
#logging.info("{0} and {1}".format(pv, type(pv)))
allpvs.append(pv)
prpt_list, tag_list = [], []
for r in s[1:]:
if r.find('=') > 0:
prpt, val = [v.strip() for v in r.split('=')]
prpt_data.setdefault((prpt, val), [])
prpt_data[(prpt, val)].append(pv)
else:
# it is a tag
tag = r.strip()
if not tag: continue
tag_data.setdefault(tag, [])
tag_data[tag].append(pv)
#tag_list.append(Tag(r.strip()), tag_owner)
logging.info("{0}: {1} ({2})".format(pv, tag, tag_owner))
#addPvTag(cf, pv, tag, tag_owner)
errpvs = []
for pv in allpvs:
chs = cf.find(name=pv)
if not chs:
errpvs.append(pv)
print("PV '%s' does not exist" % pv)
continue
elif len(chs) != 1:
print("Find two results for pv=%s" % pv)
continue
for prpt, val in chs[0].getProperties().items():
pvlst = prpt_data.get((prpt, val), [])
if not pvlst: continue
try:
j = pvlst.index(pv)
prpt_data[(prpt, val)].pop(j)
except:
# the existing data is not in the update list, skip
pass
#if errpvs:
# #raise RuntimeError("PVs '{0}' are missing".format(errpvs))
# print
logging.warn("{0} does not exist in DB".format(errpvs))
for k, v in prpt_data.items():
vf = [pv for pv in v if pv not in errpvs]
if not vf:
logging.info("no valid PVs for {0}".format(k))
continue
updatePropertyPvs(cf, k[0], prpt_owner, k[1], vf)
logging.info("add property {0} for pvs {1}".format(k, vf))
for k, v in tag_data.items():
vf = [pv for pv in v if pv not in errpvs]
addTagPvs(cf, k, vf, tag_owner)
logging.info("add tag {0} for pvs {1}".format(k, vf))
def cfs_append_from_csv2(rec_list, update_only):
cf = ChannelFinderClient(**cfinput)
all_prpts = [p.Name for p in cf.getAllProperties()]
all_tags = [t.Name for t in cf.getAllTags()]
ignore_prpts = ['hostName', 'iocName']
import csv
rd = csv.reader(rec_list)
allpvs = []
tag_owner = OWNER
prpt_owner = PRPTOWNER
prpt_data, tag_data = {}, {}
# the data body
for s in rd:
if not s: continue
if not s[0].strip(): continue
if s[0].strip().startswith('#'): continue
pv = s[0].strip()
logging.info("updating '{0}'".format(pv))
#cf.update(property=Property('elemType', PRPTOWNER, 'QUAD'),
# channelNames = [pv])
#chs = cf.find(name=pv)
#sys.exit(0)
#logging.info("{0} and {1}".format(chs[0].Name, type(chs[0].Name)))
#logging.info("{0} and {1}".format(pv, type(pv)))
allpvs.append(pv)
prpt_list, tag_list = [], []
for r in s[1:]:
if r.find('=') > 0:
prpt, val = [v.strip() for v in r.split('=')]
prpt_data.setdefault((prpt, val), [])
prpt_data[(prpt, val)].append(pv)
else:
# it is a tag
tag = r.strip()
if not tag: continue
tag_data.setdefault(tag, [])
tag_data[tag].append(pv)
#tag_list.append(Tag(r.strip()), tag_owner)
logging.info("{0}: {1} ({2})".format(pv, tag, tag_owner))
#addPvTag(cf, pv, tag, tag_owner)
errpvs = []
for pv in allpvs:
chs = cf.find(name=pv)
if not chs:
errpvs.append(pv)
print "PV '%s' does not exist" % pv
continue
elif len(chs) != 1:
print "Find two results for pv=%s" % pv
continue
for prpt,val in chs[0].getProperties().items():
pvlst = prpt_data.get((prpt, val), [])
if not pvlst: continue
try:
j = pvlst.index(pv)
prpt_data[(prpt,val)].pop(j)
except:
# the existing data is not in the update list, skip
pass
#if errpvs:
# #raise RuntimeError("PVs '{0}' are missing".format(errpvs))
# print
logging.warn("{0} does not exist in DB".format(errpvs))
for k,v in prpt_data.iteritems():
vf = [pv for pv in v if pv not in errpvs]
if not vf:
logging.info("no valid PVs for {0}".format(k))
continue
updatePropertyPvs(cf, k[0], prpt_owner, k[1], vf)
logging.info("add property {0} for pvs {1}".format(k, vf))
for k,v in tag_data.iteritems():
vf = [pv for pv in v if pv not in errpvs]
addTagPvs(cf, k, vf, tag_owner)
logging.info("add tag {0} for pvs {1}".format(k, vf))
def cfs_append_from_csv1(rec_list, update_only):
cf = ChannelFinderClient(**cfinput)
all_prpts = [p.Name for p in cf.getAllProperties()]
all_tags = [t.Name for t in cf.getAllTags()]
ignore_prpts = ['hostName', 'iocName']
import csv
rd = csv.reader(rec_list)
# header line
header = rd.next()
# lower case of header
hlow = [s.lower() for s in header]
# number of headers, pv + properties
nheader = len(header)
# the index of PV, properties and tags
ipv = hlow.index('pv')
# the code did not rely on it, but it is a good practice
if ipv != 0:
raise RuntimeError("the first column should be pv")
iprpt, itags = [], []
for i, h in enumerate(header):
if i == ipv: continue
# if the header is empty, it is a tag
if len(h.strip()) == 0:
itags.append(i)
else:
iprpt.append(i)
tag_owner = OWNER
prpt_owner = PRPTOWNER
tags = {}
# the data body
for s in rd:
prpts = [Property(header[i], prpt_owner, s[i]) for i in iprpt if s[i]]
# itags could be empty if we put all tags in the end columns
for i in itags + range(nheader, len(s)):
rec = tags.setdefault(s[i].strip(), [])
rec.append(s[ipv].strip())
#print s[ipv], prpts, tags
ch = cf.find(name=s[ipv])
if ch is None:
logging.warning("pv {0} does not exist".format(s[ipv]))
elif len(ch) > 1:
logging.warning("pv {0} is not unique ({1})".format(
s[ipv], len(ch)))
else:
for p in prpts:
#continue
if p.Name in ignore_prpts: continue
#if p.Name != 'symmetry': continue
logging.info("updating '{0}' with property, {1}={2}".format(
s[ipv], p.Name, p.Value))
cf.update(channelName=s[ipv], property=p)
logging.info("finished updating properties")
for t, pvs in tags.items():
if not hasTag(cf, t): cf.set(tag=Tag(t, tag_owner))
if 'V:1-SR-BI{BETA}X-I' in pvs: continue
if 'V:1-SR-BI{BETA}Y-I' in pvs: continue
try:
cf.update(tag=Tag(t, tag_owner), channelNames=pvs)
except:
print(t, pvs)
raise
logging.info("update '{0}' for {1} pvs".format(t, len(pvs)))
logging.info("finished updating tags")
def downloadCfs(self, cfsurl, **kwargs):
"""
downloads data from channel finder service.
:param cfsurl: the URL of channel finder service.
:type cfsurl: str
:param keep: if present, it only downloads specified properties.
:type keep: list
:param converter: convert properties from string to other format.
:type converter: dict
:Example:
>>> prpt_list = ['elemName', 'sEnd']
>>> conv_dict = {'sEnd', float}
>>> downloadCfs(URL, keep = prpt_list, converter = conv_dict)
>>> downloadCfs(URL, property=[('hostName', 'virtac2')])
>>> downloadCfs(URL, property=[('hostName', 'virtac')], tagName='aphla.*')
The channel finder client API provides *property* and *tagName* as
keywords parameters.
"""
keep_prpts = kwargs.pop('keep', None)
converter = kwargs.pop('converter', {})
self.source = cfsurl
from channelfinder import ChannelFinderClient
cf = ChannelFinderClient(BaseURL = cfsurl)
if len(kwargs) == 0:
chs = cf.find(name='*')
else:
#print kwargs
chs = cf.find(**kwargs)
if not chs: return
if keep_prpts is None:
# use all possible property names
keep_prpts = [p.Name for p in cf.getAllProperties()]
#print "# include properties", properties
for ch in chs:
# keep only known properties
prptdict = ch.getProperties()
# prpts is known part from prptdict, otherwise empty dict
if prptdict is not None:
prpts = dict([v for v in prptdict.iteritems()])
# convert the data type
else:
prpts = None
# the empty tags could be None
if self.use_unicode:
self.rows.append([unicode(ch.Name),
dict([(unicode(k), unicode(v))
for k,v in prpts.iteritems()]),
[unicode(v) for v in ch.getTags()]])
else:
self.rows.append([ch.Name.encode('ascii'),
dict([(k.encode('ascii'), v.encode('ascii'))
for k,v in prpts.iteritems()]),
[v.encode('ascii') for v in ch.getTags()]])
if self.rows[-1][1]:
for k in converter:
self.rows[-1][1][k] = converter[k](prpts[k])
# warn if hostName or iocName does not present
if "hostName" not in self.rows[-1][1]:
_logger.warn("no 'hostName' for {0}".format(self.rows[-1]))
if "iocName" not in self.rows[-1][1]:
_logger.warn("no 'iocName' for {0}".format(self.rows[-1]))
del prptdict
def cfs_append_from_sqlite(fname, update_only):
sq = ap.chanfinder.ChannelFinderAgent()
sq.loadSqlite(fname)
cf = ChannelFinderClient(**cfinput)
all_prpts = [p.Name for p in cf.getAllProperties()]
all_tags = [t.Name for t in cf.getAllTags()]
ignore_prpts = ['hostName', 'iocName']
allpvs = []
tag_owner = OWNER
prpt_owner = PRPTOWNER
prpt_data, tag_data = {}, {}
# the data body
for pv, prpts, tags in sq.rows:
if not pv: continue
if pv in allpvs: continue
if pv.find("SR:") != 0: continue
logging.info("updating '{0}'".format(pv))
allpvs.append(pv)
prpt_list, tag_list = [], []
for k, v in prpts.items():
if k not in [
"elemIndex", "system", "elemType", "elemHandle",
"elemName", "elemField"
]:
continue
prpt_data.setdefault((k, v), [])
prpt_data[(k, v)].append(pv)
for tag in tags:
if not tag.startswith("aphla."): continue
tag_data.setdefault(tag, [])
tag_data[tag].append(pv)
#tag_list.append(Tag(r.strip()), tag_owner)
logging.info("{0}: {1} ({2})".format(pv, tag, tag_owner))
#addPvTag(cf, pv, tag, tag_owner)
errpvs = []
for pv in allpvs:
chs = cf.find(name=pv)
if not chs:
errpvs.append(pv)
print("PV '%s' does not exist" % pv)
continue
elif len(chs) != 1:
print("Find two results for pv=%s" % pv)
continue
prpts = chs[0].getProperties()
if not prpts: continue
for prpt, val in prpts.items():
pvlst = prpt_data.get((prpt, val), [])
if not pvlst: continue
try:
j = pvlst.index(pv)
prpt_data[(prpt, val)].pop(j)
except:
# the existing data is not in the update list, skip
pass
#if errpvs:
# #raise RuntimeError("PVs '{0}' are missing".format(errpvs))
# print
logging.warn("{0} does not exist in DB".format(errpvs))
for k, v in prpt_data.items():
vf = [pv for pv in v if pv not in errpvs]
if not vf:
logging.info("no valid PVs for {0}".format(k))
continue
updatePropertyPvs(cf, k[0], prpt_owner, k[1], vf)
logging.info("add property {0} for pvs {1}".format(k, vf))
for k, v in tag_data.items():
vf = [pv for pv in v if pv not in errpvs]
addTagPvs(cf, k, vf, tag_owner)
logging.info("add tag {0} for pvs {1}".format(k, vf))
def cfs_append_from_csv1(rec_list, update_only):
cf = ChannelFinderClient(**cfinput)
all_prpts = [p.Name for p in cf.getAllProperties()]
all_tags = [t.Name for t in cf.getAllTags()]
ignore_prpts = ['hostName', 'iocName']
import csv
rd = csv.reader(rec_list)
# header line
header = rd.next()
# lower case of header
hlow = [s.lower() for s in header]
# number of headers, pv + properties
nheader = len(header)
# the index of PV, properties and tags
ipv = hlow.index('pv')
# the code did not rely on it, but it is a good practice
if ipv != 0:
raise RuntimeError("the first column should be pv")
iprpt, itags = [], []
for i, h in enumerate(header):
if i == ipv: continue
# if the header is empty, it is a tag
if len(h.strip()) == 0:
itags.append(i)
else:
iprpt.append(i)
tag_owner = OWNER
prpt_owner = PRPTOWNER
tags = {}
# the data body
for s in rd:
prpts = [Property(header[i], prpt_owner, s[i]) for i in iprpt if s[i]]
# itags could be empty if we put all tags in the end columns
for i in itags + range(nheader, len(s)):
rec = tags.setdefault(s[i].strip(), [])
rec.append(s[ipv].strip())
#print s[ipv], prpts, tags
ch = cf.find(name=s[ipv])
if ch is None:
logging.warning("pv {0} does not exist".format(s[ipv]))
elif len(ch) > 1:
logging.warning("pv {0} is not unique ({1})".format(s[ipv], len(ch)))
else:
for p in prpts:
#continue
if p.Name in ignore_prpts: continue
#if p.Name != 'symmetry': continue
logging.info("updating '{0}' with property, {1}={2}".format(
s[ipv], p.Name, p.Value))
cf.update(channelName=s[ipv], property=p)
logging.info("finished updating properties")
for t,pvs in tags.iteritems():
if not hasTag(cf, t): cf.set(tag=Tag(t, tag_owner))
if 'V:1-SR-BI{BETA}X-I' in pvs: continue
if 'V:1-SR-BI{BETA}Y-I' in pvs: continue
try:
cf.update(tag=Tag(t, tag_owner), channelNames=pvs)
except:
print t, pvs
raise
logging.info("update '{0}' for {1} pvs".format(t, len(pvs)))
logging.info("finished updating tags")
