application.py

Go to the documentation of this file.

#  Copyright 2008-2015 Nokia Networks
#  Copyright 2016-     Robot Framework Foundation
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
 
import sys
 
from robot.errors import (INFO_PRINTED, DATA_ERROR, STOPPED_BY_USER,
                          FRAMEWORK_ERROR, Information, DataError)
 
from .argumentparser import ArgumentParser
from .encoding import console_encode
from .error import get_error_details
 
 
class Application:
 
    def __init__(self, usage, name=None, version=None, arg_limits=None,
                 env_options=None, logger=None, **auto_options):
        self._ap_ap = ArgumentParser(usage, name, version, arg_limits,
                                  self.validatevalidate, env_options, **auto_options)
        self._logger_logger = logger or DefaultLogger()
 
    def main(self, arguments, **options):
        raise NotImplementedError
 
    def validate(self, options, arguments):
        return options, arguments
 
    def execute_cli(self, cli_arguments, exit=True):
        with self._logger_logger:
            self._logger_logger.info('%s %s' % (self._ap_ap.name, self._ap_ap.version))
            options, arguments = self._parse_arguments_parse_arguments(cli_arguments)
            rc = self._execute_execute(arguments, options)
        if exit:
            self._exit_exit(rc)
        return rc
 
    def console(self, msg):
        if msg:
            print(console_encode(msg))
 
    def _parse_arguments(self, cli_args):
        try:
            options, arguments = self.parse_argumentsparse_arguments(cli_args)
        except Information as msg:
            self._report_info_report_info(msg.message)
        except DataError as err:
            self._report_error_report_error(err.message, help=True, exit=True)
        else:
            self._logger_logger.info('Arguments: %s' % ','.join(arguments))
            return options, arguments
 
    
    def parse_arguments(self, cli_args):
        return self._ap_ap.parse_args(cli_args)
 
    def execute(self, *arguments, **options):
        with self._logger_logger:
            self._logger_logger.info('%s %s' % (self._ap_ap.name, self._ap_ap.version))
            return self._execute_execute(list(arguments), options)
 
    def _execute(self, arguments, options):
        try:
            rc = self.mainmain(arguments, **options)
        except DataError as err:
            return self._report_error_report_error(err.message, help=True)
        except (KeyboardInterrupt, SystemExit):
            return self._report_error_report_error('Execution stopped by user.',
                                      rc=STOPPED_BY_USER)
        except:
            error, details = get_error_details(exclude_robot_traces=False)
            return self._report_error_report_error('Unexpected error: %s' % error,
                                      details, rc=FRAMEWORK_ERROR)
        else:
            return rc or 0
 
    def _report_info(self, message):
        self.consoleconsole(message)
        self._exit_exit(INFO_PRINTED)
 
    def _report_error(self, message, details=None, help=False, rc=DATA_ERROR,
                      exit=False):
        if help:
            message += '\n\nTry --help for usage information.'
        if details:
            message += '\n' + details
        self._logger_logger.error(message)
        if exit:
            self._exit_exit(rc)
        return rc
 
    def _exit(self, rc):
        sys.exit(rc)
 
 
class DefaultLogger:
 
    def info(self, message):
        pass
 
    def error(self, message):
        print(console_encode(message))
 
    def close(self):
        pass
 
    def __enter__(self):
        pass
 
    def __exit__(self, *exc_info):
        pass