Esempio n. 1
0
    def __init__(self, config):
        # Initialize Logging
        self.log = logging.getLogger('autmon')

        # Initialize Members
        self.config = config
        self.running = False
        self.handlers = []
        self.modules = {}
        self.tasks = {}
        # Initialize Scheduler
        self.scheduler = ThreadedScheduler()
Esempio n. 2
0
class Server(object):
    """
    Server class loads and starts Handlers and Collectors
    """

    def __init__(self, config):
        # Initialize Logging
        self.log = logging.getLogger('autmon')

        # Initialize Members
        self.config = config
        self.running = False
        self.handlers = []
        self.modules = {}
        self.tasks = {}
        # Initialize Scheduler
        self.scheduler = ThreadedScheduler()

    def load_config(self):
        """
        Load the full config
        """

        configfile = os.path.abspath(self.config['configfile'])
        config = configobj.ConfigObj(configfile)
        config['configfile'] = self.config['configfile']

        self.config = config

    def load_handler(self, fqfn, fqcn):
        """
        Load Handler class named fqcn
        """
        # Load class
        fqname = 'handlers.' + fqfn + '.' + fqcn
        cls = load_class_from_name(fqname)
        # Check if cls is subclass of Handler
        if cls == Handler or not issubclass(cls, Handler):
            raise TypeError("%s is not a valid Handler" % fqcn)
        # Log
        self.log.debug("Loaded Handler: %s", fqcn)
        return cls

    def load_handlers(self):
        """
        Load handlers
        """
        for h in self.config['handlers'].sections:
            if h == 'default': continue

            try:
                if 'enabled' in self.config['handlers'][h].keys():
                    #if self.config['handlers'][h]['enabled'] == 'False':
                    if self.config['handlers'][h].get('enabled', 'False').strip() == 'False':
                        continue
                else:
                    self.log.debug("The %s not have enabled params", h)
                    continue

                # Load Handler Class
                if 'file_name' in self.config['handlers'][h].keys():
                    f = self.config['handlers'][h]['file_name']
                    cls = self.load_handler(f, h)
                else:
                    self.log.debug("The %s not have file_name params", h)
                    continue

                # Initialize Handler config
                handler_config = configobj.ConfigObj()
                # Merge default Handler default config
                handler_config.merge(self.config['handlers']['default'])
                # Check if Handler config exists
                if cls.__name__ in self.config['handlers']:
                    # Merge Handler config section
                    handler_config.merge(self.config['handlers'][cls.__name__])

                # Initialize Handler class
                self.handlers.append(cls(handler_config))

            except ImportError:
                # Log Error
                self.log.debug("Failed to load handler %s.%s. %s", f, h,
                               traceback.format_exc())
                continue

    def load_collectors(self):
        """
        Scan for collectors to load from path
        """
        # Initialize return value
        collectors = {}

        # Load all
        for c in self.config['collectors'].sections:
            if c == 'default': continue

            if 'enabled' in self.config['collectors'][c].keys():
                #if self.config['collectors'][c]['enabled'] == 'False':
                if self.config['collectors'][c].get('enabled', 'False').strip() == 'False':
                    continue
            else:
                self.log.debug("The %s not have enabled params", c)
                continue

            self.log.debug("Loading Collector: %s", c)

            configpath = os.path.join(self.config['server']['collectors_config_path'], c)
            configfile = os.path.join(configpath, c + ".conf")

            if os.path.exists(configfile):
                config = configobj.ConfigObj(os.path.abspath(configfile))
                # Add current collectors path to config file
                config['configpath'] = configpath
                config['configfile'] = configfile
                self.config['collectors'][c].merge(config)

                cls = self.config['collectors'][c]['class']

                if cls == "CMDCollector":
                    from autmon.collector_cmd import CMDCollector
                    collectors[c] = CMDCollector
                elif cls == "DB2SqlCollector":
                    from autmon.collector_db2_sql import DB2SqlCollector
                    collectors[c] = DB2SqlCollector
                elif cls == "DB2ProcCollector":
                    from autmon.collector_db2_proc import DB2ProcCollector
                    collectors[c] = DB2ProcCollector
                elif cls == "WasJythonCollector":
                    from autmon.collector_was_jpython import WasJythonCollector
                    collectors[c] = WasJythonCollector
            else:
                self.log.debug("Collector Config File Not found: %s(%s)", c, configfile)

        # Return Collector classes
        return collectors

    def init_collector(self, name, cls):
        """
        Initialize collector
        """
        collector = None
        try:
            # Initialize Collector
            collector = cls(name, self.config, self.handlers)
            # Log
            self.log.debug("Initialized Collector: %s(%s)", name, collector.__class__.__name__)
        except Exception:
            # Log error
            self.log.error("Failed to initialize Collector: %s(%s). %s",
                           name, cls, traceback.format_exc())

        # Return collector
        return collector

    def schedule_collector(self, c, interval_task=True):
        """
        Schedule collector
        """
        # Check collector is for realz
        if c is None:
            self.log.warn("Skipped loading invalid Collector: %s",
                          c.__class__.__name__)
            return

        if c.config['enabled'] != True:
            self.log.warn("Skipped loading disabled Collector: %s",
                          c.__class__.__name__)
            return

        # Get collector schedule
        for name, schedule in c.get_schedule().items():
            # Get scheduler args
            func, args, splay, interval = schedule

            # Check if Collecter with same name has already been scheduled
            if name in self.tasks:
                try:
                    self.scheduler.cancel(self.tasks[name])
                    # Log
                    self.log.debug("Canceled task: %s", name)
                except ValueError, e:
                    self.log.error("Canceled task not found: %s", e)

            method = scheduler_method.sequential

            if 'method' in c.config:
                if c.config['method'] == 'Threaded':
                    method = scheduler_method.threaded
                elif c.config['method'] == 'Forked':
                    method = scheduler_method.forked

            # Schedule Collector
            if interval_task and ('task_type' in c.config):
                if c.config['task_type'] == 'Interval':
                    task = self.scheduler.add_interval_task(func,
                                                            name,
                                                            splay,
                                                            interval,
                                                            method,
                                                            args,
                                                            None,
                                                            True)
                elif c.config['task_type'] == 'Weekday':
                    try:
                        weekdays = [int(a) for a in c.config['weekdays']]
                    except TypeError, e:
                        self.log.error("weekdays must be a sequence of numbers 1-7: %s", e)

                    try:
                        timeonday = [int(a) for a in c.config['timeonday']]
                    except TypeError, e:
                        self.log.error("timeonday must be a sequence of hour,minute: %s", e)

                    task = self.scheduler.add_daytime_task(func,
                                                            name,
                                                            weekdays,
                                                            None,
                                                            timeonday,
                                                            method,
                                                            args,
                                                            None)
                elif c.config['task_type'] == 'Monthday':
                    try:
                        monthdays = [int(a) for a in c.config['monthdays']]
                    except TypeError, e:
                        self.log.error("monthdays must be a sequence of numbers 1-31: %s", e)