DCD.py

Go to the documentation of this file.

"""
HCE project, Python bindings, Distributed Tasks Manager application.
Event objects definitions.

@package: dc
@file DCD.py
@author Oleksii <developers.hce@gmail.com>
@link: http://hierarchical-cluster-engine.com/
@copyright: Copyright &copy; 2013-2014 IOIX Ukraine
@license: http://hierarchical-cluster-engine.com/license/
@since: 0.1
"""


import time
import logging  # pylint: disable=unused-import
import logging.config
import ConfigParser
from cement.core import foundation
# from transport.ConnectionBuilderLight import ConnectionBuilderLight
from app import Utils
from app.AdminInterfaceServer import AdminInterfaceServer  # pylint: disable=unused-import
import app.Consts as APP_CONSTS
from dc.ClientInterfaceService import ClientInterfaceService  # pylint: disable=unused-import
from dc.BatchTasksManager import BatchTasksManager  # pylint: disable=unused-import
from dc.BatchTasksManagerRealTime import BatchTasksManagerRealTime  # pylint: disable=unused-import
from dc.BatchTasksManagerProcess import BatchTasksManagerProcess  # pylint: disable=unused-import
from dc.SitesManager import SitesManager  # pylint: disable=unused-import
from transport.ConnectionBuilderLight import ConnectionBuilderLight


APP_NAME = "dc"
START_APP_LOG_MSG = "Start dc daemon."
STOP_APP_LOG_MSG = "Stop dc daemon."
PID_FILE = "../../../run/dc-daemon.pid"
APP_CONFIG_FILE = "../ini/dc-daemon.ini"
LOG_CONFIG_FILE = "../ini/dc-daemon_log.ini"
LOG_MSG_START_APP = "dc-daemon start"
LOG_MSG_CLOSE_APP = "Close dc daemon app"
ERR_MSG_CLOSE_APP = "Error close dc daemon app"
ERROR_LOAD_LOG_CONFIG_FILE = "Error loading logging config file. Exiting."
ERROR_LOAD_CONFIG = "Error loading config file. Exciting."


class DCD(foundation.CementApp):

  CREATE_APP_DELAY = 0
  START_APP_DELAY = 0
  JOIN_APP_DELAY = 0


  class Meta(object):
    label = APP_NAME
    def __init__(self):
      pass


  # #constructor
  # initialize default fields
  def __init__(self):
    # call base class __init__ method
    foundation.CementApp.__init__(self)
    self.logger = None
    self.threadObjs = None


  # #setup
  # setup application
  def setup(self):
    # call base class setup method
    foundation.CementApp.setup(self)


  # #run
  # run application
  def run(self):
    # call base class run method
    foundation.CementApp.run(self)

    # config section
    self.loadConfig()

    # load logger config file
    self.loadLogConfigFile()

    # load application sequence
    self.loadStartAppsSequence()

    # create threadObjs
    # strictly ordered sequence caused connection establishment order
    try:
      self.threadObjs = [self.createThreadObj(threadObj) for threadObj in self.threadObjs]
    except:
      self.logger.error("Exception during creation thread-based class!\n" + Utils.getTracebackInfo())
      raise

    # run apps
    # strictly ordered
    try:
      [self.startThreadObj(threadObj) for threadObj in self.threadObjs]
    except:
      self.logger.error("Exception during run thread-based class!\n" + Utils.getTracebackInfo())
      raise

    # wait for stop
    # strictly ordered
    try:
      [self.joinThreadObj(threadObj) for threadObj in self.threadObjs]
    except:
      self.logger.error("Exception during stop thread-based class!\n" + Utils.getTracebackInfo())
      raise


  # #createApp
  # create application's pool
  #
  # @param app_name application name which instance will be created
  # @return instance of created application
  def createThreadObj(self, app_name):
    app = None
    try:
      app = (app_name, eval(app_name)(self.config, ConnectionBuilderLight()))  # pylint: disable = I0011, eval-used
      app[1].setName(app[0])
      self.logger.debug("%s has been created!", app_name)
      time.sleep(self.CREATE_APP_DELAY)
    except:
      self.logger.error("Exception has been thrown during %s creation!", app_name)
      raise
    return app


  # #joinThreadObj
  # join threadObjs
  #
  # @param app_name application name which instance will be stopped
  # @return None
  def joinThreadObj(self, app):
    try:
      app[1].join()
      self.logger.debug("%s waiting for stopping!", app[0])
      time.sleep(self.JOIN_APP_DELAY)
    except:
      self.logger.error("Exception has been thrown during %s joining!", app[0])
      raise


  # #startApp
  # start application's pool
  #
  # @param app - application instance will be started
  def startThreadObj(self, app):
    try:
      app[1].setName(app[0])
      app[1].start()
      self.logger.debug("%s has been started!", app[0])
      time.sleep(self.START_APP_DELAY)
    except:
      self.logger.error("Exception has been thrown during %s start!", app[0])
      raise


  # #load config from file
  # load from cli argument or default config file
  def loadConfig(self):
    try:
      self.config = ConfigParser.ConfigParser()
      self.config.optionxform = str
      if self.pargs.config:
        self.config.read(self.pargs.config)
      else:
        raise Exception("Error load config")
        # self.config.read(APP_CONFIG_FILE)
    except Exception as err:
      print ERROR_LOAD_CONFIG + err.message
      raise


  # #load application's start sequence
  # the sequence is the list of class names separated by commas
  # in "Application" section "instantiateSequence" option
  def loadStartAppsSequence(self):
    self.logger.debug("Load application's start sequence.")
    self.threadObjs = self.config.get("Application", "instantiateSequence").split(",")


  # #load logging
  # load logging configuration (log file, log level, filters)
  #
  def loadLogConfigFile(self):
    try:
      log_conf_file = self.config.get("Application", "log")
      logging.config.fileConfig(log_conf_file)
      #self.logger = logging.getLogger(APP_NAME)
      # Logger initialization
      self.logger = logging.getLogger(APP_CONSTS.LOGGER_NAME)

    except Exception as err:
      print ERROR_LOAD_LOG_CONFIG_FILE + err.message
      raise


  # #close
  # close application
  def close(self, code=None):
    if self.logger is not None:
      self.logger.debug(LOG_MSG_CLOSE_APP)
    # call base class run method
    foundation.CementApp.close(self)