def __init__(self,
channel,
data,
dbf=None,
meta=META.PLAIN,
dbf_conv=None,
wait=False):
"""Start a new write request
channel: PV name
data: value array
dbf: Field type to write
meta: Meta data class to send
dbf_conv: Treat value array as different field type.
Does a client-side conversion
wait: Request notification on completion
"""
self._chan, self.dbf = channel, dbf
self._data, self.dbf_conv = data, dbf_conv
self._meta, self._wait = meta, wait
self.done, self.ioid = True, None
self.__D = None
if dbf_conv is None and dbf is not None:
self.meta = caMeta(dbf)
elif dbf_conv is not None:
self.meta = caMeta(dbf_conv)
else:
self.meta = None
self.restart(data)
def __init__(self,
channel,
dbf=None,
count=None,
meta=META.PLAIN,
dbf_conv=None):
"""Start a new request.
channel: PV name
dbf: Field type requested from server
count: length requested from server
meta: Meta-data class requested
dbf_conv: Additional client side conversion
before data is returned to user.
Note: Server will never return more then count
elements, but may return less.
"""
self._chan, self.dbf = channel, dbf
self._meta, self.count = meta, count
self.dbf_conv = dbf_conv
if dbf_conv is None and dbf is not None:
self.meta = caMeta(dbf)
elif dbf_conv is not None:
self.meta = caMeta(dbf_conv)
else:
self.meta = None
self.restart()
def main():
lmeta=caMeta(DBF.LONG)
test=PV('test', value=['hello world'], meta=caMeta(DBF.STRING))
test2=PV('test2', value=[42], meta=caMeta(DBF.LONG))
test3=PV('test3', value=range(10), meta=caMetaProxy(test2.meta))
p = Server(pvs=[test,test2,test3])
reactor.run()
p.close()
def test_ro(self):
m=cadata.caMeta(defs.DBF.INT)
p=cadata.caMetaProxy(m, ro=True)
m.stamp=5.1
self.assertEqual(p.stamp, 5.1)
def x():
p.stamp=4.9
self.assertRaises(TypeError, x)
def test_cow(self):
m=cadata.caMeta(defs.DBF.INT)
p=cadata.caMetaProxy(m)
m.stamp=5.1
self.assertEqual(p.stamp, 5.1)
p.stamp=4.9
self.assertEqual(m.stamp, 5.1)
self.assertEqual(p.stamp, 4.9)
def _chanOk(self, chan):
self.__D = None
if chan is None:
self.close()
# channel has shutdown
return
assert self._chan is chan
self.ioid = chan._circ.pendingActions.add(self)
dbf = self.dbf
if dbf is None:
dbf, _ = dbr_to_dbf(chan.dbr)
dbr = dbf_to_dbr(dbf, self._meta)
meta = self.meta
if meta is None:
meta = caMeta(dbf)
data = self._data
cnt = len(data)
if cnt > chan.maxcount:
cnt = chan.maxcount
data = data[:chan.maxcount]
data, cnt = tostring(data, meta, dbr, cnt)
log.debug('Set %s to %s', chan, data)
cmd = 19 if self._wait else 4
msg = CAmessage(cmd=cmd,
size=len(data),
dtype=dbr,
count=cnt,
p1=chan.sid,
p2=self.ioid,
body=data).pack()
chan._circ.send(msg)
if not self._wait:
log.debug('Send put request (no wait) %s', self._chan.name)
# do completion here
self.ioid = None
self.done = True
self._comp.callback(ECA_NORMAL)
else:
log.debug('Send put request (wait) %s', self._chan.name)
d = self.__D = self._chan.whenDis
d.addCallback(self._circuitLost)
return chan
def _chanOk(self, chan):
self.__D=None
if chan is None:
self.close()
# channel shutdown
return
assert self._chan is chan
ver=chan._circ.version
self.subid=chan._circ.subscriptions.add(self)
dbf=self.dbf
if dbf is None:
self.dbf,_=dbr_to_dbf(chan.dbr)
dbr=dbf_to_dbr(self.dbf, self._meta)
if self.dbf_conv is None:
self.meta=caMeta(self.dbf)
else:
self.meta=caMeta(dbf_conv)
# use dynamic array length whenever possible
cnt=self.count if ver<13 else 0
if cnt is None or cnt>chan.maxcount:
cnt=chan.maxcount
b=monitormask.pack(self.mask)
msg=CAmessage(cmd=1, size=len(b),
dtype=dbr, count=cnt,
p1=chan.sid, p2=self.subid,
body=b).pack()
chan._circ.send(msg)
log.debug('Start monitor %s (%d)',chan.name,self.mask)
d=self.__D=self._chan.whenDis
d.addCallback(self._circuitLost)
return chan
def test_int(self):
meta = cadata.caMeta(defs.DBF.INT)
val=[5]
meta.status=0x1234
meta.severity=0x1020
meta.stamp=1284327459.1030619
one, count=cadata.tostring(val, meta, defs.DBR.INT, 1)
self.assertEqual(count, 1)
self.assertEqual(one, '\x00\x05'+('\0'*6))
one, count=cadata.tostring(val, meta, defs.DBR.STRING, 1)
self.assertEqual(count, 1)
self.assertEqual(one, '5'+('\0'*7))
def test_intarray(self):
meta = cadata.caMeta(defs.DBF.INT)
val=range(5,15)
meta.status=0x1234
meta.severity=0x1020
meta.stamp=1284327459.1030619
one, count=cadata.tostring(val, meta, defs.DBR.INT, 20)
self.assertEqual(count, 10)
self.assertEqual(one,
reduce(str.__add__,[chr(0)+chr(n) for n in range(5,15)],'')
+('\0'*4))
one, count=cadata.tostring(val, meta, defs.DBR.STRING, 1)
self.assertEqual(count, 1)
self.assertEqual(one, '5, 6, 7, 8, 9, 10, 11, 12, 13, 14'+('\0'*7))
def dispatch(self, pkt, circuit, peer=None):
if pkt.cmd != 15:
log.warning('Channel %s get ignoring pkt %s', self._chan.name, pkt)
# wait for real reply
chan._circ.pendingActions[self.ioid] = self
return
meta = self.meta
if meta is None:
dbf, _ = dbr_to_dbf(pkt.dtype)
meta = caMeta(dbf)
data = fromstring(pkt.body, pkt.dtype, pkt.count, meta)
self.ioid = None
self.done = True
self._result.callback(data)
def test_string(self):
meta = cadata.caMeta(defs.DBF.STRING)
val=['hello world']
meta.status=0x1234
meta.severity=0x1020
meta.stamp=1284327459.1030619
one, count=cadata.tostring(val, meta, defs.DBR.STRING, 1)
self.assertEqual(meta.dbf, defs.DBF.STRING)
self.assertEqual(count, 1)
self.assertEqual(one, 'hello world'+('\0'*5))
one, count=cadata.tostring(val, meta, defs.DBR.STS_STRING, 1)
self.assertEqual(meta.dbf, defs.DBF.STRING)
self.assertEqual(count, 1)
self.assertEqual(len(one), 24)
self.assertEqual(one, '\x12\x34\x10\x20hello world'+('\0'*9))
one, count=cadata.tostring(val, meta, defs.DBR.CHAR, 16)
self.assertEqual(meta.dbf, defs.DBF.STRING)
self.assertEqual(count, 11)
self.assertEqual(len(one), 16)
self.assertEqual(one, 'hello world'+('\0'*5))
def setUp(self):
self.meta=cadata.caMeta(defs.DBF.STRING)
self.bmeta=deepcopy(self.meta)