def test_exception(self):
try:
raise RuntimeError("BLA")
except:
with wrapped_stderr() as stderr:
log.exception("excepted exception", raise_exception=False)
output = stderr.getvalue()
self.assertEquals(
output,
"""ERROR: excepted exception
Traceback (most recent call last):
File "TestLogging.py", line 74, in test_exception
raise RuntimeError("BLA")
RuntimeError: BLA
""")
def main():
try:
delete_unused_emotion_axes()
except:
elog.error(
"Cannot delete unused emotion axes.",
raise_exception=False)
try:
py = PyTango.Util(sys.argv)
log_param = [param for param in sys.argv if "-v" in param]
if log_param:
log_param = log_param[0]
# print "-vN log flag found len=%d" % len(log_param)
if len(log_param) > 2:
tango_log_level = int(log_param[2:])
elif len(log_param) > 1:
tango_log_level = 4
else:
print "Emotion.py - EMOTION ERROR LOG LEVEL"
if tango_log_level == 1:
elog.level(40)
elif tango_log_level == 2:
elog.level(30)
elif tango_log_level == 3:
elog.level(20)
else:
elog.level(10)
else:
# by default : show INFO
elog.level(20)
tango_log_level = 0
print ""
elog.info(" ---------------------= EMotion PyTango Device Server =----------------------------")
# elog.info("tango log level=%d" % tango_log_level)
# elog.debug("Emotion.py debug message")
# elog.error("Emotion.py error message", raise_exception=False)
# Searches for emotion devices defined in tango database.
U = PyTango.Util.instance()
db = U.get_database()
device_list = get_devices_from_server().get('Emotion')
if device_list is not None:
_device = device_list[0]
elog.info(" Emotion.py - Emotion device : %s" % _device)
try:
_config_file = db.get_device_property(_device, "config_file")["config_file"][0]
except:
elog.info(" Emotion.py - 'config_file' property not present ?")
_config_file = None
first_run = False
else:
elog.error("[FIRST RUN] New server never started ? -> no database entry...", raise_exception=False)
elog.error("[FIRST RUN] NO CUSTOM COMANDS :( ", raise_exception=False)
elog.error("[FIRST RUN] Restart DS to havec CUSTOM COMMANDS", raise_exception=False)
first_run = True
py.add_class(EmotionClass, Emotion)
# py.add_class(EmotionAxisClass, EmotionAxis)
if not first_run:
if _config_file is not None:
elog.info(" Emotion.py - config file : " + bcolors.PINK + _config_file + bcolors.ENDC)
try:
TgGevent.execute(emotion.load_cfg, _config_file)
except:
elog.error("error (not present or syntax error?) in reading config file : %s" %
_config_file, raise_exception=False)
sys.excepthook(*sys.exc_info())
sys.exit(-1)
else:
# Get axis names defined in config file.
axis_names = emotion.config.axis_names_list()
else:
elog.info(" Emotion.py - " + bcolors.PINK + "beacon config" + bcolors.ENDC)
# Get axes names from property (= use beacon to get axis objects)
emotion.config.BACKEND = "beacon"
axis_names = db.get_device_property(_device, "axes")["axes"][0].split()
elog.debug("axis names list : %s" % axis_names)
for axis_name in axis_names:
elog.debug("Emotion.py : _____________ axis %s _____________" % axis_name)
try:
_axis = TgGevent.get_proxy(emotion.get_axis, axis_name)
except ConnectionException:
elog.error("beacon_server seems not running")
sys.exit(-1)
except:
print traceback.format_exc()
sys.exit(-1)
new_axis_class_class = types.ClassType("EmotionAxisClass_%s" % axis_name, (EmotionAxisClass,), {})
new_axis_class = types.ClassType("EmotionAxis_%s" % axis_name, (EmotionAxis,), {})
types_conv_tab = {
None: PyTango.DevVoid,
str: PyTango.DevString,
int: PyTango.DevLong,
float: PyTango.DevDouble,
bool: PyTango.DevBoolean,
"str": PyTango.DevString,
"int": PyTango.DevLong,
"float": PyTango.DevDouble,
"bool": PyTango.DevBoolean,
"None": PyTango.DevVoid,
"float_array": PyTango.DevVarFloatArray,
"double_array": PyTango.DevVarDoubleArray,
"long_array": PyTango.DevVarLongArray,
"string_array": PyTango.DevVarStringArray
}
"""
CUSTOM COMMANDS
"""
# Search and adds custom commands.
_cmd_list = _axis.custom_methods_list()
elog.debug("'%s' custom commands:" % axis_name)
new_axis_class_class.cmd_list = dict(EmotionAxisClass.cmd_list)
for (fname, (t1, t2)) in _cmd_list:
setattr(new_axis_class, fname, getattr(_axis, fname))
tin = types_conv_tab[t1]
tout = types_conv_tab[t2]
new_axis_class_class.cmd_list.update({fname: [[tin, ""], [tout, ""]]})
elog.debug(" %s (in: %s, %s) (out: %s, %s)" % (fname, t1, tin, t2, tout))
"""
SETTINGS AS ATTRIBUTES.
"""
elog.debug(" Emotion.py : %s : -------------- SETTINGS -----------------" % axis_name)
new_axis_class_class.attr_list = dict(EmotionAxisClass.attr_list)
for setting_name in _axis.settings():
if setting_name in ["velocity", "position", "dial_position", "state",
"offset", "low_limit", "high_limit", "acceleration", "_set_position"]:
elog.debug(" Emotion.py -- std SETTING %s " % (setting_name))
else:
_attr_name = setting_name
_setting_type = _axis.controller().axis_settings.convert_funcs[_attr_name]
_attr_type = types_conv_tab[_setting_type]
elog.debug(" Emotion.py -- adds SETTING %s as %s attribute" % (setting_name, _attr_type))
# Updates Attributes list.
new_axis_class_class.attr_list.update({_attr_name:
[[_attr_type,
PyTango._PyTango.AttrDataFormat.SCALAR,
PyTango._PyTango.AttrWriteType.READ_WRITE], {
'Display level': PyTango._PyTango.DispLevel.OPERATOR,
'format': '%10.3f',
'description': '%s : u 2' % _attr_name,
'unit': 'user units/s^2',
'label': _attr_name
}]})
# Creates functions to read and write settings.
def read_custattr(self, attr, _axis=_axis, _attr_name=_attr_name):
_val = _axis.get_setting(_attr_name)
print "in read_%s %s (%s)" % (_attr_name, _val, _axis.name())
attr.set_value(_val)
new_read_attr_method = types.MethodType(read_custattr, new_axis_class,
new_axis_class.__class__)
setattr(new_axis_class, "read_%s" % _attr_name, new_read_attr_method)
def write_custattr(self, attr, _axis=_axis, _attr_name=_attr_name):
data = attr.get_write_value()
print "in write_%s %s (%s)" % (_attr_name, data, _axis.name())
_axis.set_setting(_attr_name, data)
new_write_attr_method = types.MethodType(write_custattr, new_axis_class,
new_axis_class.__class__)
setattr(new_axis_class, "write_%s" % _attr_name, new_write_attr_method)
# End of custom command and settings
elog.debug("Emotion.py : Adds new Axis specific class.")
py.add_class(new_axis_class_class, new_axis_class)
elog.debug("Emotion.py : Class added.")
elog.debug("Emotion.py : intitialize server.")
U.server_init()
except PyTango.DevFailed:
print traceback.format_exc()
elog.exception(
"Error in server initialization")
sys.exit(0)
try:
emotion_admin_device_names = get_devices_from_server().get('Emotion')
if emotion_admin_device_names:
blname, server_name, device_number = emotion_admin_device_names[
0].split('/')
for axis_name in emotion.config.axis_names_list():
device_name = '/'.join((blname,
'%s_%s' % (server_name, device_number),
axis_name))
try:
elog.debug("Creating %s" % device_name)
U.create_device("EmotionAxis_%s" % axis_name, device_name)
except PyTango.DevFailed:
# print traceback.format_exc()
elog.debug("Device %s already defined in Tango database" % device_name)
pass
# If axis name is not already a tango alias,
# define it as an alias of the device.
try:
db.get_device_alias(axis_name)
except PyTango.DevFailed:
db.put_device_alias(device_name, axis_name)
elog.debug("Created alias %s for device %s" % (axis_name, device_name))
else:
# Do not raise exception to be able to use
# Jive device creation wizard.
elog.error("No emotion supervisor device",
raise_exception=False)
except PyTango.DevFailed:
print traceback.format_exc()
elog.exception(
"Error in devices initialization")
sys.exit(0)
U.server_run()