def __init__(self, instance="MSTESTS1", msdevices=None, doordevices=None):
if not isinstance(msdevices, list):
msdevices = ["mstestp09/testts/t1r228"]
if not isinstance(doordevices, list):
doordevices = ["doortestp09/testts/t1r228"]
# information about tango writer
self.server = "MacroServer/%s" % instance
self.door = {}
self.ms = {}
# device proxy
self.dps = {}
for dv in msdevices:
self.ms[dv] = PyTango.DbDevInfo()
self.ms[dv]._class = "MacroServer"
self.ms[dv].server = self.server
self.ms[dv].name = dv
for dv in doordevices:
self.door[dv] = PyTango.DbDevInfo()
self.door[dv]._class = "Door"
self.door[dv].server = self.server
self.door[dv].name = dv
# server instance
self.instance = instance
self._psub = None
def createCounterTimerSimulatorInDB(self):
"""Registers the Counter Timer Simulator in the Database"""
if not self.needsCounterTimerSimulator():
return
# Create the motor controller simulator
ctrl_server_info = PyTango.DbDevInfo()
ctrl_server_info.name = self.ctsim_ctrl_dev_name
ctrl_server_info._class = 'SimuCoTiCtrl'
ctrl_server_info.server = 'SimuCoTiCtrl/' + self.ctsim_ds_instance
self.tango_db.add_device(ctrl_server_info)
# Create the counter timer simulators
cts = self.getCounterTimerSimulators()
ct_idx = 1
for ct in cts:
ct_info = PyTango.DbDevInfo()
ct_info.name = "%s/simct/test%03d" % (self.username, ct_idx)
ct_info._class = 'SimuCounter'
ct_info.server = 'SimuCoTiCtrl/' + self.ctsim_ds_instance
self.tango_db.add_device(ct_info)
self.tango_db.put_device_property(ct_info.name, ct['properties'])
ct_idx += 1
def createMotorSimulatorInDB(self):
"""Registers the Motor Simulator in the Database"""
if not self.needsMotorSimulator():
return
# Create the motor controller simulator
ctrl_server_info = PyTango.DbDevInfo()
ctrl_server_info.name = self.motsim_ctrl_dev_name
ctrl_server_info._class = 'SimuMotorCtrl'
ctrl_server_info.server = 'SimuMotorCtrl/' + self.motsim_ds_instance
self.tango_db.add_device(ctrl_server_info)
# Add the MaxError property
props = {'MaxError': [str(self.getMotorControllerSimulatorMaxError())]}
self.tango_db.put_device_property(ctrl_server_info.name, props)
# Create the motor simulators
mots = self.getMotorSimulators()
mot_idx = 1
for mot in mots:
mot_info = PyTango.DbDevInfo()
mot_info.name = "%s/simmot/test%03d" % (self.username, mot_idx)
mot_info._class = 'SimuMotor'
mot_info.server = 'SimuMotorCtrl/' + self.motsim_ds_instance
self.tango_db.add_device(mot_info)
self.tango_db.put_device_property(mot_info.name, mot['properties'])
mot_idx += 1
def create_component_device(device_name, component_name):
server_name = component_name
db = PyTango.Database()
comp = PyTango.DbDevInfo()
comp._class = "DServer"
comp.server = "component/" + server_name
comp.name = "dserver/component/" + server_name
db.add_device(comp)
dev_info = PyTango.DbDevInfo()
dev_info._class = device_name
dev_info.server = "component/" + server_name
dev_info.name = "sys/component/" + component_name
db.add_device(dev_info)
return server_name
def register_device(db,server_name,class_name,dev_name,dev_alias):
""" Register a device in DB """
#logger= logging.getLogger(__name__)
## Create a DevInfo
dev_info = PyTango.DbDevInfo()
dev_info.name = dev_name
dev_info._class = class_name
dev_info.server = server_name
## Add device to DB
try:
db.add_device(dev_info)
except PyTango.DevFailed as df:
#logger.error("Failed to add device %s to DB!",dev_name)
return 1
## Register alias
if dev_alias:
try:
db.put_device_alias(dev_name,dev_alias)
except PyTango.DevFailed as df:
#logger.error("Failed to register alias (%s) to device %s in DB!",dev_alias,dev_name)
return 1
return 0
def _create_macroserver(self,
name,
macropath,
pool_names,
version,
alias=None,
device_name=None):
db = self.get_database()
info = PyTango.DbDevInfo()
info.name = device_name
info._class = "MacroServer"
info.server = "MacroServer/" + name
db.add_device(info)
if alias:
db.put_device_alias(device_name, alias)
db.put_device_property(device_name, {
"MacroPath": macropath,
"Version": version,
"PoolNames": pool_names
})
ms = MacroServer(self,
name,
macropath,
pool_names,
version,
alias=alias,
device_name=device_name)
self._macroservers.append(ms)
db.cache().refresh()
return ms
def _create_pool(self,
name,
poolpath,
version,
alias=None,
device_name=None):
db = self.get_database()
info = PyTango.DbDevInfo()
info.name = device_name
info._class = "Pool"
info.server = "Pool/" + name
db.add_device(info)
if alias:
db.put_device_alias(device_name, alias)
db.put_device_property(device_name, {
"PoolPath": poolpath,
"Version": version
})
pool = Pool(self,
name,
poolpath,
version,
alias=alias,
device_name=device_name)
self._pools.append(pool)
db.cache().refresh()
return pool
def __init__(self, methodName):
""" constructor
:param methodName: name of the test method
"""
PyBenchmarkTargetDeviceTest.__init__(self, methodName)
self.instance = 'TEST'
self.device = 'test/cppbenchmarktarget/000'
self.new_device_info_benchmark = PyTango.DbDevInfo()
self.new_device_info_benchmark._class = "CppBenchmarkTarget"
self.new_device_info_benchmark.server = "CppBenchmarkTarget/%s" % \
self.instance
self.new_device_info_benchmark.name = self.device
self.proxy = None
home = expanduser("~")
serverfile = "%s/DeviceServers/CppBenchmarkTarget" % home
if os.path.isfile(serverfile):
self._startserver = "%s %s &" % (serverfile, self.instance)
else:
self._startserver = "CppBenchmarkTarget %s &" % self.instance
self._grepserver = \
"ps -ef | grep 'CppBenchmarkTarget %s' | grep -v grep" % \
self.instance
def __init__(self, methodName):
""" constructor
:param methodName: name of the test method
"""
PyBenchmarkTargetDeviceTest.__init__(self, methodName)
self.instance = 'TEST'
self.device = 'test/javabenchmarktarget/000'
self.new_device_info_benchmark = PyTango.DbDevInfo()
self.new_device_info_benchmark._class = "JavaBenchmarkTarget"
self.new_device_info_benchmark.server = "JavaBenchmarkTarget/%s" % \
self.instance
self.new_device_info_benchmark.name = self.device
self.proxy = None
# home = expanduser("~")
# serverfile = "%s/DeviceServers/JavaBenchmarkTarget" % home
# if os.path.isfile(serverfile):
self._startserver = \
"cd ../JavaBenchmarkTarget; " \
"CLASSPATH=/usr/share/java/JTango.jar:" \
"./target/JavaBenchmarkTarget-1.0.jar:$CLASSPATH ; " \
"export CLASSPATH; . /etc/tangorc; export TANGO_HOST; " \
"java org.tango.javabenchmarktarget.JavaBenchmarkTarget %s &" % \
(self.instance)
# else:
# self._startserver = "JavaBenchmarkTarget %s &" % self.instance
self._grepserver = \
"ps -ef | " \
"grep 'JavaBenchmarkTarget %s' | grep -v grep" % (self.instance)
def create_tango_server(self, server_name):
comp = PyTango.DbDevInfo()
comp._class = "DServer"
comp.server = '/'.join((self.device_family, server_name))
comp.name = '/'.join(('dserver', self.device_family, server_name))
self.tango_database.add_device(comp)
return server_name
def addNewDevice(self, device, klass=None):
"""
Register a device of this server in the DB (register the server if
not present)
e.g. to create Starter in an init script::
addNewDevice('sys/tg_test/foobar', klass='TangoTest')
:param klass: class name. If None passed, it defaults to the server
name (without instance name)
"""
if device in self._addedDevices:
_log.warning('%s already added. Skipping' % device)
return
if klass is None:
klass = self.ds_name.split('/')[0]
# in case the device is already defined, skipping...
db = PyTango.Database()
try:
db.import_device(device)
_log.warning('%s already exists. Skipping' % device)
return
except:
pass
# register the device,
# in case the server did not exist before this will define it
dev_info = PyTango.DbDevInfo()
dev_info.name = device
dev_info.klass = klass
dev_info.server = self.ds_name
db.add_device(dev_info)
# create proxy to dserver
self.dserver = PyTango.DeviceProxy(self.dserver_name)
# keep track of added devices
self._addedDevices.append(device)
def register_device(db,server_name,class_name,dev_name,dev_alias): """ Register a device in DB """ ## Create a DevInfo dev_info = PyTango.DbDevInfo() dev_info.name = dev_name dev_info._class = class_name dev_info.server = server_name ## Add device to DB try: db.add_device(dev_info) except PyTango.DevFailed as df: raise ## Register alias if dev_alias: try: ## Delete alias first in DB (if alias exist put_device_alias throws an exception) db.delete_device_alias(dev_alias) ## Set alias in DB db.put_device_alias(dev_name,dev_alias) except PyTango.DevFailed as df: raise return 0
def create_tango_device(self, component_class, component, device_family):
comp = PyTango.DbDevInfo()
comp._class = component_class
comp.server = '/'.join((self.device_family, self.server_name))
comp.name = '/'.join(('sys', device_family, component))
self.tango_database.add_device(comp)
return comp.name
def __init__(self, methodName):
""" constructor
:param methodName: name of the test method
"""
unittest.TestCase.__init__(self, methodName)
self.instance = 'TEST'
self.device = 'test/pybenchmarktarget/000'
self.new_device_info_benchmark = PyTango.DbDevInfo()
self.new_device_info_benchmark._class = "PyBenchmarkTarget"
self.new_device_info_benchmark.server = "PyBenchmarkTarget/%s" % \
self.instance
self.new_device_info_benchmark.name = self.device
self.proxy = None
if PY3:
if os.path.isfile("../PyBenchmarkTarget"):
self._startserver = \
"cd ..; python3 ./PyBenchmarkTarget %s &" % self.instance
else:
self._startserver = \
"python3 PyBenchmarkTarget %s &" % self.instance
else:
if os.path.isfile("../PyBenchmarkTarget"):
self._startserver = \
"cd ..; python2 ./PyBenchmarkTarget %s &" % self.instance
else:
self._startserver = \
"python2 PyBenchmarkTarget %s &" % self.instance
self._grepserver = \
"ps -ef | grep 'PyBenchmarkTarget %s' | grep -v grep" % \
self.instance
def __init__(self):
# information about tango writer
self.new_device_info_writer = PyTango.DbDevInfo()
self.new_device_info_writer._class = "NXSConfigServer"
self.new_device_info_writer.server = "NXSConfigServer/MCSTEST"
self.new_device_info_writer.name = "testp09/testmcs/testr228"
self._psub = None
def add_facade_devices_to_server(self, facades):
for facade in facades:
dev_info = PyTango.DbDevInfo()
dev_info.server = "FacadeDevice/elin"
dev_info._class = "FacadeDevice"
dev_info.name = facade
self.db.add_device(dev_info)
def setup_resource_manager_ds():
dev_info = PyTango.DbDevInfo()
dev_info.server = "ResourceManagerDS/test"
dev_info._class = "ResourceManager"
dev_info.name = "test/resource_manager/1"
db = PyTango.Database()
db.add_device(dev_info)
def __init__(self, device="testp09/testnrs/testr228", instance="NRSTEST"):
# information about tango writer
self.new_device_info_writer = PyTango.DbDevInfo()
self.new_device_info_writer._class = "NXSRecSelector"
self.new_device_info_writer.server = "NXSRecSelector/%s" % instance
self.new_device_info_writer.name = device
# server instance
self.instance = instance
self._psub = None
def __init__(self, device="testp09/testtdw/testr228", instance="TDWTEST"):
# information about tango writer
self.instance = instance
self.device = device
self.new_device_info_writer = PyTango.DbDevInfo()
self.new_device_info_writer._class = "NXSDataWriter"
self.new_device_info_writer.server = "NXSDataWriter/%s" % self.instance
self.new_device_info_writer.name = device
self._psub = None
def register_device(name, device_class, server_name, instance):
dev_info = PyTango.DbDevInfo()
dev_info.name = name
dev_info._class = device_class
dev_info.server = "{}/{}".format(server_name.split('.')[0], instance)
print """Attempting to register TANGO device {!r}
class: {!r} server: {!r}.""".format(dev_info.name, dev_info._class,
dev_info.server)
db = PyTango.Database()
db.add_device(dev_info)
def _create_door(self, alias, device_name):
db = self.get_database()
info = PyTango.DbDevInfo()
info.name = device_name
info._class = "Door"
info.server = "MacroServer/" + self._name
db.add_device(info)
if alias:
db.put_device_alias(device_name, alias)
door = Door(alias=alias, device_name=device_name)
self._doors.append(door)
return door
def create_new_server(self, server_name, class_name, devs_list):
"""It creates a new server in the database, using Jive's like input."""
#di = PyTango.DbDevInfo()
#di.server,di.class_name,di.name = server_name,class_name,devs_list[0]
#self.db.add_server(server_name,[di])
for dev in devs_list:
di = PyTango.DbDevInfo()
di.server, di._class, di.name = server_name, class_name, dev
self.db.add_device(di)
print 'added %s.%s.%s to Database' % (di.server, di._class,
di.name)
return
def createDataWriter(self, beamline, masterHost):
""" creates data writer
:param beamline: beamline name
:type beamline: :obj:`str`
:param masterHost: master host of data writer
:type masterHost: :obj:`str`
:returns: True if server was created
:rtype: :obj:`bool`
"""
if not beamline:
print("createDataWriter: no beamline given ")
return False
if not masterHost:
print("createDataWriter: no masterHost given ")
return False
class_name = 'NXSDataWriter'
server = class_name
server_name = server + '/' + masterHost
full_class_name = 'NXSDataWriter/' + masterHost
self.writer_name = "%s/nxsdatawriter/%s" % (beamline, masterHost)
if server_name not in self.db.get_server_list(server_name):
print("createDataWriter: creating %s" % server_name)
if server_name in self.db.get_server_list(server_name):
print("createDataWriter: DB contains already %s" % server_name)
return False
di = PyTango.DbDevInfo()
di.name = self.writer_name
di._class = class_name
di.server = server_name
self.db.add_device(di)
self.db.put_device_property(self.writer_name,
{'NumberOfThreads': 100})
elif (self.writer_name
not in self.db.get_device_class_list(server_name).value_string):
print("\ncreateDataWriter: %s already exists. "
"To change its device name please remove it." % server_name)
return False
hostname = socket.gethostname()
self._startupServer(full_class_name, 1, hostname, 1, self.writer_name)
return True
def __init__(self, device="writertestp09/testts/t1r228",
instance="WRITERTESTS1"):
# information about tango writer
self.new_device_info_writer = PyTango.DbDevInfo()
# information about tango writer class
self.new_device_info_writer._class = "NXSDataWriter"
# information about tango writer server
self.new_device_info_writer.server = "NXSDataWriter/%s" % instance
# information about tango writer name
self.new_device_info_writer.name = device
# server instance
self.instance = instance
self._psub = None
# device proxy
self.dp = None
def createPoolInDB(self):
"""Registers the Device Pool in the Database"""
if not self.needsPool():
return
# Create the device pool in the database
pool_server_info = PyTango.DbDevInfo()
pool_server_info.name = self.pool_dev_name
pool_server_info._class = 'Pool'
pool_server_info.server = 'Pool/' + self.pool_ds_instance
self.tango_db.add_device(pool_server_info)
# Add the PoolPath property
props = {'PoolPath': self.getPoolPath()}
self.tango_db.put_device_property(pool_server_info.name, props)
def __init__(self, name="mgtests1"):
instance = name.upper()
device = "mntgrp/pool/%s" % name
# information about tango writer
self.new_device_info_writer = PyTango.DbDevInfo()
# information about tango writer class
self.new_device_info_writer._class = "MeasurementGroup"
# information about tango writer server
self.new_device_info_writer.server = "MeasurementGroup/%s" % instance
# information about tango writer name
self.new_device_info_writer.name = device
# server instance
self.instance = instance
self._psub = None
# device proxy
self.dp = None
def testServerExists(self):
self.assertEqual(self.facadeCtrl.server_exists(), False)
devs = ["1", "2", "77", "44"]
for dev in devs:
dev_info = PyTango.DbDevInfo()
dev_info.server = "FacadeDevice/elin"
dev_info._class = "FacadeDevice"
dev_info.name = "fcd_something/to/test" + dev
self.db.add_device(dev_info)
self.assertEqual(self.facadeCtrl.server_exists(), True)
for dev in self.db.get_device_class_list("FacadeDevice/elin"):
if "/" in dev:
self.db.delete_device(dev)
self.assertEqual(self.facadeCtrl.server_exists(), False)
def _createTestDevice(self):
tangodb = PyTango.Database()
self.log("Creating a %s device in %s:%s" %
(DevName, tangodb.get_db_host(), tangodb.get_db_port()),
color=bcolors.HEADER)
devInfo = PyTango.DbDevInfo()
devInfo.name = DevName
devInfo._class = DevClass
devInfo.server = DevServer + "/" + DevInstance
tangodb.add_device(devInfo)
self.log("Server %s added" % (DevServer + "/" + DevInstance),
color=bcolors.OKBLUE)
propertyName = 'Instrument'
propertyValue = 'localhost'
property = PyTango.DbDatum(propertyName)
property.value_string.append(propertyValue)
self.log("Set property %s: %s" % (propertyName, propertyValue),
color=bcolors.OKBLUE)
tangodb.put_device_property(DevName, property)
def __init__(self, instance="MTS01", devices=None):
if not isinstance(devices, list):
devices = ["ttestp09/testts/mt1r228"]
# information about tango writer
self.server = "TestServer/%s" % instance
self.ts = {}
# device proxy
self.dps = {}
for dv in devices:
self.ts[dv] = PyTango.DbDevInfo()
self.ts[dv]._class = "TestServer"
self.ts[dv].server = self.server
self.ts[dv].name = dv
# server instance
self.instance = instance
self._psub = None
# device properties
self.device_prop = {
'DeviceBoolean': False,
'DeviceShort': 12,
'DeviceLong': 1234566,
'DeviceFloat': 12.4345,
'DeviceDouble': 3.453456,
'DeviceUShort': 1,
'DeviceULong': 23234,
'DeviceString': "My Sting"
}
# class properties
self.class_prop = {
'ClassBoolean': True,
'ClassShort': 1,
'ClassLong': -123555,
'ClassFloat': 12.345,
'ClassDouble': 1.23445,
'ClassUShort': 1,
'ClassULong': 12343,
'ClassString': "My ClassString",
}
def _createTestDevice(self):
tangodb = PyTango.Database()
self.log("Creating a {0} device in {1}:{2}".format(
DevName, tangodb.get_db_host(), tangodb.get_db_port()),
color=bcolors.HEADER)
devInfo = PyTango.DbDevInfo()
devInfo.name = DevName
devInfo._class = DevClass
devInfo.server = DevServer + "/" + DevInstance
tangodb.add_device(devInfo)
self.log("Server {0} added".format(DevServer + "/" + DevInstance),
color=bcolors.OKBLUE)
for (propertyName, propertyValue) in \
[['Instrument', 'localhost'],
['NumChannels', '4'], ['NumFunctions', '8']]:
_property = PyTango.DbDatum(propertyName)
_property.value_string.append(propertyValue)
self.log("Set property {0}: {1}".format(propertyName,
propertyValue),
color=bcolors.OKBLUE)
tangodb.put_device_property(DevName, _property)
