def setEnsembleContext(theMDIB, theClient):
# calling operation on remote device
print("Trying to set ensemble context of device A")
# first we get the container to the element in the MDIB
descriptorContainer = theMDIB.descriptions.NODETYPE.getOne(
domTag('EnsembleContextDescriptor'))
# get the context of our provider(client)
contextClient = theClient.ContextService_client
# start with empty operation handle and try to find the one we need
operationHandle = None
# iterate over all matching handles (can be 0..n)
for oneOp in theMDIB.descriptions.NODETYPE.get(
domTag('SetContextStateOperationDescriptor'), []):
if oneOp.OperationTarget == descriptorContainer.handle:
operationHandle = oneOp.Handle
# now we should have a operatoin handle to work with
# create a new ensemble context as parameter to this operation
newEnsembleContext = contextClient.mkProposedContextObject(
descriptorContainer.handle)
newEnsembleContext.ContextAssociation = 'Assoc'
newEnsembleContext.Identification = [
pmtypes.InstanceIdentifier(root="1.2.3",
extensionString="SupervisorSuperEnsemble")
]
# execute the remote operation (based on handle) with the newly created ensemble as parameter
contextClient.setContextState(operationHandle, [newEnsembleContext])
def test_ActivateOperationDescriptorContainer(self):
def _cmp_ActivateOperationDescriptorContainer(_dc, _dc2):
self.assertEqual(_dc.diff(_dc2), [])
self.assertEqual(_dc.Argument, _dc2.Argument)
# self.assertEqual(_dc.ActivationDuration, _dc2.ActivationDuration)
self.assertEqual(_dc.Retriggerable, _dc2.Retriggerable)
dc = descriptorcontainers.ActivateOperationDescriptorContainer(
nsmapper=self.nsmapper,
nodeName=namespaces.domTag('MyDescriptor'),
handle='123',
parentHandle='456',
)
# create copy with default values
node = dc.mkNode()
dc2 = descriptorcontainers.ActivateOperationDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
_cmp_ActivateOperationDescriptorContainer(dc, dc2)
dc.Argument = [
pmtypes.Argument(argName=pmtypes.CodedValue('abc', 'def'),
arg=namespaces.domTag('blubb'))
]
node = dc.mkNode()
dc2.updateDescrFromNode(node)
_cmp_ActivateOperationDescriptorContainer(dc, dc2)
def test_AbstractStateContainer(self):
sc = statecontainers.AbstractStateContainer(
nsmapper=self.nsmapper, descriptorContainer=self.dc, node=None)
# constructor shall create a node
self.assertEqual(sc.nodeName, namespaces.domTag('State'))
#initially the state version shall be 0, and DescriptorVersion shall be set
self.assertEqual(sc.StateVersion, 0)
self.assertEqual(sc.DescriptorVersion, self.dc.DescriptorVersion)
# verify that mkStateNode() also updates changed Descriptorversion
self.dc.DescriptorVersion += 1
sc.mkStateNode()
self.assertEqual(sc.DescriptorVersion, self.dc.DescriptorVersion)
# verify incrementState works ay expected
sc.incrementState()
self.assertEqual(sc.StateVersion, 1)
node = sc.mkStateNode()
self.assertEqual(node.get('StateVersion'), '1')
# test updateFromNode
node = etree_.Element(namespaces.domTag('State'),
attrib={
'StateVersion': '2',
'DescriptorHandle': self.dc.handle
})
sc.updateFromNode(node)
self.assertEqual(sc.StateVersion, 2)
self.assertEqual(sc.node.get('StateVersion'), '2')
node = etree_.Element(namespaces.domTag('State'),
attrib={
'StateVersion':
'3',
'DescriptorHandle':
'something_completely_different'
})
self.assertRaises(RuntimeError, sc.updateFromNode, node)
#test creation from node
sc2 = statecontainers.AbstractStateContainer(
nsmapper=self.nsmapper,
descriptorContainer=self.dc,
node=copy.deepcopy(sc.node)
) # sc2 might change node, therfore give it a deep copy
self._verifyAbstractStateContainerDataEqual(sc, sc2)
# test update from Node
sc.DescriptorVersion += 1
sc.incrementState()
node = sc.mkStateNode()
sc2.updateFromNode(node)
self._verifyAbstractStateContainerDataEqual(sc, sc2)
def setLocalEnsembleContext(mdib, ensemble):
descriptorContainer = mdib.descriptions.NODETYPE.getOne(
domTag('EnsembleContextDescriptor'))
if not descriptorContainer:
print("No ensemble contexts in mdib")
return
allEnsembleContexts = mdib.contextStates.descriptorHandle.get(
descriptorContainer.handle, [])
with mdib.mdibUpdateTransaction() as mgr:
# set all to currently associated Locations to Disassociated
associatedEnsembles = [
l for l in allEnsembleContexts
if l.ContextAssociation == pmtypes.ContextAssociation.ASSOCIATED
]
for l in associatedEnsembles:
ensembleContext = mgr.getContextState(l.descriptorHandle, l.Handle)
ensembleContext.ContextAssociation = pmtypes.ContextAssociation.DISASSOCIATED
ensembleContext.UnbindingMdibVersion = mdib.mdibVersion # UnbindingMdibVersion is the first version in which it is no longer bound ( == this version)
newEnsState = mgr.getContextState(
descriptorContainer.handle) # this creates a new location state
newEnsState.ContextAssociation = 'Assoc'
newEnsState.Identification = [
pmtypes.InstanceIdentifier(root="1.2.3", extensionString=ensemble)
]
def test_LimitAlertConditionDescriptorContainer(self):
dc = descriptorcontainers.LimitAlertConditionDescriptorContainer(
nsmapper=self.nsmapper,
nodeName=namespaces.domTag('MyDescriptor'),
handle='123',
parentHandle='456',
)
# create copy with default values
node = dc.mkNode()
dc2 = descriptorcontainers.LimitAlertConditionDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
self._cmp_LimitAlertConditionDescriptorContainer(dc, dc2)
# set values, test updateFromNode
dc.MaxLimits = pmtypes.Range(lower=0,
upper=100,
stepWidth=1,
relativeAccuracy=0.1,
absoluteAccuracy=0.2)
dc.AutoLimitSupported = True
node = dc.mkNode()
dc2.updateDescrFromNode(node)
self._cmp_LimitAlertConditionDescriptorContainer(dc, dc2)
# create copy with values set
dc2 = descriptorcontainers.LimitAlertConditionDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
self._cmp_LimitAlertConditionDescriptorContainer(dc, dc2)
def test_getContextStates(self):
facility = 'HOSP42'
poc = 'Care Unit 1'
bed = 'my bed'
loc = SdcLocation(fac=facility, poc=poc, bed=bed)
for sdcDevice in self._alldevices:
sdcDevice.mdib.setLocation(loc)
contextService = sdcDevice._handler._ContextDispatcher
endpoint_reference = '123'
getEnv = self._mkGetRequest(sdcDevice,
contextService.port_type_string,
'GetContextStates', endpoint_reference)
receivedEnv = AddressedSoap12Envelope.fromXMLString(
getEnv.as_xml())
httpHeader = {}
response = contextService.dispatchSoapRequest(
None, httpHeader, receivedEnv)
print(response.as_xml(pretty=True))
response.validateBody(sdcDevice.mdib.bicepsSchema.bmmSchema)
_ns = sdcDevice.mdib.nsmapper # shortcut
query = '*/{}[@{}="{}"]'.format(
_ns.docName(Prefix.MSG, 'ContextState'),
_ns.docName(Prefix.XSI, 'type'),
_ns.docName(Prefix.PM, 'LocationContextState'))
locationContextNodes = response.bodyNode.xpath(
query, namespaces=_ns.docNssmap)
self.assertEqual(len(locationContextNodes), 1)
identificationNode = locationContextNodes[0].find(
domTag('Identification'))
if sdcDevice is self.sdcDevice_final:
self.assertEqual(identificationNode.get('Extension'),
'{}///{}//{}'.format(facility, poc, bed))
else:
self.assertEqual(identificationNode.get('Extension'),
'{}/{}/{}'.format(facility, poc, bed))
locationDetailNode = locationContextNodes[0].find(
domTag('LocationDetail'))
self.assertEqual(locationDetailNode.get('PoC'), poc)
self.assertEqual(locationDetailNode.get('Bed'), bed)
self.assertEqual(locationDetailNode.get('Facility'), facility)
print(response.as_xml(pretty=True))
def test_episodicContextReportEvent(self):
''' verify that an event message is sent to subscriber and that message is valid'''
# directly inject a subscription event, this test is not about starting subscriptions
for sdcDevice in self._allDevices:
testSubscr = mockstuff.TestDevSubscription(sdcDevice.mdib.sdc_definitions.Actions.EpisodicContextReport, sdcDevice.mdib.bicepsSchema)
sdcDevice.subscriptionsManager._subscriptions.addObject(testSubscr)
patientContextDescriptor = sdcDevice.mdib.descriptions.NODETYPE.getOne(namespaces.domTag('PatientContextDescriptor'))
descriptorHandle = patientContextDescriptor.handle
with sdcDevice.mdib.mdibUpdateTransaction() as mgr:
st = mgr.getContextState(descriptorHandle)
st.PatientType = pmtypes.PatientType.ADULT
self.assertEqual(len(testSubscr.reports), 1)
response = testSubscr.reports[0]
response.validateBody(sdcDevice.mdib.bicepsSchema.bmmSchema)
def test_EnumStringMetricDescriptorContainer(self):
dc = descriptorcontainers.EnumStringMetricDescriptorContainer(
nsmapper=self.nsmapper,
nodeName=namespaces.domTag('MyDescriptor'),
handle='123',
parentHandle='456',
)
dc.AllowedValue = [pmtypes.AllowedValue('abc')]
node = dc.mkNode()
print(etree_.tostring(node, pretty_print=True))
dc2 = descriptorcontainers.EnumStringMetricDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
self.assertEqual(dc.AllowedValue, dc2.AllowedValue)
def test_RealTimeSampleArrayMetricStateContainer(self):
dc = descriptorcontainers.RealTimeSampleArrayMetricDescriptorContainer(
nsmapper=self.nsmapper,
nodeName='MyDescriptor',
handle='123',
parentHandle='456')
def verifyEqual(origin, copied):
self.assertEqual(copied.metricValue.Samples,
origin.metricValue.Samples)
self.assertEqual(copied.metricValue.DeterminationTime,
origin.metricValue.DeterminationTime)
self.assertEqual(copied.metricValue.Annotation,
origin.metricValue.Annotation)
self.assertEqual(copied.metricValue.ApplyAnnotations,
origin.metricValue.ApplyAnnotations)
self._verifyAbstractStateContainerDataEqual(copied, origin)
sc = statecontainers.RealTimeSampleArrayMetricStateContainer(
nsmapper=self.nsmapper, descriptorContainer=dc, node=None)
sc.mkMetricValue()
self.assertEqual(sc.nodeName, namespaces.domTag('State'))
self.assertTrue(isinstance(sc.metricValue, pmtypes.SampleArrayValue))
sc.metricValue.Samples = [1, 2, 3, 4, 5.5]
sc.metricValue.DeterminationTime = 1234567
sc.metricValue.Annotations = []
sc.metricValue.ApplyAnnotations = []
sc.ActivationState = 'act'
#test creation from node
node = sc.mkStateNode()
sc2 = statecontainers.RealTimeSampleArrayMetricStateContainer(
nsmapper=self.nsmapper, descriptorContainer=dc, node=node)
verifyEqual(sc, sc2)
#test update from node
sc.metricValue.Samples = [5.5, 6.6]
sc.metricValue.DeterminationTime = 2345678
sc.metricValue.Annotations = [
pmtypes.Annotation(pmtypes.CodedValue('a', 'b'))
]
sc.metricValue.ApplyAnnotations = [pmtypes.ApplyAnnotation(1, 2)]
sc.incrementState()
node = sc.mkStateNode()
sc2.updateFromNode(node)
verifyEqual(sc, sc2)
def test_AlertConditionDescriptorContainer(self):
dc = descriptorcontainers.AlertConditionDescriptorContainer(
nsmapper=self.nsmapper,
nodeName=namespaces.domTag('MyDescriptor'),
handle='123',
parentHandle='456',
)
# create copy with default values
node = dc.mkNode()
dc2 = descriptorcontainers.AlertConditionDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
self._cmp_AlertConditionDescriptorContainer(dc, dc2)
# set values, test updateFromNode
dc.Source = [
pmtypes.ElementWithTextOnly('A'),
pmtypes.ElementWithTextOnly('B')
]
dc.Cause = [
pmtypes.CauseInfo(remedyInfo=pmtypes.RemedyInfo(
[pmtypes.LocalizedText('abc'),
pmtypes.LocalizedText('def')]),
descriptions=[
pmtypes.LocalizedText('descr1'),
pmtypes.LocalizedText('descr2')
]),
pmtypes.CauseInfo(remedyInfo=pmtypes.RemedyInfo(
[pmtypes.LocalizedText('123'),
pmtypes.LocalizedText('456')]),
descriptions=[
pmtypes.LocalizedText('descr1'),
pmtypes.LocalizedText('descr2')
])
]
dc.Kind = 'cont'
dc.Priority = 'High'
node = dc.mkNode()
dc2.updateDescrFromNode(node)
self._cmp_AlertConditionDescriptorContainer(dc, dc2)
# create copy with values set
dc2 = descriptorcontainers.AlertConditionDescriptorContainer.fromNode(
nsmapper=self.nsmapper, node=node, parentHandle='467')
self._cmp_AlertConditionDescriptorContainer(dc, dc2)
def __init__(self,
wsdiscovery,
my_uuid,
mdib_xml_string,
validate=True,
sslContext=None,
logLevel=logging.INFO,
log_prefix='',
chunked_messages=False):
model = DPWSThisModel(
manufacturer='Draeger CoC Systems',
manufacturerUrl='www.draeger.com',
modelName='SomeDevice',
modelNumber='1.0',
modelUrl='www.draeger.com/whatever/you/want/model',
presentationUrl='www.draeger.com/whatever/you/want/presentation')
device = DPWSThisDevice(friendlyName='Py SomeDevice',
firmwareVersion='0.99',
serialNumber='12345')
# log_prefix = '' if not ident else '<{}>:'.format(ident)
deviceMdibContainer = DeviceMdibContainer.fromString(
mdib_xml_string, log_prefix=log_prefix)
# set Metadata
mdsDescriptor = deviceMdibContainer.descriptions.NODETYPE.getOne(
namespaces.domTag('MdsDescriptor'))
mdsDescriptor.Manufacturer.append(pmtypes.LocalizedText(u'Dräger'))
mdsDescriptor.ModelName.append(
pmtypes.LocalizedText(model.modelName[None]))
mdsDescriptor.SerialNumber.append(
pmtypes.ElementWithTextOnly('ABCD-1234'))
mdsDescriptor.ModelNumber = '0.99'
mdsDescriptor.updateNode()
super(SomeDevice, self).__init__(
wsdiscovery,
my_uuid,
model,
device,
deviceMdibContainer,
validate,
# registerDefaultOperations=True,
sslContext=sslContext,
logLevel=logLevel,
log_prefix=log_prefix,
chunked_messages=chunked_messages)
def _test_ClockDescriptorContainer(self, cls):
dc = cls(
nsmapper=self.nsmapper,
nodeName=namespaces.domTag('MyDescriptor'),
handle='123',
parentHandle='456',
)
# create copy with default values
node = dc.mkNode()
dc2 = cls.fromNode(nsmapper=self.nsmapper,
node=node,
parentHandle='467')
self.assertEqual(dc.TimeProtocol, dc2.TimeProtocol)
self.assertEqual(dc.Resolution, dc2.Resolution)
dc.TimeProtocol = [
pmtypes.CodedValue('abc', 'def'),
pmtypes.CodedValue('123', '456')
]
dc.Resolution = 3.14
node = dc.mkNode()
dc2.updateDescrFromNode(node)
self.assertEqual(dc.TimeProtocol, dc2.TimeProtocol)
self.assertEqual(dc.Resolution, dc2.Resolution)
dpwsDevice = sdc11073.pysoap.soapenvelope.DPWSThisDevice(friendlyName='TestDevice',
firmwareVersion='Version1',
serialNumber='12345')
if ca_folder:
ssl_context = mk_ssl_context_from_folder(ca_folder, cyphers_file=None,
ssl_passwd=ssl_passwd)
else:
ssl_context = None
sdcDevice = sdc11073.sdcdevice.sdcdeviceimpl.SdcDevice(wsd, my_uuid, dpwsModel, dpwsDevice, my_mdib,
sslContext=ssl_context)
sdcDevice.startAll()
validators = [sdc11073.pmtypes.InstanceIdentifier('Validator', extensionString='System')]
sdcDevice.setLocation(loc, validators)
patientDescriptorHandle = my_mdib.descriptions.nodeName.get(domTag('PatientContext'))[0].handle
with my_mdib.mdibUpdateTransaction() as mgr:
patientContainer = mgr.getContextState(patientDescriptorHandle)
patientContainer.Givenname = "Given"
patientContainer.Middlename = "Middle"
patientContainer.Familyname = "Familiy"
patientContainer.Birthname = "Birthname"
patientContainer.Title = "Title"
patientContainer.ContextAssociation = "Assoc"
identifiers = []
patientContainer.Identification = identifiers
descs = list(sdcDevice.mdib.descriptions.objects)
descs.sort(key=lambda x: x.handle)
metric = None
alertCondition = None
def testRecording(self):
testFile = "testFile"
# create and start recorder
rec = sdc11073.recording.ClientRecorder(self.sdcClientCocoFinal,
".",
filename=testFile)
rec.startRecording()
self.cleanUpDirs.append(rec.currentRecordingPath)
# make changes to the mdib
with self.sdcDeviceCoCoFinal.mdib.mdibUpdateTransaction(
setDeterminationTime=False) as mgr:
mst = mgr.getMetricState('0x34F00100')
if mst.metricValue is None:
mst.mkMetricValue()
mst.metricValue.Value = 12
mst.metricValue.Validity = 'Vld'
mst.metricValue.DeterminationTime = time.time()
metricDescriptor = mgr.getDescriptor('0x34F00100')
metricDescriptor.DeterminationPeriod = 29.0
numericMetricDescriptorContainer = NumericMetricDescriptorContainer(
nsmapper=self.sdcDeviceCoCoFinal.mdib.nsmapper,
nodeName=namespaces.domTag('Metric'),
handle="testHandle",
parentHandle='2.1.1.1' #"COCO_2827", #""COCO_3120",
)
numericMetricDescriptorContainer.Type = CodedValue('11921', 'sys')
numericMetricDescriptorContainer.Unit = CodedValue('11921', 'sys')
numericMetricDescriptorContainer.Resolution = 0.01
mgr.createDescriptor(numericMetricDescriptorContainer)
with self.sdcDeviceCoCoFinal.mdib.mdibUpdateTransaction(
setDeterminationTime=False) as mgr:
metricState = mgr.getMetricState("testHandle")
metricState.Validity = 'Vld'
time.sleep(1)
mdsHandle = self.sdcDeviceCoCoFinal.mdib.descriptions.NODETYPE.getOne(
sdc11073.namespaces.domTag('MdsDescriptor')).handle
with self.sdcDeviceCoCoFinal.mdib.mdibUpdateTransaction() as mgr:
tst = mgr.getComponentState(mdsHandle)
tst.ActivationState = "StndBy"
time.sleep(1)
with self.sdcDeviceCoCoFinal.mdib.mdibUpdateTransaction(
setDeterminationTime=True) as mgr:
acst = mgr.getAlertState('0xD3C00100')
acst.Presence = False
time.sleep(1)
with self.sdcDeviceCoCoFinal.mdib.mdibUpdateTransaction(
setDeterminationTime=True) as mgr:
asst = mgr.getAlertState(
'0xD3C00100.loc.Vis') #('AlertSignal_0xD3C00100_Aud')
asst.ActivationState = 'On'
time.sleep(1)
patientDescriptorContainer = self.sdcDeviceCoCoFinal.mdib.descriptions.NODETYPE.getOne(
sdc11073.namespaces.domTag('PatientContextDescriptor'))
# create a patient locally on device, then test update from client
with self.sdcDeviceCoCoFinal.mdib.mdibUpdateTransaction() as mgr:
st = mgr.getContextState(patientDescriptorContainer.handle)
st.Givenname = 'Max123'
st.Middlename = 'Willy'
st.Birthname = 'Mustermann \n'
st.Familyname = 'Musterfrau'
st.Title = 'Rex'
st.Sex = 'M'
st.PatientType = pmtypes.PatientType.ADULT
st.Height = sdc11073.pmtypes.Measurement(
88.2, sdc11073.pmtypes.CodedValue('abc', 'def'))
st.Weight = sdc11073.pmtypes.Measurement(
68.2, sdc11073.pmtypes.CodedValue('abc'))
st.Race = sdc11073.pmtypes.CodedValue('123', 'def')
newLocation = SdcLocation(fac='tasdaklx',
poc='CsadU1',
bed='cocoDraft10Bed')
self.sdcDeviceCoCoFinal.setLocation(newLocation, [])
paw = waveforms.SawtoothGenerator(min_value=0,
max_value=10,
waveformperiod=1.1,
sampleperiod=0.01)
self.sdcDeviceCoCoFinal.mdib.registerWaveformGenerator(
'0x34F05500', paw)
# record some waveforms and then stop
for x in range(20):
time.sleep(1)
# make changes to the mdib
with self.sdcDeviceCoCoFinal.mdib.mdibUpdateTransaction(
setDeterminationTime=False) as mgr:
mst = mgr.getMetricState('0x34F00100')
mst.metricValue.Value = x
with self.sdcDeviceCoCoFinal.mdib.mdibUpdateTransaction(
setDeterminationTime=True) as mgr:
asst = mgr.getAlertState(
'0xD3C00100.loc.Vis') #('AlertSignal_0xD3C00100_Aud')
asst.ActivationState = 'Off'
time.sleep(1)
rec.stopRecording()
# verify recording has stopped by monitoring the file size
recordingFile = os.path.join(rec.currentRecordingPath,
testFile) + ".rec"
currentSize = os.path.getsize(recordingFile)
time.sleep(1)
self.assertEqual(currentSize, os.path.getsize(recordingFile))
#
# verify contents have metric and real time updates
with open(recordingFile, 'r') as f:
version = f.readline()
self.assertTrue("pysdc ver" in version)
mdib = f.readline()
self.assertTrue("GetMdibResponse" in mdib)
for line in f:
nodeString = line.split("|", 1)[1]
if nodeString.startswith("u'"):
nodeString = nodeString[2:-2]
else:
nodeString = nodeString[1:-2]
node = lxml.etree.fromstring(nodeString)
if node.tag == namespaces.msgTag(
'DescriptionModificationReport'):
val = node.xpath('//dom:MetricValue',
namespaces=namespaces.nsmap)
self.assertEqual(val[0].attrib['Value'], '12')
f.close()
break
#verify archive has been created
rec.archive()
expectedZipFile = os.path.join(rec.currentRecordingPath,
testFile) + ".zip"
self.assertTrue(os.path.exists(expectedZipFile))
rec_file = os.path.join(rec.currentRecordingPath, testFile) + ".rec"
player = sdc11073.recording.MdibPlayer()
mdib = player.readRecording(rec_file)
model = DPWSThisModel(manufacturer="Draeger",
manufacturerUrl="draeger.com",
modelName="testMOdel",
modelNumber="231412411241",
modelUrl="draeger.com/testMOdel",
presentationUrl="draeger.com/testMOdel")
device = DPWSThisDevice(friendlyName="SuperDevice",
firmwareVersion="v1.23",
serialNumber="MISAD31245124")
self._publishingDevice = SdcDevice(self.wsdiscovery, uuid.uuid1(),
model, device, mdib)
# commLogger = commlog.CommLogger(log_folder="testcomm",
# log_out=True,
# log_in=False,
# broadcastIpFilter=None)
# commlog.defaultLogger = commLogger
self._publishingDevice.startAll()
loca = SdcLocation(fac='Noneas', poc='CU1', bed='cocoDraft6Bed')
self._publishingDevice.setLocation(loca, [])
player.play(self._publishingDevice, loop=True)
time.sleep(40)
player.stop()
def test_AbstractContextStateContainer(self):
def verifyEqual(origin, copied):
self.assertEqual(copied.ContextAssociation,
origin.ContextAssociation)
self.assertEqual(copied.BindingMdibVersion,
origin.BindingMdibVersion)
self.assertEqual(copied.UnbindingMdibVersion,
origin.UnbindingMdibVersion)
self.assertEqual(copied.BindingStartTime, origin.BindingStartTime)
self.assertEqual(copied.BindingEndTime, origin.BindingEndTime)
self.assertEqual(copied.Validator, origin.Validator)
self.assertEqual(copied.Identification, origin.Identification)
self._verifyAbstractStateContainerDataEqual(copied, origin)
sc = statecontainers.AbstractContextStateContainer(
nsmapper=self.nsmapper, descriptorContainer=self.dc, node=None)
self.assertEqual(sc.ContextAssociation, 'No')
self.assertEqual(sc.BindingMdibVersion, None)
self.assertEqual(sc.UnbindingMdibVersion, None)
self.assertEqual(sc.BindingStartTime, None)
self.assertEqual(sc.BindingEndTime, None)
self.assertEqual(sc.Validator, [])
self.assertEqual(sc.Identification, [])
idents = [
pmtypes.InstanceIdentifier(
root='abc',
type_codedValue=pmtypes.CodedValue('abc', 'def'),
identifierNames=[pmtypes.LocalizedText('ABC')],
extensionString='123')
]
sc.Identification = idents
self.assertEqual(sc.Identification, idents)
validators = [
pmtypes.InstanceIdentifier(
root='ABC',
type_codedValue=pmtypes.CodedValue('123', '456'),
identifierNames=[pmtypes.LocalizedText('DEF')],
extensionString='321')
]
sc.Validator = validators
self.assertEqual(sc.Validator, validators)
for value in ('assoc', 'disassoc'):
sc.ContextAssociation = value
node = sc.mkStateNode()
self.assertEqual(node.get('ContextAssociation'), value)
for value in (12345.123, 67890.987):
sc.BindingStartTime = value
sc.BindingEndTime = value + 1
node = sc.mkStateNode()
self.assertEqual(
node.get('BindingStartTime'),
containerproperties.TimestampConverter.toXML(value))
self.assertEqual(
node.get('BindingEndTime'),
containerproperties.TimestampConverter.toXML(value + 1))
for value in (0, 42, 123):
sc.BindingMdibVersion = value
sc.UnbindingMdibVersion = value + 1
node = sc.mkStateNode()
self.assertEqual(node.get('BindingMdibVersion'),
containerproperties.IntegerConverter.toXML(value))
self.assertEqual(
node.get('UnbindingMdibVersion'),
containerproperties.IntegerConverter.toXML(value + 1))
node = etree_.Element(namespaces.domTag('State'),
attrib={
'StateVersion': '2',
'DescriptorHandle': '123',
'BindingStartTime': '1234567',
'BindingEndTime': '2345678',
'Handle': sc.Handle
})
sc.updateFromNode(node)
self.assertEqual(sc.BindingStartTime, 1234.567)
self.assertEqual(sc.BindingEndTime, 2345.678)
self.assertEqual(sc.node.get('BindingStartTime'), '1234567')
self.assertEqual(sc.node.get('BindingEndTime'), '2345678')
self.assertEqual(sc.Identification, [])
self.assertEqual(sc.Validator, [])
#test creation from node
sc.Identification = idents
sc.Validator = validators
node = sc.mkStateNode()
sc2 = statecontainers.AbstractContextStateContainer(
nsmapper=self.nsmapper, descriptorContainer=self.dc, node=node)
verifyEqual(sc, sc2)
ca_folder,
cyphers_file='device_cyphers.txt',
ssl_passwd=ssl_passwd)
else:
ssl_context = None
sdcDevice = sdc11073.sdcdevice.sdcdeviceimpl.SdcDevice(
wsd, my_uuid, dpwsModel, dpwsDevice, my_mdib, sslContext=ssl_context)
sdcDevice.startAll()
validators = [
sdc11073.pmtypes.InstanceIdentifier('Validator',
extensionString='System')
]
sdcDevice.setLocation(loc, validators)
patientDescriptorHandle = my_mdib.descriptions.nodeName.get(
domTag('PatientContext'))[0].handle
with my_mdib.mdibUpdateTransaction() as mgr:
patientContainer = mgr.getContextState(patientDescriptorHandle)
patientContainer.Givenname = "Given"
patientContainer.Middlename = "Middle"
patientContainer.Familyname = "Familiy"
patientContainer.Birthname = "Birthname"
patientContainer.Title = "Title"
patientContainer.ContextAssociation = "Assoc"
identifiers = []
patientContainer.Identification = identifiers
descs = list(sdcDevice.mdib.descriptions.objects)
descs.sort(key=lambda x: x.handle)
metric = None
alertCondition = None
def _removeMdsDescriptor(self):
handle = self._device.mdib.descriptions.NODETYPE.getOne(
domTag('MdsDescriptor')).handle #node.attrib['Handle']
with self._device.mdib.mdibUpdateTransaction() as mgr:
mgr.removeDescriptor(handle)
firmwareVersion='Version1',
serialNumber='12345')
# create a device (provider) class that will do all the SDC magic
sdcDevice = SdcDevice(ws_discovery=myDiscovery,
my_uuid=my_uuid,
model=dpwsModel,
device=dpwsDevice,
deviceMdibContainer=my_mdib)
# start the local device and make it discoverable
sdcDevice.startAll()
# set the local ensemble context to ease discovery based on ensemble ID
setLocalEnsembleContext(my_mdib, "MyEnsemble")
# set the location on our device
sdcDevice.setLocation(my_location)
# create one local numeric metric that will change later on
numMetrDescr = domTag("NumericMetricDescriptor")
# get all metrics from the mdib (as described in the file)
allMetricDescrs = [
c for c in my_mdib.descriptions.objects if c.NODETYPE == numMetrDescr
]
# now change all the metrics in one transaction
with my_mdib.mdibUpdateTransaction() as mgr:
for metricDescr in allMetricDescrs:
# get the metric state of this specific metric
st = mgr.getMetricState(metricDescr.handle)
# create a value in case it is not there yet
st.mkMetricValue()
# set the value and some other fields to a fixed value
st.metricValue.Value = 1.0
st.metricValue.ActiveDeterminationPeriod = "1494554822450"
st.metricValue.Validity = 'Vld'
