Skip to content
Snippets Groups Projects
Unverified Commit fcc03e6f authored by rajeshwarange's avatar rajeshwarange Committed by GitHub
Browse files

Merge pull request #70 from ska-sa/user/rajesh/ISFP-39-40/log_level

Added ElementLogger, CentralLogger, LogLevel attributes and set interfaces to levels
parents ef5e37ae c3d63013
Branches
Tags
No related merge requests found
#!/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,))
#!/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,))
#!/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])
File added
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment