xbot.plugins.ssh 0.1.0__py3-none-any.whl

demo/lib/testbed.py

@@ -0,0 +1,48 @@
+from typing import Union
+
+from xbot.framework import testbed
+from xbot.plugins.ssh.ssh import SSHConnection
+from xbot.plugins.ssh.sftp import SFTPConnection
+
+
+class TestBed(testbed.TestBed):
+    """
+    TestBed for ssh demo.
+    """
+    def __init__(self, filepath: str):
+        """
+        :param filepath: testbed filepath.
+        """
+        super().__init__(filepath)
+        self._conns = {
+            'ssh': {},
+            'sftp': {}
+        }
+
+    def get_conn(
+        self, 
+        typ: str,
+        role: str
+    ) -> Union[SSHConnection, SFTPConnection]:
+        """
+        Get specific connection to the specified role.
+
+        :param typ: connection type, 'ssh' or 'sftp'.
+        :param role: user role.
+        """
+        typs = ('ssh', 'sftp')
+        if typ not in typs:
+            raise ValueError(f'Invalid connection type: {typ}, should be one of {typs}.')
+        for user in self.get('host.users'):
+            if user['role'] == role:
+                if role not in self._conns[typ]:
+                    conn = SSHConnection() if typ == 'ssh' else SFTPConnection()
+                    conn.connect(self.get('host.ip'), 
+                                 user['name'], 
+                                 user['password'], 
+                                 port=self.get('host.sshport'))
+                    self._conns[typ][role] = conn
+                return self._conns[typ][role]
+        raise ValueError(f'No such user: role={role}')
+
+    

demo/lib/testcase.py

@@ -0,0 +1,15 @@
+from xbot.framework import testcase
+
+from .testbed import TestBed
+
+
+class TestCase(testcase.TestCase):
+    """
+    TestCase for ssh demo.
+    """
+    @property
+    def testbed(self) -> TestBed:
+        """
+        TestBed instance.
+        """
+        return self.__testbed

demo/testcases/tc_sftp.py

@@ -0,0 +1,99 @@
+import os
+import shutil
+
+from xbot.framework.utils import assertx
+
+from lib.testcase import TestCase
+
+
+class tc_sftp(TestCase):
+    """
+    Testcase using SFTPConnection.
+    """
+    TIMEOUT = 60
+    FAILFAST = True
+    TAGS = ['sftp']
+
+    def setup(self):
+        """
+        Prepare test environment.
+        """
+        self.sftp = self.testbed.get_conn('sftp', 'normal')
+        self.lhome = os.environ.get('HOME') or os.environ['HOMEPATH']
+        self.lputdir = os.path.join(self.lhome, 'lputdir')
+        self.lgetdir = os.path.join(self.lhome, 'lgetdir')
+        self.rputdir = '/tmp/rputgetdir'
+        self.rgetdir = self.rputdir
+        for d in (self.lputdir, self.lgetdir):
+            if os.path.exists(d):
+                shutil.rmtree(d)
+        self.sftp.makedirs(self.rputdir)
+        os.makedirs(os.path.join(self.lputdir, 'dir', 'subdir'))
+        os.system('whoami > %s' % os.path.join(self.lputdir, 'file'))
+        os.system('whoami > %s' % os.path.join(self.lputdir, 'dir', 'subfile'))
+
+    def step1(self):
+        """
+        Test `putdir` method.
+        """
+        l = os.path.join(self.lputdir, 'dir')
+        self.sftp.putdir(l, self.rputdir)
+        p1 = self.sftp.join(self.rputdir, 'dir', 'subdir')
+        assertx(self.sftp.exists(p1), '==', True)
+        p2 = self.sftp.join(self.rputdir, 'dir', 'subfile')
+        assertx(self.sftp.exists(p2), '==', True)
+
+    def step2(self):
+        """
+        Test `putfile` method.
+        """
+        l = os.path.join(self.lputdir, 'file')
+        self.sftp.putfile(l, self.rputdir)
+        p1 = self.sftp.join(self.rputdir, 'file')
+        assertx(self.sftp.exists(p1), '==', True)
+        # rename
+        self.sftp.putfile(l, self.rputdir, 'newfile')
+        p2 = self.sftp.join(self.rputdir, 'newfile')
+        assertx(self.sftp.exists(p2), '==', True)
+
+    def step3(self):
+        """
+        Test `getdir` method.
+        """
+        r = self.sftp.join(self.rgetdir, 'dir')
+        self.sftp.getdir(r, self.lgetdir)
+        p1 = os.path.join(self.lgetdir, 'dir', 'subdir')
+        assertx(os.path.exists(p1), '==', True)
+        p2 = os.path.join(self.lgetdir, 'dir', 'subfile')
+        assertx(os.path.exists(p2), '==', True)
+    
+    def step4(self):
+        """
+        Test `getfile` method.
+        """
+        r = self.sftp.join(self.rgetdir, 'file')
+        self.sftp.getfile(r, self.lgetdir)
+        p1 = os.path.join(self.lgetdir, 'file')
+        assertx(os.path.exists(p1), '==', True)
+        # rename
+        self.sftp.getfile(r, self.lgetdir, 'newfile')
+        p2 = os.path.join(self.lgetdir, 'newfile')
+        assertx(os.path.exists(p2), '==', True)
+
+    def step5(self):
+        """
+        Test `open` method.
+        """
+        p = self.sftp.join(self.rputdir, 'file')
+        with self.sftp.open(p, 'w') as fp:
+            fp.write('xbot')
+        with self.sftp.open(p, 'r') as fp:
+            assertx(fp.read().decode('utf-8'), '==', 'xbot')
+
+    def teardown(self):
+        """
+        Clean up test environment.
+        """
+        shutil.rmtree(self.lputdir)
+        shutil.rmtree(self.lgetdir)
+

demo/testcases/tc_ssh.py

@@ -0,0 +1,73 @@
+from lib.testcase import TestCase
+
+
+class tc_ssh(TestCase):
+    """
+    Testcase using SSHConnection.
+    """
+    TIMEOUT = 60
+    FAILFAST = True
+    TAGS = ['ssh']
+
+    def setup(self):
+        """
+        Prepare test environment.
+        """
+        self.ssh = self.testbed.get_conn('ssh', 'normal')
+
+    def step1(self):
+        """
+        Execute command `whoami`, expect `name` of the normal user.
+        """
+        username = self.testbed.get("host.users[?role=='normal']")[0]['name']
+        self.ssh.exec('whoami', expect=username)
+        
+    def step2(self):
+        """
+        Execute command `sudo whoami`, expect `root`.
+        """
+        self.ssh.sudo('whoami', expect='root')
+
+    def step3(self):
+        """
+        Execute a interactive command.
+        """
+        self.ssh.exec("read -p 'input: '", prompts={'input:': 'hello'})
+
+    def step4(self):
+        """
+        Execute a command and expect no error.
+        """
+        self.ssh.exec('ls /tmp', expect=0)
+
+    def step5(self):
+        """
+        Execute a command and expect return code is 2.
+        """
+        self.ssh.exec('ls /errpath', expect=2)
+
+    def step5(self):
+        """
+        Execute a command and expect nothing.
+        """
+        self.ssh.exec('ls /tmp', expect=None)
+        self.ssh.exec('ls /errpath', expect=None)
+
+    def step6(self):
+        """
+        Execute a command and expect a specific output.
+        """
+        self.ssh.exec('echo hello', expect='hello')
+
+    def step7(self):
+        """
+        Execute a command with cd context manager.
+        """
+        with self.ssh.cd('/tmp'):
+            self.ssh.exec('pwd', expect='/tmp')
+
+    def teardown(self):
+        """
+        Clean up test environment.
+        """
+        pass

tests/run.py

@@ -0,0 +1,39 @@
+"""
+Run tests.
+"""
+
+import unittest
+import argparse
+
+from pathlib import Path
+
+from test_ssh import TestSSHConnection
+from test_sftp import TestSFTPConnection
+
+
+def create_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-H', '--host', required=True, 
+                        help='hostname or ip to test.')
+    parser.add_argument('-u', '--user', required=True, 
+                        help='username for host.')
+    parser.add_argument('-p', '--password', required=True, 
+                        help='password for host.')
+    parser.add_argument('-P', '--port', type=int, default=22,
+                        help='ssh port for host.')
+    return parser
+
+
+if __name__ == '__main__':
+    args = create_parser().parse_args()
+    TestSSHConnection.HOST = args.host
+    TestSSHConnection.USER = args.user
+    TestSSHConnection.PWD = args.password
+    TestSSHConnection.PORT = args.port
+    TestSFTPConnection.HOST = args.host
+    TestSFTPConnection.USER = args.user
+    TestSFTPConnection.PWD = args.password
+    TestSFTPConnection.PORT = args.port
+    startdir = Path(__file__).parent
+    testsuit = unittest.TestLoader().discover(startdir)
+    unittest.TextTestRunner(verbosity=2).run(testsuit)

tests/test_sftp.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2022-2023, zhaowcheng <zhaowcheng@163.com>
+
+import unittest
+import shutil
+import os
+import sys
+sys.path.append(os.path.abspath(f'{__file__}/../..'))
+
+from xbot.plugins.ssh.sftp import SFTPConnection
+
+
+class TestSFTPConnection(unittest.TestCase):
+
+    HOST = ''
+    PORT = 22
+    USER = ''
+    PWD = ''
+
+    sftp = SFTPConnection()
+
+    LHOME = os.environ.get('HOME') or os.environ['HOMEPATH']
+    LPUTDIR = os.path.join(LHOME, 'lputdir')
+    LGETDIR = os.path.join(LHOME, 'lgetdir')
+    RPUTDIR = '/tmp/rputgetdir'
+    RGETDIR = RPUTDIR
+
+    @classmethod
+    def setUpClass(cls):
+        cls.sftp.connect(cls.HOST, cls.USER, 
+                         cls.PWD, cls.PORT)
+        if not cls.sftp.exists(cls.RPUTDIR):
+            cls.sftp.makedirs(cls.RPUTDIR)
+        os.makedirs(os.path.join(cls.LPUTDIR, 'dir', 'subdir'))
+        os.system('whoami > %s' % os.path.join(cls.LPUTDIR, 'file'))
+        os.system('whoami > %s' % os.path.join(cls.LPUTDIR, 'dir', 'subfile'))
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls.LPUTDIR)
+        shutil.rmtree(cls.LGETDIR)
+        cls.sftp.disconnect()
+
+    def test_01_putdir(self):
+        l = os.path.join(self.LPUTDIR, 'dir')
+        self.sftp.putdir(l, self.RPUTDIR)
+        p1 = self.sftp.join(self.RPUTDIR, 'dir', 'subdir')
+        self.assertTrue(self.sftp.exists(p1))
+        p2 = self.sftp.join(self.RPUTDIR, 'dir', 'subfile')
+        self.assertTrue(self.sftp.exists(p2))
+
+    def test_02_putfile(self):
+        l = os.path.join(self.LPUTDIR, 'file')
+        self.sftp.putfile(l, self.RPUTDIR)
+        p1 = self.sftp.join(self.RPUTDIR, 'file')
+        self.assertTrue(self.sftp.exists(p1))
+        # rename
+        self.sftp.putfile(l, self.RPUTDIR, 'newfile')
+        p2 = self.sftp.join(self.RPUTDIR, 'newfile')
+        self.assertTrue(self.sftp.exists(p2))
+
+    def test_03_getdir(self):
+        r = self.sftp.join(self.RGETDIR, 'dir')
+        self.sftp.getdir(r, self.LGETDIR)
+        p1 = os.path.join(self.LGETDIR, 'dir', 'subdir')
+        self.assertTrue(os.path.exists(p1))
+        p2 = os.path.join(self.LGETDIR, 'dir', 'subfile')
+        self.assertTrue(os.path.exists(p2))
+    
+    def test_04_getfile(self):
+        r = self.sftp.join(self.RGETDIR, 'file')
+        self.sftp.getfile(r, self.LGETDIR)
+        p1 = os.path.join(self.LGETDIR, 'file')
+        self.assertTrue(os.path.exists(p1))
+        # rename
+        self.sftp.getfile(r, self.LGETDIR, 'newfile')
+        p2 = os.path.join(self.LGETDIR, 'newfile')
+        self.assertTrue(os.path.exists(p2))
+
+    def test_05_open(self):
+        p = self.sftp.join(self.RPUTDIR, 'file')
+        with self.sftp.open(p, 'a') as fp:
+            fp.write('xbot\n')
+        with self.sftp.open(p, 'r') as fp:
+            self.assertIn('xbot', fp.read().decode('utf-8'))
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/test_ssh.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2022-2023, zhaowcheng <zhaowcheng@163.com>
+
+import unittest
+import doctest
+import sys
+import os
+sys.path.append(os.path.abspath(f'{__file__}/../..'))
+
+from xbot.plugins.ssh import ssh
+from xbot.plugins.ssh.ssh import SSHConnection
+from xbot.plugins.ssh.errors import SSHConnectError, SSHCommandError
+
+
+def load_tests(loader, tests, ignore):
+    tests.addTests(doctest.DocTestSuite(ssh))
+    return tests
+
+
+class TestSSHConnection(unittest.TestCase):
+
+    HOST = ''
+    PORT = 22
+    USER = ''
+    PWD = ''
+
+    conn = SSHConnection()
+
+    def setenv(self, name: str, value: str) -> None:
+        self.conn.exec(f'export {name}="{value}"')
+
+    def getenv(self, name: str) -> str:
+        return self.conn.exec(f'echo ${name}')
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.conn.connect(cls.HOST, cls.USER, cls.PWD, cls.PORT)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.conn.disconnect()
+
+    def test_connect_error_pwd(self):
+        conn = SSHConnection()
+        with self.assertRaises(SSHConnectError) as cm:
+            conn.connect(self.HOST, self.USER, self.PWD + 'shit', self.PORT)
+        self.assertIn('please check whether the username and password are correct',
+                      str(cm.exception))
+        
+    def test_connect_error_port(self):
+        conn = SSHConnection()
+        with self.assertRaises(SSHConnectError) as cm:
+            conn.connect(self.HOST, self.USER, self.PWD, self.PORT + 1000)
+        self.assertRegex(str(cm.exception),
+                         r'.*please check whether the port is (opened|correct).*')
+        
+    def test_connect_error_ip(self):
+        conn = SSHConnection()
+        with self.assertRaises(SSHConnectError) as cm:
+            conn.connect('128.0.0.1', self.USER, self.PWD, self.PORT)
+        self.assertIn('please check whether the network is normal',
+                      str(cm.exception))
+
+    def test_cmd_whoami(self):
+        self.conn.exec('whoami', expect=self.USER)
+
+    def test_cmd_sudo(self):
+        self.conn.sudo('whoami', expect='root')
+
+    def test_cmd_interact(self):
+        self.conn.exec("read -p 'input: '", prompts={'input:': 'hello'})
+
+    def test_expect_0(self):
+        self.conn.exec('ls /tmp', expect=0)
+        with self.assertRaises(SSHCommandError):
+            self.conn.exec('ls /errpath', expect=0)
+
+    def test_expect_2(self):
+        self.conn.exec('ls /errpath', expect=2)
+
+    def test_expect_none(self):
+        self.conn.exec('ls /tmp', expect=None)
+        self.conn.exec('ls /errpath', expect=None)
+
+    def test_expect_str(self):
+        self.conn.exec('echo hello', expect='hello')
+        with self.assertRaises(SSHCommandError):
+            self.conn.exec('echo hello', expect='world')
+
+    def test_timeout(self):
+        with self.assertRaises(TimeoutError):
+            self.conn.exec('sleep 3', timeout=1)
+
+    def test_cmd_cd(self):
+        with self.conn.cd('/tmp'):
+            self.assertEqual(self.conn.exec('pwd'), '/tmp')
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

tests/test_utils.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2022-2023, zhaowcheng <zhaowcheng@163.com>
+
+import unittest
+import doctest
+import sys
+import os
+sys.path.append(os.path.abspath(f'{__file__}/../..'))
+
+from xbot.plugins.ssh import utils
+
+
+def load_tests(loader, tests, ignore):
+    tests.addTests(doctest.DocTestSuite(utils))
+    return tests
+
+
+if __name__ == '__main__':
+    unittest.main(verbosity=2)

venv/bin/jp.py

@@ -0,0 +1,54 @@
+#!/Users/wan/CodeProjects/xbot.plugins.ssh/venv/bin/python3.6
+
+import sys
+import json
+import argparse
+from pprint import pformat
+
+import jmespath
+from jmespath import exceptions
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('expression')
+    parser.add_argument('-f', '--filename',
+                        help=('The filename containing the input data.  '
+                              'If a filename is not given then data is '
+                              'read from stdin.'))
+    parser.add_argument('--ast', action='store_true',
+                        help=('Pretty print the AST, do not search the data.'))
+    args = parser.parse_args()
+    expression = args.expression
+    if args.ast:
+        # Only print the AST
+        expression = jmespath.compile(args.expression)
+        sys.stdout.write(pformat(expression.parsed))
+        sys.stdout.write('\n')
+        return 0
+    if args.filename:
+        with open(args.filename, 'r') as f:
+            data = json.load(f)
+    else:
+        data = sys.stdin.read()
+        data = json.loads(data)
+    try:
+        sys.stdout.write(json.dumps(
+            jmespath.search(expression, data), indent=4, ensure_ascii=False))
+        sys.stdout.write('\n')
+    except exceptions.ArityError as e:
+        sys.stderr.write("invalid-arity: %s\n" % e)
+        return 1
+    except exceptions.JMESPathTypeError as e:
+        sys.stderr.write("invalid-type: %s\n" % e)
+        return 1
+    except exceptions.UnknownFunctionError as e:
+        sys.stderr.write("unknown-function: %s\n" % e)
+        return 1
+    except exceptions.ParseError as e:
+        sys.stderr.write("syntax-error: %s\n" % e)
+        return 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())

venv/bin/rst2html.py

@@ -0,0 +1,23 @@
+#!/Users/wan/CodeProjects/xbot.plugins.ssh/venv/bin/python3.6
+
+# $Id: rst2html.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML documents from standalone reStructuredText '
+               'sources.  ' + default_description)
+
+publish_cmdline(writer_name='html', description=description)

venv/bin/rst2html4.py

@@ -0,0 +1,26 @@
+#!/Users/wan/CodeProjects/xbot.plugins.ssh/venv/bin/python3.6
+
+# $Id: rst2html4.py 7994 2016-12-10 17:41:45Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing (X)HTML.
+
+The output conforms to XHTML 1.0 transitional
+and almost to HTML 4.01 transitional (except for closing empty tags).
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+
+description = ('Generates (X)HTML documents from standalone reStructuredText '
+               'sources.  ' + default_description)
+
+publish_cmdline(writer_name='html4', description=description)

venv/bin/rst2html5.py

@@ -0,0 +1,34 @@
+#!/Users/wan/CodeProjects/xbot.plugins.ssh/venv/bin/python3.6
+# -*- coding: utf8 -*-
+# :Copyright: © 2015 Günter Milde.
+# :License: Released under the terms of the `2-Clause BSD license`_, in short:
+#
+#    Copying and distribution of this file, with or without modification,
+#    are permitted in any medium without royalty provided the copyright
+#    notice and this notice are preserved.
+#    This file is offered as-is, without any warranty.
+#
+# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
+#
+# Revision: $Revision: 8567 $
+# Date: $Date: 2020-09-30 13:57:21 +0200 (Mi, 30. Sep 2020) $
+
+"""
+A minimal front end to the Docutils Publisher, producing HTML 5 documents.
+
+The output is also valid XML.
+"""
+
+try:
+    import locale # module missing in Jython
+    locale.setlocale(locale.LC_ALL, '')
+except locale.Error:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+
+description = (u'Generates HTML5 documents from standalone '
+               u'reStructuredText sources.\n'
+               + default_description)
+
+publish_cmdline(writer_name='html5', description=description)

venv/bin/rst2latex.py

@@ -0,0 +1,26 @@
+#!/Users/wan/CodeProjects/xbot.plugins.ssh/venv/bin/python3.6
+
+# $Id: rst2latex.py 5905 2009-04-16 12:04:49Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A minimal front end to the Docutils Publisher, producing LaTeX.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline
+
+description = ('Generates LaTeX documents from standalone reStructuredText '
+               'sources. '
+               'Reads from <source> (default is stdin) and writes to '
+               '<destination> (default is stdout).  See '
+               '<http://docutils.sourceforge.net/docs/user/latex.html> for '
+               'the full reference.')
+
+publish_cmdline(writer_name='latex', description=description)

venv/bin/rst2man.py

@@ -0,0 +1,26 @@
+#!/Users/wan/CodeProjects/xbot.plugins.ssh/venv/bin/python3.6
+
+# Author:
+# Contact: grubert@users.sf.net
+# Copyright: This module has been placed in the public domain.
+
+"""
+man.py
+======
+
+This module provides a simple command line interface that uses the
+man page writer to output from ReStructuredText source.
+"""
+
+import locale
+try:
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline, default_description
+from docutils.writers import manpage
+
+description = ("Generates plain unix manual documents.  " + default_description)
+
+publish_cmdline(writer=manpage.Writer(), description=description)