RobotFramework学习系列(三)

　　前两篇文章讲解了Suite的构造，文件到Robot的数据格式的转化。这篇文章继续讲解

　　回到入口函数Robotframework().main()

　　8行之前已经讲过了，8行为对suite的配置。9行为重点

    def main(self, datasources, **options):
        settings = RobotSettings(options)
        LOGGER.register_console_logger(**settings.console_logger_config)
        LOGGER.info('Settings:
%s' % unicode(settings))
        suite = TestSuiteBuilder(settings['SuiteNames'],
                                 settings['WarnOnSkipped'],
                                 settings['RunEmptySuite']).build(*datasources)
        suite.configure(**settings.suite_config)
        result = suite.run(settings)
        LOGGER.info("Tests execution ended. Statistics:
%s"
                    % result.suite.stat_message)
        if settings.log or settings.report or settings.xunit:
            writer = ResultWriter(settings.output if settings.log else result)
            writer.write_results(settings.get_rebot_settings())
        return result.return_code

　　suite.run()是robot unningmodel.py下TestSuite的方法，具体构造已经在上篇文章中简单讲述了

    def run(self, settings=None, **options):
        with STOP_SIGNAL_MONITOR:
            IMPORTER.reset()
            pyloggingconf.initialize(settings['LogLevel'])
            init_global_variables(settings)
            output = Output(settings)
            runner = Runner(output, settings)
            self.visit(runner)
        output.close(runner.result)
        return runner.result

 　　这里出现了with STOP_SIGNAL_MONITOR 这个也算是python中的魔法实现了。这篇文章先讲一下这块，with的原理如下

　　1、紧跟with后面的语句被执行后后，对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量
　　2、当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法

　　示例代码和输出结果如下

class Test:
    def __enter__(self):
        print "__enter__"
        return self
    def __exit__(self, *exc_info):
        print "__exit__"
    def output(self, message):
        print message
with Test() as test:
    test.output('test')

C:Python27python.exe E:/test/testwith.py
__enter__
test
__exit__

　　返回来看STOP_SIGNAL_MONITOR这个类

class _StopSignalMonitor(object):

    def __init__(self):
        self._signal_count = 0
        self._running_keyword = False
        self._orig_sigint = None
        self._orig_sigterm = None

    def __call__(self, signum, frame):
        self._signal_count += 1
        LOGGER.info('Received signal: %s.' % signum)
        if self._signal_count > 1:
            sys.__stderr__.write('Execution forcefully stopped.
')
            raise SystemExit()
        sys.__stderr__.write('Second signal will force exit.
')
        if self._running_keyword and not sys.platform.startswith('java'):
            self._stop_execution_gracefully()

    def _stop_execution_gracefully(self):
        raise ExecutionFailed('Execution terminated by signal', exit=True)

    def start(self):
        # TODO: Remove start() in favor of __enter__ in RF 2.9. Refactoring
        # the whole signal handler at that point would be a good idea.
        self.__enter__()

    def __enter__(self):
        if signal:
            self._orig_sigint = signal.getsignal(signal.SIGINT)
            self._orig_sigterm = signal.getsignal(signal.SIGTERM)
            for signum in signal.SIGINT, signal.SIGTERM:
                self._register_signal_handler(signum)
        return self

    def __exit__(self, *exc_info):
        if signal:
            signal.signal(signal.SIGINT, self._orig_sigint)
            signal.signal(signal.SIGTERM, self._orig_sigterm)

    def _register_signal_handler(self, signum):
        try:
            signal.signal(signum, self)
        except (ValueError, IllegalArgumentException), err:
            # ValueError occurs e.g. if Robot doesn't run on main thread.
            # IllegalArgumentException is http://bugs.jython.org/issue1729
            if currentThread().getName() == 'MainThread':
                self._warn_about_registeration_error(signum, err)

    def _warn_about_registeration_error(self, signum, err):
        name, ctrlc = {signal.SIGINT: ('INT', 'or with Ctrl-C '),
                       signal.SIGTERM: ('TERM', '')}[signum]
        LOGGER.warn('Registering signal %s failed. Stopping execution '
                    'gracefully with this signal %sis not possible. '
                    'Original error was: %s' % (name, ctrlc, err))

    def start_running_keyword(self, in_teardown):
        self._running_keyword = True
        if self._signal_count and not in_teardown:
            self._stop_execution_gracefully()

    def stop_running_keyword(self):
        self._running_keyword = False

　　程序开始运行时执行顺序为：

　　1、__enter__():

　　　　查看signal是否导入成功，导入成功，则获取一下执行signal.getsignal()，对signal.SIGINT和signal.SIGTERM，这两种信号，一个是Crtl+C触发，一个是进程自身要求中断引起，当程序初始运行时，getsignal返回的都是0

　　　　调用_register_signal_handler 对两种信号进行注册，以备将来捕获。在注册时候，使用了signal.signal(signum, self)。请注意这块，signale的第二个参数为捕获到对应信号后的处理函数，此时把self传进去，也就是说处理函数为self()也就是_StopSignalMonito()这块，一会再讲

　　　　此时由于信号只能在主线程设置，所以又判断了一下，给出了相应的告警

　　2、退出

　　　　分为两种，接收到SIGINIT or SIGTERM

　　　　此时会调用_StopSignalMonito()进行信号处理，这块又用到Python的魔法，__call__()

　　　　其中的逻辑是，接到一次信号，判断自身状态，如果测试在跑，则后续不再进行，执行teardown后正常退出；如果再次接到信号，直接调用系统的SystemExit()。也就是说在程序运行过程中，我们要中断测试，需要按两次Ctrl+C

　　　　然后再执行__exit__()，此时又执行了signal.signal，传入的是Stop_SignalMonito的两个变量，在执行__enter__时被初始化，此时应该都是0，也就是singal.SIG_DFL，进程采用默认操作。退出with

　　　　无故障，直接调用__exit__()，和上述接到中断信号调用__exit__()的流程是一样的