diff --git a/sandbox/logging/CentralLogger.py b/sandbox/logging/CentralLogger.py
new file mode 100644
index 0000000000000000000000000000000000000000..adb396ea3c7bb029ba8033ad00253ef11bc598ad
--- /dev/null
+++ b/sandbox/logging/CentralLogger.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""CentralLogger device server receiving logs from SendingDS server"""
+import sys
+import time
+import logging
+from PyTango import server, DeviceProxy, Database, DbDevInfo, DevState, DebugIt, AttrQuality, AttrWriteType, DispLevel
+from PyTango.server import Device, DeviceMeta, attribute, command, run, device_property
+
+
+"""CentralLogger device server class"""
+class CentralLogger(Device):
+ __metaclass__ = DeviceMeta
+
+ def init_device(self):
+ Device.init_device(self)
+ self.set_state(DevState.STANDBY)
+ self.info_stream("Init CentralLogger Device.")
+
+ @command(dtype_in='DevVarLongStringArray', dtype_out=None)
+ def SetCentralLoggingLevel(self, element_devices_and_levels):
+ CentralLoggingLevel = element_devices_and_levels[0][:]
+ CentralLoggingDevice = element_devices_and_levels[1][:]
+ i = 0
+ while i < len(CentralLoggingLevel[:]):
+ self.info_stream("%s,%s", CentralLoggingLevel[i], CentralLoggingDevice[i])
+ dev1 = DeviceProxy(CentralLoggingDevice[i])
+ dev1.centralLoggingLevel = CentralLoggingLevel[i]
+ property_names = ["logging_level",
+ "logging_target",
+ ]
+ dev_properties = dev1.get_property(property_names)
+ dev_properties["logging_level"] = ["DEBUG"]
+ dev_properties["logging_target"].append("device::central/cdev/cdev1")
+ dev1.put_property(dev_properties)
+ dev1.add_logging_target("device::central/cdev/cdev1")
+ i+=1
+
+ """Logs are received from all element devices at all levels.
+ Filtering happens within the log function depending upon
+ CentralLoggingLevel of each element device.
+ NOTE : This fiteration logic is still under consideration."""
+ @command(dtype_in='DevVarStringArray', dtype_out=None)
+ def log(self, details):
+ cmessage = details[3]
+ clevel = details[1]
+ tango_log_level = {"FATAL": 1, "ERROR": 2, "WARN": 3, "INFO": 4, "DEBUG": 5}
+ level_number = tango_log_level[clevel]
+ clogsource = details[2]
+ if clogsource == details[2]:
+ device = DeviceProxy(clogsource)
+ deviceLogLevel = device.centralLoggingLevel
+
+ if clevel == "FATAL" and level_number <= deviceLogLevel:
+ self.fatal_stream("%s : %s", clogsource, cmessage)
+ elif clevel == "ERROR" and level_number <= deviceLogLevel:
+ self.error_stream("%s : %s", clogsource, cmessage)
+ elif clevel == "WARN" and level_number <= deviceLogLevel:
+ self.warn_stream("%s : %s", clogsource, cmessage)
+ elif clevel == "INFO" and level_number <= deviceLogLevel:
+ self.info_stream("%s : %s", clogsource, cmessage)
+ elif clevel == "DEBUG" and level_number <= deviceLogLevel:
+ self.debug_stream("%s : %s", clogsource, cmessage)
+ else:
+ pass
+ else:
+ pass
+
+run((CentralLogger,))
diff --git a/sandbox/logging/ElementLogger.py b/sandbox/logging/ElementLogger.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d638533bde3468a362da852e97a01835a1a0f91
--- /dev/null
+++ b/sandbox/logging/ElementLogger.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""ElementLogger device server receiving logs from another device server"""
+import sys
+import time
+import logging
+from PyTango import server, DeviceProxy, Database, DbDevInfo, DevState, DebugIt, AttrQuality, AttrWriteType, DispLevel
+from PyTango.server import Device, DeviceMeta, attribute, command, run, device_property
+
+
+"""ElementLogger device server class"""
+class ElementLogger(Device):
+ __metaclass__ = DeviceMeta
+
+ def init_device(self):
+ Device.init_device(self)
+ self.__StorageLoggingLevel = 5 #Storage logging level for ElementLogger(Unused currently)
+ self.__ElementLoggingLevel = 5 #Element logging level for all Element devices(Unused currently)
+ self.set_state(DevState.STANDBY)
+ self.info_stream("Init ElementLogger Device.")
+
+ @command(dtype_in='DevVarLongStringArray', dtype_out=None)
+ def SetStorageLoggingLevel(self, storages):
+ StorageLoggingLevel = storages[0][:]
+ StorageLoggingDevice = storages[1][:]
+ i = 0
+ while i < len(StorageLoggingLevel[:]):
+ self.info_stream("%s,%s", StorageLoggingLevel[i], StorageLoggingDevice[i])
+ dev1 = DeviceProxy(StorageLoggingDevice[i])
+ dev1.storageLoggingLevel = StorageLoggingLevel[i]
+ i+=1
+
+ @command(dtype_in='DevVarLongStringArray', dtype_out=None)
+ def SetElementLoggingLevel(self, element_devices_and_levels):
+ ElementLoggingLevel = element_devices_and_levels[0][:]
+ ElementLoggingDevice = element_devices_and_levels[1][:]
+ i = 0
+ while i < len(ElementLoggingLevel[:]):
+ self.info_stream("%s,%s", ElementLoggingLevel[i], ElementLoggingDevice[i])
+ dev1 = DeviceProxy(ElementLoggingDevice[i])
+ dev1.elementLoggingLevel = ElementLoggingLevel[i]
+ property_names = ["logging_level",
+ "logging_target",
+ ]
+ dev_properties = dev1.get_property(property_names)
+ dev_properties["logging_level"] = ["DEBUG"]
+ dev_properties["logging_target"].append("device::ellogger/elem/elem1")
+ dev1.put_property(dev_properties)
+ dev1.add_logging_target("device::ellogger/elem/elem1")
+ i+=1
+
+ """Logs are received from all element devices at all levels.
+ Filtering happens within the log function depending upon
+ ElementLoggingLevel of each element device.
+ NOTE : This fiteration logic is still under consideration."""
+ @command(dtype_in='DevVarStringArray', dtype_out=None)
+ def log(self, details):
+ message = details[3]
+ level = details[1]
+ tango_log_level = {"FATAL": 1, "ERROR": 2, "WARN": 3, "INFO": 4, "DEBUG": 5}
+ level_number = tango_log_level[level]
+ logsource = details[2]
+ if logsource == details[2]:
+ device = DeviceProxy(logsource)
+ deviceLogLevel = device.elementLoggingLevel
+ if level == "FATAL" and level_number <= deviceLogLevel:
+ self.fatal_stream("%s : %s", logsource, message)
+ elif level == "ERROR" and level_number <= deviceLogLevel:
+ self.error_stream("%s : %s", logsource, message)
+ elif level == "WARN" and level_number <= deviceLogLevel:
+ self.warn_stream("%s : %s", logsource, message)
+ elif level == "INFO" and level_number <= deviceLogLevel:
+ self.info_stream("%s : %s", logsource, message)
+ elif level == "DEBUG" and level_number <= deviceLogLevel:
+ self.debug_stream("%s : %s", logsource, message)
+ else:
+ pass
+ else:
+ pass
+
+run((ElementLogger,))
diff --git a/sandbox/logging/Sending.py b/sandbox/logging/Sending.py
new file mode 100644
index 0000000000000000000000000000000000000000..624245b60d8f47b70f189eab3ed0761b4c84a28c
--- /dev/null
+++ b/sandbox/logging/Sending.py
@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""Sending Device server which is logged by ElementLogger and CentralLogger"""
+import sys
+import time
+import logging
+import logging.handlers
+import syslog
+from logging.handlers import SysLogHandler
+from PyTango import AttrQuality, AttrWriteType, DispLevel, DevState, DebugIt, Database, DbDevInfo, DeviceProxy
+from PyTango.server import Device, DeviceMeta, attribute, command, run, device_property
+
+logger = logging.getLogger("Sending")
+syslog = SysLogHandler(address='/dev/log', facility='user')
+formatter = logging.Formatter('%(name)s: %(levelname)s %(module)s %(message)r')
+syslog.setFormatter(formatter)
+logger.addHandler(syslog)
+
+"""Sending Device server class"""
+class Sending(Device):
+ __metaclass__ = DeviceMeta
+
+ """Attributes for setting logging levels for element storage and central"""
+ elementLoggingLevel = attribute(label="ElementLogginglevel", dtype=int,
+ fget="get_elementLoggingLevel",
+ fset="set_elementLoggingLevel",
+ doc="Sets element logging level")
+
+ storageLoggingLevel = attribute(label="StorgeLoggingLevel", dtype=int,
+ fget="get_storageLoggingLevel",
+ fset="set_storageLoggingLevel",
+ doc="Sets syslog logging level")
+
+ centralLoggingLevel = attribute(label="CentralLoggingLevel", dtype=int,
+ fget="get_centralLoggingLevel",
+ fset="set_centralLoggingLevel",
+ doc="Sets Central logging level")
+
+ def init_device(self):
+ Device.init_device(self)
+ self.set_state(DevState.STANDBY)
+ self.__elementLoggingLevel = 5
+ self.__storageLoggingLevel = 5
+ self.__centralLoggingLevel = 5
+ logger.setLevel(logging.DEBUG)
+
+ def get_elementLoggingLevel(self):
+ return self.__elementLoggingLevel
+
+ def set_elementLoggingLevel(self, elementLoggingLevel):
+ self.__elementLoggingLevel = elementLoggingLevel
+ return elementLoggingLevel
+
+ def get_centralLoggingLevel(self):
+ return self.__centralLoggingLevel
+
+ def set_centralLoggingLevel(self, centralLoggingLevel):
+ self.__centralLoggingLevel = centralLoggingLevel
+ return centralLoggingLevel
+
+ def get_storageLoggingLevel(self):
+ return self.__storageLoggingLevel
+
+ def set_storageLoggingLevel(self, storageLoggingLevel):
+ self.debug_stream("In set_StorageLogginglevel")
+ self.__storageLoggingLevel = storageLoggingLevel
+
+ if self.__storageLoggingLevel == 1:
+ logger.setLevel(logging.FATAL)
+ elif self.__storageLoggingLevel == 2:
+ logger.setLevel(logging.ERROR)
+ elif self.__storageLoggingLevel == 3:
+ logger.setLevel(logging.WARNING)
+ elif self.__storageLoggingLevel == 4:
+ logger.setLevel(logging.INFO)
+ elif self.__storageLoggingLevel == 5:
+ logger.setLevel(logging.DEBUG)
+ else:
+ logger.setLevel(logging.DEBUG)
+ return storageLoggingLevel
+
+ @command
+ def TurnOn(self):
+ # turn on the sending device.
+ self.set_state(DevState.ON)
+ self.debug_stream("TurnOn Sending DEBUG")
+ self.info_stream("TurnOn Sending INFO")
+ self.warn_stream("TurnOn Sending WARNING")
+ self.error_stream("TurnOn Sending ERROR")
+ self.fatal_stream("TurnOn Sending FATAL")
+
+ logger.debug("TurnOn Sending debug")
+ logger.info("TurnOn Sending info")
+ logger.warning("TurnOn Sending warn")
+ logger.error("TurnOn Sending error")
+ logger.fatal("TurnOn Sending fatal")
+
+ @command
+ def TurnOff(self):
+ # turn off the sending device
+ self.set_state(DevState.OFF)
+ self.debug_stream("TurnOff Sending DEBUG")
+ self.info_stream("TurnOff Sending INFO")
+ self.warn_stream("TurnOff Sending WARNING")
+ self.error_stream("TurnOff Sending ERROR")
+ self.fatal_stream("TurnOff Sending FATAL")
+
+ logger.debug("TurnOff Sending debug")
+ logger.info("TurnOff Sending info")
+ logger.warning("TurnOff Sending warn")
+ logger.error("TurnOff Sending error")
+ logger.fatal("TurnOff Sending fatal")
+
+run([Sending])
diff --git a/sandbox/logging/Verification.pdf b/sandbox/logging/Verification.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..23d3739ab7b91eac35de7e37b19f71986c1b685f
Binary files /dev/null and b/sandbox/logging/Verification.pdf differ