同步、异步测试——ssh、scp

coding: utf-8

import time
import socket
import paramiko
import pytest
import hashlib
import os
from concurrent.futures import ThreadPoolExecutor

待测试代码

_executor = ThreadPoolExecutor(max_workers=10)

SSHRunError = SCPRunError = paramiko.SSHException


class MessageError(Exception):

    def __init__(self, msg):
        super(MessageError, self).__init__(msg)


class Executor(object):
    """
    远程命令执行器，支持异步方式
    """

    def __init__(self, stdin, stdout):
        self._stdin = stdin
        self._stdout = stdout

        self.finish = 'ANT_EXECUTE_DONE'
        self.echo_finish = 'echo {} $?'.format(self.finish)

    def write(self, cmd):
        self._stdin.write(cmd + '\n')

    def flush(self):
        self._stdin.flush()

    def execute(self, cmd, stdin=None, sync=False, all_output=False):
        if sync:
            future = self._execute(cmd, stdin, all_output)
        else:
            future = _executor.submit(self._execute, cmd, stdin, all_output)
        return future

    def _execute(self, cmd, stdin=None, all_output=False):
        """
        远程执行命令时，多条命令之间需要有一定的间隔，确保前一条执行命令已经执行，通过
        强制time.sleep实现，以防前一条命令还未开始执行后续命令就发送过去。
        :param cmd: execute cmd
        :param stdin: input something when execute cmd need interaction
        :return: execute result
        """
        self.write(cmd)
        time.sleep(0.1)
        if stdin:
            self.write(stdin)
            time.sleep(0.1)
        self.write(self.echo_finish)
        self.flush()

        out, err = [], []
        for line in self._stdout:
            # logger.debug(line)
            line = line.strip()
            if not line:
                continue
            if cmd in line or self.echo_finish in line:
                continue