def __init__(self, filename=None, macro=None, **pars):
BaseFileRecorder.__init__(self)
self.base_filename = filename
self.macro = weakref.ref(macro) if macro else None
self.db = PyTango.Database()
if filename:
self.setFileName(self.base_filename)
def setModel(self, trim):
TaurusWidget.setModel(self, trim)
db = PyTango.Database()
if trim:
self.setWindowTitle("Trim coil panel: %s" % trim)
swb = str(
db.get_device_property(
trim, "SwitchBoardProxy")["SwitchBoardProxy"][0])
ps = str(
db.get_device_property(
trim, "PowerSupplyProxy")["PowerSupplyProxy"][0])
# check PS class
if db.get_class_for_device(ps) == "PulsePowerSupply":
# change ps panel to bimp ps panel (for kicker and pinger)
make_binpps_panel(self)
hack_circuitpanel(self, ps)
self.resize(700, 500)
# set model
self.tabs.setModel([trim, ps, trim, trim, swb])
else:
self.setWindowTitle("N/A")
self.circuit_widget.setModel(None)
# self.cycle_widget.setModel(None)
self.field_widget.setModel(None)
self.ps_widget.setModel(None)
self.magnets_widget.setModel(None)
self.switchboard_widget.setModel(None)
def getNodeID(self, axis):
"""
get the node id string from db
"""
db = PyTango.Database()
dict_nodeID = db.get_device_property(str(self.name), "NodeId")
return str(dict_nodeID["NodeId"][0])
def stop_servers(startswith_list):
astor = fn.Astor()
db = PyTango.Database()
datum = db.get_server_list()
for server_name in datum.value_string:
# Operate on servers starting with the specified strings
items = [
item for item in startswith_list if server_name.startswith(item)
]
if items:
try:
# TBD - add the
# astor.stop_server(server_name)
# success_output.append(server_name)
failed_output.append(server_name +
"(NO-OP IN STOPPING:{})".format(exc))
except Exception as exc:
logging.error("EXCEPTION in stopping {} {}".format(
server_name, exc))
failed_output.append(server_name +
"(EXC IN STOPPING:{})".format(exc))
else:
skipped_output.append(server_name + " (SKIPPED)")
def setUp(self):
"""Create dummy motor controller and dummy motor element
"""
super(ReadMotorPositionOutsideLim, self).setUp()
sar_type = 'Motor'
lib = 'DummyMotorController'
cls = 'DummyMotorController'
self.ctrl_name = get_free_alias(PyTango.Database(), "readposctrl")
self.pool.CreateController([sar_type, lib, cls, self.ctrl_name])
self.elem_name = get_free_alias(PyTango.Database(), "mot_test")
axis = 1
self.pool.CreateElement(
[sar_type, self.ctrl_name,
str(axis), self.elem_name])
self.elem = PyTango.DeviceProxy(self.elem_name)
self.elem.DefinePosition(0)
def setUp(self):
print("\nsetting up ...")
db = PyTango.Database()
db.add_device(self.new_device_info_benchmark)
db.add_server(self.new_device_info_benchmark.server,
self.new_device_info_benchmark)
self._psub = subprocess.call(self._startserver,
stdout=None,
stderr=None,
shell=True)
sys.stdout.write("waiting for server ")
found = False
cnt = 0
while not found and cnt < 1000:
try:
sys.stdout.write(".")
dp = PyTango.DeviceProxy(self.new_device_info_benchmark.name)
time.sleep(0.1)
if dp.state() == PyTango.DevState.ON:
found = True
except Exception:
found = False
cnt += 1
print("")
self.proxy = dp
def setUp(self):
print "tearing down ..."
db = PyTango.Database()
db.add_device(self.new_device_info_writer)
db.add_server(self.new_device_info_writer.server,
self.new_device_info_writer)
if os.path.isfile("../NXSConfigServer"):
self._psub = subprocess.call("cd ..; ./NXSConfigServer MCSTEST &",
stdout=None,
stderr=None,
shell=True)
else:
self._psub = subprocess.call("NXSConfigServer MCSTEST &",
stdout=None,
stderr=None,
shell=True)
print "waiting for server",
found = False
cnt = 0
while not found and cnt < 1000:
try:
print "\b.",
dp = PyTango.DeviceProxy(self.new_device_info_writer.name)
time.sleep(0.01)
if dp.state() == PyTango.DevState.ON:
found = True
found = True
except:
found = False
cnt += 1
print ""
def setProp(self, rc, name, value):
db = PyTango.Database()
name = "" + name[0].upper() + name[1:]
db.put_device_property(
self._sv.new_device_info_writer.name,
{name: value})
rc.Init()
def tearDown(self):
"""Remove the MacroServer instance and its properties file.
"""
self._msstarter.cleanDb(force=True)
self._msstarter = None
self.macroserver = None
self.door = None
db = PyTango.Database()
prop = db.get_device_property(self.ms_name, "EnvironmentDb")
ms_properties = prop["EnvironmentDb"]
if not ms_properties:
dft_ms_properties = os.path.join(
MacroServerClass.DefaultEnvBaseDir,
MacroServerClass.DefaultEnvRelDir)
ds_inst_name = self.ms_ds_name.split("/")[1]
ms_properties = dft_ms_properties % {
"ds_exec_name": "MacroServer",
"ds_inst_name": ds_inst_name
}
ms_properties = os.path.normpath(ms_properties)
extensions = [".bak", ".dat", ".dir"]
for ext in extensions:
name = ms_properties + ext
if not os.path.exists(name):
continue
try:
os.remove(name)
except Exception as e:
msg = "Not possible to remove macroserver environment file"
print(msg)
print(("Details: %s" % e))
def tearDown(self):
print("tearing down ...")
db = PyTango.Database()
db.delete_server(self.new_device_info_writer.server)
if sys.version_info > (3, ):
with subprocess.Popen(
"ps -ef | grep 'SimpleServer.py %s' | grep -v grep" %
self.instance,
stdout=subprocess.PIPE,
shell=True) as proc:
pipe = proc.stdout
res = str(pipe.read(), "utf8").split("\n")
for r in res:
sr = r.split()
if len(sr) > 2:
subprocess.call("kill -9 %s" % sr[1],
stderr=subprocess.PIPE,
shell=True)
pipe.close()
else:
pipe = subprocess.Popen(
"ps -ef | grep 'SimpleServer.py %s' | grep -v grep" %
self.instance,
stdout=subprocess.PIPE,
shell=True).stdout
res = str(pipe.read()).split("\n")
for r in res:
sr = r.split()
if len(sr) > 2:
subprocess.call("kill -9 %s" % sr[1],
stderr=subprocess.PIPE,
shell=True)
pipe.close()
def init_device(self):
self.debug_stream("In init_device()")
self.get_device_properties(self.get_device_class())
#----- PROTECTED REGION ID(EventsHandlerSrv.init_device) ENABLED START -----#
db = PyTango.Database()
class_name = 'EventStation'
list_of_devs = [
'/'.join((class_name, name))
for name in db.get_instance_name_list(class_name)
]
listOfDev = []
for mydev in list_of_devs:
tmp = db.get_device_class_list(mydev)
listOfDev.append(tmp[2])
print("TEST", listOfDev)
for device in listOfDev:
try:
print("SOTTOSCRIVI")
self.dev = PyTango.DeviceProxy(device)
eventoID = self.dev.subscribe_event(
"NewDirectory",
PyTango.EventType.CHANGE_EVENT,
self.HandlePushedEvent,
stateless=True) #
#eventoID = self.dev.subscribe_event("NewDirectory", PyTango.EventType.CHANGE_EVENT, self.HandlePushedEvent) #,[],True)#,stateless=
print(" Sottoscritto a ", device, eventoID)
except Exception:
print("str(e)")
def normalize_config(config):
"""Take a 'loose' config and return a new config that conforms to the
DSConfig format.
Current transforms:
- server instances (e.g. 'TangoTest/1') are split into a server
level and an instance level (e.g. 'TangoTest' -> '1'). This is to
convert "v1" format files to the "v2" format.
- "devices" toplevel; allows to change *existing* devices by just
adding them directly to a "devices" key in the config, instead
of having to list out the server, instance and class (since this
information can be gotten from the DB.)
"""
old_config = expand_config(config)
new_config = SetterDict()
if "servers" in old_config:
new_config.servers = old_config["servers"]
if "classes" in old_config:
new_config.classes = old_config["classes"]
if "devices" in old_config:
db = PyTango.Database()
for device, props in old_config["devices"].items():
try:
info = db.get_device_info(device)
except PyTango.DevFailed as e:
sys.exit("Can't reconfigure device %s: %s" %
(device, str(e[0].desc)))
srv, inst = info.ds_full_name.split("/")
new_config.servers[srv][inst][info.class_name][device] = props
return new_config.to_dict()
def setModel(self, device):
print self.__class__.__name__, "setModel", device
TaurusWidget.setModel(self, device)
# self.state_button.setModel(device)
if device:
self.form.setModel(
["%s/%s" % (device, attribute) for attribute in self.attrs])
self.status_label.setModel("%s/cyclingStatus" % device)
ps = str(PyTango.Database().get_device_property(
device, "PowerSupplyProxy")["PowerSupplyProxy"][0])
self.trend.setPaused()
self.trend.setModel(["%s/Current" % ps])
self.trend.setForcedReadingPeriod(0.2)
self.trend.showLegend(True)
# let's pause the trend when not cycling
self.cyclingState = self.getModelObj().getAttribute("cyclingState")
self.cyclingState.addListener(self.handle_cycling_state)
else:
if self.cyclingState:
self.cyclingState.removeListener(self.handle_cycling_state)
self.trend.setModel(None)
self.status_label.setModel(None)
def send_sms(self, numbers, message, extended=True, priority=2):
"""Send a given text message to the given numbers.
Args:
numbers (iterator): phone number as strings
message (str or unicode): body of the message
extended (bool): Not Implemented
priority (int): Not Implemented
SendSMS using SMSGateway class device serwer
"""
db = PyTango.Database()
class_name = 'SMSGateway'
try:
devs = [
'/'.join((class_name, name))
for name in db.get_instance_name_list(class_name)
]
list_of_devs = [
dev for dev in db.get_device_class_list(devs[0])
if '/' in dev and not dev.startswith('dserver')
]
device = PyTango.DeviceProxy(list_of_devs[0])
sms_message = ';'.join([numbers, message])
device.command_inout_asynch('sendSMS', sms_message, True)
except Exception as e:
print('PROBLEM to send sms {0}'.format(e))
def prepare_ORBendPoint(args, tango_args):
"""Try to get Tango *free property* (object name: ``ORBendPoint``,
property name: ``<server_name>/<instance_name>``) and set it via
environment variable only in two occasions:
- this one was not existing
- ``-ORBendPoint`` argument was not passed
"""
log_messages = []
server_name = args[0]
try:
instance_name = args[1]
except IndexError:
msg = ("Unknown %s instance name. " % server_name +
"Skipping ORBendPoint from free property configuration...")
log_messages.append(msg, )
return log_messages
env_name = "ORBendPoint"
if env_name in os.environ:
return log_messages
arg_name = "-" + env_name
if arg_name in tango_args:
return log_messages
db = PyTango.Database()
property_name = server_name + "/" + instance_name
env_val = get_free_property(db, env_name, property_name)
if env_val is not None:
os.environ[env_name] = env_val
log_messages.append(
("setting %s=%s from Tango DB free property", env_name, env_val))
return log_messages
def get_tango_host_from_user():
import PyTango
while True:
prompt = "Please enter a valid tango host (<host>:<port>): "
from_user = raw_input(prompt).strip()
try:
host, port = from_user.split(':')
try:
port = int(port)
try:
socket.gethostbyname(host)
try:
PyTango.Database(host, port)
return (host, port)
except:
exp = "No tango database found at %s:%d" % (host, port)
except:
exp = "Invalid host name %s" % host
except:
exp = "Port must be a number > 0"
except:
exp = "Invalid tango host. Must be in format <host>:<port>"
exp = "Invalid tango host. %s " % exp
print exp
def init_device(self):
self.debug_stream("In init_device:")
Device.init_device(self)
self.db = pt.Database()
self.set_state(pt.DevState.UNKNOWN)
self.debug_stream("Init camera controller {0}".format(
self.camera_name))
params = dict()
params["imageoffsetx"] = self.roi[0]
params["imageoffsety"] = self.roi[1]
params["imagewidth"] = self.roi[2]
params["imageheight"] = self.roi[3]
params["triggermode"] = "Off"
try:
if self.dev_controller is not None:
self.dev_controller.stop_thread()
except Exception as e:
self.error_info("Error stopping camera controller: {0}".format(e))
try:
self.setup_spectrometer()
self.dev_controller = SpectrometerCameraDeviceController(
self.camera_name, params, self.wavelengthvector_data,
self.max_value)
# self.dev_controller = CameraDeviceController(self.camera_name, params)
except Exception as e:
self.error_stream(
"Error creating camera controller: {0}".format(e))
return
self.debug_stream("init_device finished")
# self.set_state(pt.DevState.ON)
self.dev_controller.add_state_callback(self.change_state)
def get_lima_camera_type(server=None, cache=True):
"""
Returns the Lima camera type for the given server
:param server: full server name (ex: LimaCCDs/basler01)
[default: use current process args]
:type server: str
:param cache: use last value stored in cache
:type cache: bool
:return: the lima camera type for the given server (Ex: Basler)
:rtype: str
"""
global __LIMA_CAMERA_TYPE
try:
camera_type = __LIMA_CAMERA_TYPE
if cache:
return camera_type
except NameError:
pass
lima_dev_name = get_lima_device_name(server=server, cache=cache)
db = PyTango.Database()
prop_dict = db.get_device_property(lima_dev_name, 'LimaCameraType')
camera_type = prop_dict['LimaCameraType']
if not camera_type:
raise ValueError("LimaCameraType property not set")
camera_type = camera_type[0]
__LIMA_CAMERA_TYPE = camera_type
return camera_type
def get_device_class_map(server=None, cache=True):
"""
Retuns a dict of devices for the given server.
The dict key is a tango class name and the value is a list of
devices of that tango class name.
:param server: full server name (ex: LimaCCDs/basler01)
[default: use current process args]
:type server: str
:param cache: use last value stored in cache
:type cache: bool
:return: Returns dict<tango class name : list of device names>
:rtype: dict
"""
global __LIMA_CLASS_MAP
try:
dev_map = __LIMA_CLASS_MAP
if cache:
return dev_map
except NameError:
__LIMA_CLASS_MAP = {}
dev_map = __LIMA_CLASS_MAP
if server is None:
server = get_server_name()
db = PyTango.Database()
dev_list = db.get_device_class_list(server)
for class_name, dev_name in zip(dev_list[1::2], dev_list[::2]):
dev_names = dev_map.get(class_name)
if dev_names is None:
dev_map[class_name] = dev_names = []
dev_names.append(dev_name)
return dev_map
def updateMacroServer(self, door):
""" updates MacroServer and sardana pools for given door
:param door: door device name
:type door: :obj:`str`
"""
self.__macroserver = ""
self.__pools = []
host = None
port = None
if not door:
raise Exception("Door '%s' cannot be found" % door)
if ":" in door.split("/")[0] and len(door.split("/")) > 1:
host, port = door.split("/")[0].split(":")
db = PyTango.Database(host, int(port))
macroserver = MSUtils.getMacroServer(db, door)
else:
macroserver = MSUtils.getMacroServer(self.__db, door)
msp = TangoUtils.openProxy(macroserver)
pnames = msp.get_property("PoolNames")["PoolNames"]
if not pnames:
pnames = []
poolNames = list(set(pnames) - set(self.poolBlacklist))
poolNames = [
"%s/%s" % (door.split("/")[0], pn) if
(host and ":" not in pn) else pn for pn in poolNames
]
self.__pools = TangoUtils.getProxies(poolNames)
self.__macroserver = macroserver
def __get_db(host_port=None):
"""host_port == None: Use current DB whatever it is or create
default if doesn't exist
host_port == '' : use default db. If it is not the current db, switch
current db to it and return it
host_port == ... : if ... is not the current db, switch current db to it
and return it
"""
ip = get_ipapi()
user_ns = get_user_ns()
global _DB_SYMB
db = user_ns.get(_DB_SYMB)
if host_port is None:
if db is None:
host_port = __get_default_tango_host()
elif host_port == '':
host_port = __get_default_tango_host()
else:
host_port = host_port.strip().replace(" ", ":")
if host_port.count(":") == 0:
host_port += ":10000"
if host_port is not None:
host_port = str(host_port)
if db is None:
create_db = True
elif host_port is None:
create_db = False
else:
old_host_port = "%s:%s" % (db.get_db_host(), db.get_db_port())
create_db = old_host_port != host_port
if create_db:
try:
db = PyTango.Database(*host_port.split(":"))
user_ns["DB_NAME"] = host_port
except Exception as e:
if db:
print("\nCould not access Database %s:" % host_port)
print(str(e))
old_host_port = "%s:%s" % (db.get_db_host(), db.get_db_port())
print("Maintaining connection to Database", old_host_port)
user_ns["DB_NAME"] = old_host_port
else:
print("\nCould not access any Database. Make sure:")
print(
"\t- .tangorc, /etc/tangorc or TANGO_HOST environment is defined."
)
print("\t- the Database DS is running")
user_ns["DB_NAME"] = "OFFLINE"
# register the 'db' in the user namespace
user_ns.update({_DB_SYMB: db})
return db
def __init__(self, numberOfThreads):
""" constructor
:param numberOfThreads: number of threads
:type numberOfThreads: :obj:`str`
"""
self.__numberOfThreads = numberOfThreads
#: (:class:`PyTango.Database`) tango database
self.__db = PyTango.Database()
#: (:obj:`str`) nexus configuration variable name in ms
self.__nxsenv = "NeXusConfiguration"
#: (:obj:`str`) macro server device name
self.__macroserver = ""
#: (:obj:`list` <:obj:`PyTango.DeviceProxy`>) pool instances
self.__pools = []
#: (:obj:`list` <:obj:`str`>) black list of pools
self.poolBlacklist = []
#: (:obj:`list` <:obj:`str`>) pure variables
self.__pureVar = [
"AppendEntry", "ComponentsFromMntGrp", "DynamicComponents",
"DefaultDynamicLinks", "DefaultDynamicPath", "TimeZone",
"ConfigDevice", "WriterDevice", "Door", "MntGrp", "ScanDir"
]
def RetrieveFile(self, argin):
""" Retreive the specified Plexil File to the specified location
:param argin: sourcedestination
:type: PyTango.DevString
:return: result
:rtype: PyTango.DevBoolean """
self.debug_stream("In RetrieveFile()")
argout = False
#----- PROTECTED REGION ID(PlexilPlanStorage.RetrieveFile) ENABLED START -----#
try:
path = PyTango.Database().get_class_property(
sys.argv[0], "StorageDirPath")["StorageDirPath"][0]
argin = argin.split(";")
internalpath, filetype, dest = argin[0], argin[1], argin[2]
source = path + internalpath
# Query the database and update the Last_Retrieved if it is a Plan
if int(filetype) == 0:
session.query(Plan).filter(Plan.Name == internalpath).update(
{"Last_Retrieved": (datetime.now())})
# The ordering of cp after the query is important from client's POV
command = 'cp ' + source + ' ' + dest
val = subprocess.check_call(command, shell=True)
if val == 0:
session.commit()
argout = True
except Exception as e:
argout = False
session.rollback()
#----- PROTECTED REGION END -----# // PlexilPlanStorage.RetrieveFile
return argout
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 choose_db(url,default=None):
if ':' not in url and default is not None:
return default
import os
thost = os.getenv('TANGO_HOST') if ':' not in url else url.split('/')[0]
print 'TANGO_HOST=%s'%thost
return PyTango.Database(*thost.split(':'))
def read_IsStorageDirEmpty(self, attr):
self.debug_stream("In read_IsStorageDirEmpty()")
#----- PROTECTED REGION ID(PlexilPlanStorage.IsStorageDirEmpty_read) ENABLED START -----#
attr.set_value(False)
path = PyTango.Database().get_class_property(
sys.argv[0], "StorageDirPath")["StorageDirPath"][0]
if not os.listdir(path):
attr.set_value(True)
class BuiltinElementCreationTest(ElementCreationTestCase,
unittest.TestCase):
alias = get_free_alias(PyTango.Database(), "mot_test")
controller_infos = [('DummyMotorController',
'unittest',
(),
[(alias, 1)])
]
def prepare(self):
"""Prepares everything to be run"""
self.tango_db = PyTango.Database()
self.username = os.getlogin()
self.common_ds_instance = self.username + "_test"
self.prepareMotorSimulator()
self.prepareCounterTimerSimulator()
self.prepareDevicePool()
def __init__(self, filename=None, macro=None, **pars):
BaseFileRecorder.__init__(self)
self.base_filename = filename
if macro:
self.macro = macro
self.db = PyTango.Database()
if filename:
self.setFileName(self.base_filename)
def __init__(self):
""" constructor """
#: (:class:`PyTango.Database`) tango database
try:
self.__db = PyTango.Database()
except Exception as e:
print(str(e))
self.__db = None
