Пример #1
0
 def start_composition(self, comp=None):
     """\brief Starts up a composition
     \param comp (\c string)      The composition. If None self.__composition is used
     \return     (\c ReturnValue) The result of the operation
     """
     if comp:
         self.__composition = comp
     self.__parser = CompositionParser(self.__composition)
     self.__comp_id = self.__parser.parse_comp_id()
     self.__comp_mngr = CompositionManager(self.__comp_id, blockmon,
                                           self.__logger)
     self.__comp_mngr.install(
         xml.dom.minidom.parseString(self.__composition))
     self.start_bm()
     return ReturnValue(ReturnValue.CODE_SUCCESS, "", None)
Пример #2
0
 def start_composition(self, comp=None):
     """\brief Starts up a composition
     \param comp (\c string)      The composition. If None self.__composition is used
     \return     (\c ReturnValue) The result of the operation
     """
     if comp:
         self.__composition = comp
     self.__parser = CompositionParser(self.__composition)
     self.__comp_id = self.__parser.parse_comp_id()
     self.__comp_mngr = CompositionManager(self.__comp_id, blockmon, self.__logger)
     self.__comp_mngr.install(xml.dom.minidom.parseString(self.__composition))
     self.start_bm()
     return ReturnValue(ReturnValue.CODE_SUCCESS, "", None)
Пример #3
0
class BMProcessManager:
    """\brief Controls a running blockmon process. Note that this class/file can be
              used directly as an executable (the method used by the blockmon daemon
              to spawn blockmon processes) or by creating an instance of the class
              (the method used for the blockmon CLI). For the former, the manager runs
              an XML-RPC server which the blockmon daemon uses to communicate with it.
              Further note that all xml-rpc operations return a pickled ReturnValue object.
    """
    bm_running = False

    def __init__(self,
                 comp=None,
                 bm_logger=None,
                 port=None,
                 is_comp_str=False):
        """\brief Initializes class
        \param comp       (\c string)         The composition
        \param bm_logger  (\c logging.logger) The bm logger
        \param port       (\c string)         The port to run the xml-rpc server on
        \parm is_comp_str (\c bool)           Whether the composition or a file path
        """
        self.__composition = comp
        if comp and not is_comp_str:
            f = open(comp, "r")
            self.__composition = f.read()
            f.close()

        self.__logger = bm_logger
        self.__port = None
        if port:
            self.__port = int(port)
        self.__server = None

    def set_composition(self, comp):
        self.__composition = comp

    def set_logger(self, logger):
        self.__logger = logger

    def serve(self):
        """\brief Starts up a composition as well as the xml-rpc server
        """
        self.start_composition()
        self.__server = SimpleXMLRPCServer(("localhost", self.__port))
        self.__server.register_function(self.update_composition,
                                        "update_composition")
        self.__server.register_function(self.stop_composition,
                                        "stop_composition")
        self.__server.register_function(self.read_variable, "read_variable")
        self.__server.register_function(self.write_variable, "write_variable")
        self.__logger.info("Starting Blockmon process with pid=" + str(os.getpid()) +\
                           " and listening on localhost:" + str(self.__port))
        self.__server.serve_forever()

    def start_composition(self, comp=None):
        """\brief Starts up a composition
        \param comp (\c string)      The composition. If None self.__composition is used
        \return     (\c ReturnValue) The result of the operation
        """
        if comp:
            self.__composition = comp
        self.__parser = CompositionParser(self.__composition)
        self.__comp_id = self.__parser.parse_comp_id()
        self.__comp_mngr = CompositionManager(self.__comp_id, blockmon,
                                              self.__logger)
        self.__comp_mngr.install(
            xml.dom.minidom.parseString(self.__composition))
        self.start_bm()
        return ReturnValue(ReturnValue.CODE_SUCCESS, "", None)

    def update_composition(self, comp):
        """\brief Updates up a composition
        \param comp (\c string)      The composition
        \return     (\c ReturnValue) The result of the operation
        """
        self.stop_bm()
        self.__composition = comp
        self.__comp_mngr.reconfigure(xml.dom.minidom.parseString(comp))
        self.start_bm()
        r = ReturnValue(ReturnValue.CODE_SUCCESS, "", None)
        if self.__server:
            return pickle.dumps(r)
        return r

    def is_running(self):
        return self.bm_running

    def stop_composition(self):
        """\brief Stops the composition
        \return     (\c ReturnValue) The result of the operation
        """
        self.stop_bm()
        self.__comp_mngr.remove()
        r = ReturnValue(ReturnValue.CODE_SUCCESS, "", None)
        if self.__server:
            return pickle.dumps(r)
        return r

    def read_variable(self, variable):
        """\brief Reads a variable from a block
        \param variable (\c VariableInfo) The variable to read, pickled.
        \return         (\c ReturnValue) The result of the operation
        """
        if self.__server:
            variable = pickle.loads(variable)
        r = self.__comp_mngr.read_block_var(variable)
        if self.__server:
            return pickle.dumps(r)
        return r

    def select_clock(self, clock_type):
        """\brief Sets the clock type (PACKET or WALL, case insensitive)
        \param clock_type (\c string)      The clock type
        \return           (\c ReturnValue) The result of the operation
        """
        clock_type = clock_type.upper()
        if clock_type == "WALL" or clock_type == "PACKET":
            blockmon.select_clock(clock_type)
            return ReturnValue(ReturnValue.CODE_SUCCESS, "", None)
        return ReturnValue(ReturnValue.CODE_FAILURE,
                           "invalid value for clock type", None)

    def write_variable(self, variable):
        """\brief Writes a value to a block variable
        \param variable (\c VariableInfo) The variable to write to, pickled.
        \return         (\c ReturnValue)  The result of the operation
        """
        if self.__server:
            variable = pickle.loads(variable)
        r = self.__comp_mngr.write_block_var(variable)
        if self.__server:
            return pickle.dumps(r)
        return r

    def get_blocks(self):
        return self.__comp_mngr.get_blocks()

    @staticmethod
    def start_bm():
        """\brief Starts all blockmon schedulers and timers
        """
        if (BMProcessManager.bm_running):
            raise Exception('blockmon already running')
        else:
            BMProcessManager.bm_running = True
        blockmon.start_schedulers()
        blockmon.start_timer()

    @staticmethod
    def stop_bm():
        """\brief Stops all blockmon schedulers and timers
        """
        if (BMProcessManager.bm_running):
            blockmon.stop_schedulers()
            blockmon.stop_timer()
        BMProcessManager.bm_running = False
Пример #4
0
class BMProcessManager:

    """\brief Controls a running blockmon process. Note that this class/file can be
              used directly as an executable (the method used by the blockmon daemon
              to spawn blockmon processes) or by creating an instance of the class
              (the method used for the blockmon CLI). For the former, the manager runs
              an XML-RPC server which the blockmon daemon uses to communicate with it.
              Further note that all xml-rpc operations return a pickled ReturnValue object.
    """
    bm_running = False
    
    def __init__(self, comp=None, bm_logger=None, port=None, is_comp_str=False):
        """\brief Initializes class
        \param comp       (\c string)         The composition
        \param bm_logger  (\c logging.logger) The bm logger
        \param port       (\c string)         The port to run the xml-rpc server on
        \parm is_comp_str (\c bool)           Whether the composition or a file path
        """
        self.__composition = comp
        if comp and not is_comp_str:
            f = open(comp, "r")
            self.__composition = f.read()
            f.close()

        self.__logger = bm_logger
        self.__port = None
        if port:
            self.__port = int(port)
        self.__server = None

    def set_composition(self, comp):
        self.__composition = comp

    def set_logger(self, logger):
        self.__logger = logger

    def serve(self):
        """\brief Starts up a composition as well as the xml-rpc server
        """
        self.start_composition()
        self.__server = SimpleXMLRPCServer(("localhost", self.__port))
        self.__server.register_function(self.update_composition, "update_composition")
        self.__server.register_function(self.stop_composition, "stop_composition")
        self.__server.register_function(self.read_variables, "read_variables")
        self.__server.register_function(self.write_variables, "write_variables")
        self.__logger.info("Starting Blockmon process with pid=" + str(os.getpid()) +\
                           " and listening on localhost:" + str(self.__port))
        self.__server.serve_forever()

    def start_composition(self, comp=None):
        """\brief Starts up a composition
        \param comp (\c string)      The composition. If None self.__composition is used
        \return     (\c ReturnValue) The result of the operation
        """
        if comp:
            self.__composition = comp
        self.__parser = CompositionParser(self.__composition)
        self.__comp_id = self.__parser.parse_comp_id()
        self.__comp_mngr = CompositionManager(self.__comp_id, blockmon, self.__logger)
        self.__comp_mngr.install(xml.dom.minidom.parseString(self.__composition))
        self.start_bm()
        return ReturnValue(ReturnValue.CODE_SUCCESS, "", None)

    def update_composition(self, comp):
        """\brief Updates up a composition
        \param comp (\c string)      The composition
        \return     (\c ReturnValue) The result of the operation
        """
        self.stop_bm()
        self.__composition = comp
        self.__comp_mngr.reconfigure(xml.dom.minidom.parseString(comp))
        self.start_bm()
        r = ReturnValue(ReturnValue.CODE_SUCCESS, "", None)
        if self.__server:
            return pickle.dumps(r)
        return r

    def is_running(self):
        return self.bm_running

    def stop_composition(self):
        """\brief Stops the composition
        \return     (\c ReturnValue) The result of the operation
        """
        self.stop_bm()
        self.__comp_mngr.remove()
        r = ReturnValue(ReturnValue.CODE_SUCCESS, "", None)
        if self.__server:
            return pickle.dumps(r)
        return r

    def read_variables(self, variables):
        """\brief Reads variables from blocks
        \param variables (\c [VariableInfo]) The variables to read, pickled.
        \return          (\c ReturnValue)    The result of the operation
        """        
        if self.__server:
            variables = pickle.loads(variables)
        for v in variables:
            value = self.__comp_mngr.read_block_var(v.get_block_name(), v.get_name())
            v.set_value(value)
        r = ReturnValue(ReturnValue.CODE_SUCCESS, "", variables)
        if self.__server:
            return pickle.dumps(r)
        return r

    def write_variables(self, variables):
        """\brief Writes values to block variables
        \param variables (\c [VariableInfo]) The variables to write to, pickled.
        \return          (\c ReturnValue)    The result of the operation
        """                
        if self.__server:
            variables = pickle.loads(variables)
        for v in variables:
            self.__comp_mngr.write_block_var(v.get_block_name(),\
                                             v.get_name(),\
                                             v.get_value())
        r = ReturnValue(ReturnValue.CODE_SUCCESS, "", None)
        if self.__server:
            return pickle.dumps(r)
        return r

    @staticmethod
    def start_bm():
        """\brief Starts all blockmon schedulers and timers
        """
        if (BMProcessManager.bm_running):
            raise Exception('blockmon already running')
        else:
            BMProcessManager.bm_running = True
        blockmon.start_schedulers()
        blockmon.start_timer()

    @staticmethod
    def stop_bm():
        """\brief Stops all blockmon schedulers and timers
        """
        if (BMProcessManager.bm_running):
            blockmon.stop_schedulers()
            blockmon.stop_timer()
        BMProcessManager.bm_running = False