Python DataLayer.commit方法代码示例

# 需要导入模块: from enarksh.DataLayer import DataLayer [as 别名]
# 或者: from enarksh.DataLayer.DataLayer import commit [as 别名]
    def handle(_event, message, controller):
        """
        Handles a NodeActionWebMessage received event.

        :param * _event: Not used.
        :param enarksh.controller.message.NodeActionWebMessage.NodeActionWebMessage message: The message.
        :param enarksh.controller.Controller.Controller controller: The controller.
        """
        del _event

        log = logging.getLogger('enarksh')

        # Compose a response message for the web interface.
        response = {'ret':     0,
                    'new_run': 0,
                    'message': 'OK'}

        try:
            NodeActionMessageBaseEventHandler.base_handle(controller,
                                                          response,
                                                          message.sch_id,
                                                          message.rnd_id,
                                                          message.act_id)

            DataLayer.commit()
        except Exception:
            log.exception('Error')

            response['ret'] = -1
            response['message'] = 'Internal error'

            DataLayer.rollback()

        # Send the message to the web interface.
        controller.message_controller.send_message('lockstep', response, True)

# 需要导入模块: from enarksh.DataLayer import DataLayer [as 别名]
# 或者: from enarksh.DataLayer.DataLayer import commit [as 别名]
    def __startup(self):
        """
        Performs the necessary actions for starting the controller daemon.
        """
        self.__log.info('Starting controller')

        credentials = Credentials.get()

        # Set database configuration options.
        DataLayer.config['host'] = credentials.get_host()
        DataLayer.config['user'] = credentials.get_user()
        DataLayer.config['password'] = credentials.get_password()
        DataLayer.config['database'] = credentials.get_database()
        DataLayer.config['port'] = credentials.get_port()
        DataLayer.config['autocommit'] = False

        # Connect to the MySQL.
        DataLayer.connect()
        DataLayer.start_transaction()

        # Sanitise the data in the database.
        DataLayer.enk_back_controller_init()

        # Create resources defined at host level.
        self.__create_host_resources()

        # Set the effective user and group to an unprivileged user and group.
        self.__set_unprivileged_user()

        # Commit transaction and close connection to MySQL.
        DataLayer.commit()

# 需要导入模块: from enarksh.DataLayer import DataLayer [as 别名]
# 或者: from enarksh.DataLayer.DataLayer import commit [as 别名]
    def handle(_event, message, controller):
        """
        Handles a PossibleNodeActionsWebMessage received event.

        :param * _event: Not used.
        :param enarksh.controller.message.PossibleNodeActionsWebMessage.PossibleNodeActionsWebMessage message:
               The message.
        :param enarksh.controller.Controller.Controller controller: The controller.
        """
        del _event

        log = logging.getLogger('enarksh')

        try:
            schedule = controller.get_schedule_by_sch_id(message.sch_id)
            if schedule:
                response = schedule.request_possible_node_actions(message.rnd_id)
            else:
                response = Schedule.get_response_template()

            DataLayer.commit()
        except Exception:
            log.exception('Error')

            response = dict()
            response['ret'] = -1
            response['message'] = 'Internal error'

            DataLayer.rollback()

        # Send the message to the web interface.
        controller.message_controller.send_message('lockstep', response, True)

# 需要导入模块: from enarksh.DataLayer import DataLayer [as 别名]
# 或者: from enarksh.DataLayer.DataLayer import commit [as 别名]
    def handle(_event, message, controller):
        """
        Handles a JobFinishedMessage received event.

        :param * _event: Not used.
        :param enarksh.controller.message.ScheduleDefinitionMessage.ScheduleDefinitionMessage message: The message.
        :param enarksh.controller.Controller.Controller controller: The controller.
        """
        del _event

        log = logging.getLogger('enarksh')

        try:
            # Validate XML against XSD.
            reader = XmlReader()
            schedule = reader.parse_schedule(message.xml, message.filename)

            # Test schedule is currently running.
            name = schedule.name
            if name in controller.schedules:
                raise Exception("Schedule '%s' is currently running." % name)

            # Insert the XML definition as BLOB in tot the database.
            blb_id = DataLayer.enk_blob_insert_blob(os.path.basename(message.filename), 'text/xml', message.xml)
            srv_id = DataLayer.enk_reader_schedule_create_revision(blb_id, name)
            if not srv_id:
                raise Exception("Schedule '%s' is already loaded." % name)

            # Store the new schedule definition into the database.
            schedule.store(srv_id, 1)
            DataLayer.enk_back_schedule_revision_create_run(srv_id)

            response = {'ret':     0,
                        'message': "Schedule '%s' successfully loaded." % name}

            DataLayer.commit()
        except Exception:
            log.exception('Error')

            response = {'ret':     -1,
                        'message': 'Internal error'}

            DataLayer.rollback()

        # Send the message to the web interface.
        controller.message_controller.send_message('lockstep', response, True)

# 需要导入模块: from enarksh.DataLayer import DataLayer [as 别名]
# 或者: from enarksh.DataLayer.DataLayer import commit [as 别名]
    def main(self, filename):
        """
        The main function of load_schedule.

        :param str filename: The filename with the XML definition of the host.
        """
        try:
            DataLayer.connect()

            reader = XmlReader()
            host = reader.parse_host(filename)
            host.store()

            DataLayer.commit()
            DataLayer.disconnect()
        except Exception as exception:
            DataLayer.rollback()
            DataLayer.disconnect()

            raise exception

# 需要导入模块: from enarksh.DataLayer import DataLayer [as 别名]
# 或者: from enarksh.DataLayer.DataLayer import commit [as 别名]
    def handle(_event, _event_data, controller):
        """
        Handles an empty event queue event.

        :param  _event: The event.
        :param * _event_data: Not used.
        :param enarksh.controller.Controller.Controller controller: The controller.
        """
        del _event, _event_data

        # Try the start nodes.
        EventQueueEmptyEventHandler.__queue_handler(controller)

        DataLayer.commit()
        DataLayer.disconnect()

        # If event queue is empty listen for new messages.
        if controller.event_controller.queue_size() == 0:
            controller.message_controller.receive_message(None, None, None)

        DataLayer.connect()
        DataLayer.start_transaction()

# 需要导入模块: from enarksh.DataLayer import DataLayer [as 别名]
# 或者: from enarksh.DataLayer.DataLayer import commit [as 别名]
    def main(self):
        """
        Bootstrap the database for our WOB enarksh. Removes all database objects and (re)creates all databases objects.
        """
        credentials = Credentials.get()

        # Set database configuration options.
        DataLayer.config['host'] = credentials.get_host()
        DataLayer.config['user'] = credentials.get_user()
        DataLayer.config['password'] = credentials.get_password()
        DataLayer.config['database'] = credentials.get_database()
        DataLayer.config['port'] = credentials.get_port()
        DataLayer.config['autocommit'] = False

        # Connect to the MySQL.
        DataLayer.connect()

        # Remove all databases objects.
        self._drop_all_db_objects()

        # Create all types and tables.
        self._execute_sql_file('lib/ddl/0100_create_tables.sql', 'utf-8')

        # Load static data.
        self._execute_sql_file('lib/ddl/0300_enk_consumption_type.sql')
        self._execute_sql_file('lib/ddl/0300_enk_error.sql')
        self._execute_sql_file('lib/ddl/0300_enk_host.sql')
        self._execute_sql_file('lib/ddl/0300_enk_node_type.sql')
        self._execute_sql_file('lib/ddl/0300_enk_port_type.sql')
        self._execute_sql_file('lib/ddl/0300_enk_resource_type.sql')
        self._execute_sql_file('lib/ddl/0300_enk_run_status.sql')
        self._execute_sql_file('lib/ddl/0300_enk_rw_status.sql')

        # self._execute_sql_file('lib/ddl/0500_create_views.sql')

        # Load all stored procedure and functions.
        DataLayer.commit()
        self._load_stored_routines()

# 需要导入模块: from enarksh.DataLayer import DataLayer [as 别名]
# 或者: from enarksh.DataLayer.DataLayer import commit [as 别名]
    def handle(_event, message, _listener_data):
        """
        Handles a LogFileMessage received event.

        :param * _event: Not used.
        :param enarksh.message.logger.LogFileMessage.LogFileMessage message: The message.
        :param * _listener_data: Not used.
        """
        del _event, _listener_data

        log = logging.getLogger('enarksh')
        log.info('rnd_id: {}, name: {}, size: {}'.format(message.rnd_id, message.name, message.total_size))

        DataLayer.connect()

        if message.total_size > 0:
            # Read the log file or log files and concatenate if necessary.
            with open(message.filename1, 'rb') as file1:
                log = file1.read()

            if message.filename2:
                with open(message.filename2, 'rb') as file2:
                    buf2 = file2.read()
            else:
                buf2 = ''

            # Compute the number of skipped bytes.
            skipped = message.total_size - len(log) - len(buf2)

            if skipped != 0:
                # Add a newline to the end of the buffer, if required.
                if log[-1:] != b'\n':
                    log += b'\n'

                    # Note: This concatenation doesn't work for multi byte character sets.
                    log += b'\n'
                    log += bytes("Enarksh: Skipped {0} bytes.\n".format(skipped), 'utf8')
                    log += b'\n'

                log += buf2

            blb_id = DataLayer.enk_blob_insert_blob(message.name, 'text/plain', log)

        else:
            blb_id = None

        if message.name == 'out':
            DataLayer.enk_back_run_node_update_log(message.rnd_id, blb_id, message.total_size)
        elif message.name == 'err':
            DataLayer.enk_back_run_node_update_err(message.rnd_id, blb_id, message.total_size)
        else:
            raise ValueError("Unknown output name '%s'" % message.name)

        # Remove the (temporary) log files.
        if message.filename1:
            os.unlink(message.filename1)
        if message.filename2:
            os.unlink(message.filename2)

        DataLayer.commit()
        DataLayer.disconnect()