import argparse

'''低版本的Python不支持 argparse'''

'''首先创建一个 `argparse.ArugmentParser` 对象 '''
parser = argparse.ArgumentParser(description='Process some integers.')
'''使用`add_argument()`方法来添加将命令行参数解析成对象的方式，这些对象在`parse_args()`方法调用后才可以使用。'''
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                    help='an integer for the accumulator')
'''通过命令行参数可以指定`accumulate`属性是`sum`函数，还是`max`函数'''
parser.add_argument('-s', '--sum', dest='accumulate', action='store_const',
                    const=sum, default=max,
                    help='sum the integers (default: find the max)')
parser.add_argument("--foo", action='append')

'''
上述代码可以通过如下命令行调用
`python prog.py 1 2 3 4`   结果： 4
·ptython prog.py 1 2 3 4 --sum` 结果： 10
'''

'''
add_argument() 方法的参数定义如下：
- name or flags: 一个名称或一个选项字符串列表
- action: 命令行中遇到该参数时，采用基本类型的操作
   1. `store`: 仅仅存储参数的值
   2. `store_const`: 存储由`const`指定的参数，该方式通常用来存储指定某种操作的可选参数
   3. `store_true`/`store_false`: `store_const`的特例，将值存储为True/False
   4. `append`: 将各个参数的值存储为一个列表，允许多个可选参数时非常有用 
   5. `append_const`: 存储由`const`指定的参数到list中。
- nargs: 应该使用的命令行参数的数量
- const: 被action和nargs所需的常量值
- default: 如果命令行中不存在该参数，所采取的默认操作
- type: 命令行参数应该被转换成的类型
- choices: 可以被允许的值
- required: 是否可以省略的命令行选项
- help: 简要介绍参数的用途
- metavar: 用法消息参数的名称
- dest: `parse_args()` 返回的对象中属性的名字，对应于该参数。
'''


class FooAction(argparse.Action):
    def __init__(self, option_strings, dest, nargs=None, **kwargs):
        if nargs is not None:
            raise ValueError("nargs not allowed")
        super(FooAction, self).__init__(option_strings, dest, **kwargs)

    def __call__(self, parser, namespace, values, option_string=None):
        print('%r %r %r' % (namespace, values, option_string))
        setattr(namespace, self.dest, values)


'''
nargs: 应该使用的命令行参数的数量
- N: `N` 个命令行参数将会被放到一个list中。
- ?: 如果可能的话，从命令行中读取一个参数，产生一个 
- *: 所有的命令行参数都会被放到同一个list中
- +: 同`*`类似，只是要求至少有一个参数，否则会抛出异常
'''


parser.add_argument('--foo', nargs='*')
parser.add_argument('--bar', nargs='*')
parser.add_argument('baz', nargs='*')
'''parser.parse_args('a b --foo x y --bar 1 2'.split()):Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y']) '''

'''将命令行参数转换成合适的对象'''
args = parser.parse_args()
print(args.accumulate(args.integers))

import argparse
import paramiko
from concurrent.futures import ThreadPoolExecutor


def parse_argument():
    """解析参数"""
    parser = argparse.ArgumentParser(description='Process some integers.')
    parser.add_argument("-f", "--file", type=str, dest="file", default="machine", help="the file of ip address")
    parser.add_argument("-e", "--command", metavar='N', nargs='+', type=str, dest="command",
                        help="the command to execute")
    parser.add_argument("-g", "--grep", type=str, dest="grep", metavar='N', nargs='+', default=None,
                        help="grep some thing")
    args = parser.parse_args()
    if args.command is not None:
        args.command = " ".join(args.command)
    if args.grep is not None:
        args.command = "grep --color=always -P " + " ".join(args.grep)
    return args


def execute(host, username, password, command):
    """连接终端执行命令"""
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host, port=22, username=username, password=password, timeout=7)
    stdin, stdout, stderr = ssh.exec_command(command)
    cmd_result = stdout.readlines(encoding="gbk")
    err_result = stderr.readlines()
    result = "----------------------" + host + "--------------------------------\n"
    for o in cmd_result:
        print(o)
    return result + "------------------------\n"

if __name__ == '__main__':
    args = parse_argument()
    hosts = []

    print(args)
    if args.file is not None:
        with open(args.file, encoding="utf8") as hostFile:
            for line in hostFile:
                hosts.append(line.strip())
    pool = ThreadPoolExecutor(max_workers=2)
    futures = []
    print(hosts)
    for host in hosts:
        futures.append(pool.submit(execute, host, "guest", "Sogou@)!$", args.command))
    for future in futures:
        print(future.result())