Add pysftp and paramiko to standard flavor (#115)

Author: tkilias

tests/lib/docker_db_environment/__init__.py

@@ -44,6 +44,9 @@ def close(self):
         self._client.close()
         self.remove_all_started_containers()
 
+    def get_client(self):
+        return self._client
+
     def remove_all_started_containers(self):
         for container in self._started_containers:
             try:

tests/test/standard-flavor/available-packages.py

@@ -68,6 +68,8 @@ def test_32(self): self.import_test('boto')
     def test_33(self): self.import_test('pycurl')
     def test_34(self): self.import_test('requests')
     def test_35(self): self.import_test('EXASOL')
+    def test_36(self): self.import_test('paramiko')
+    def test_37(self): self.import_test('pysftp')
 
 class AvailablePython3Packages(udf.TestCase):
     def setUp(self): 
@@ -133,6 +135,8 @@ def test_33(self): self.import_test('pycurl')
     def test_34(self): self.import_test('requests')
     def test_35(self): self.import_test('pyexasol')
     def test_36(self): self.import_test('EXASOL')
+    def test_36(self): self.import_test('paramiko')
+    def test_37(self): self.import_test('pysftp')
 
 
 class AvailableRPackages(udf.TestCase):

tests/test/standard-flavor/paramiko_connection_test.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python2.7
+
+import os
+import sys
+import time 
+
+sys.path.append(os.path.realpath(__file__ + '/../../../lib'))
+
+import udf
+import docker_db_environment
+
+class ParamikoConnectionTest(udf.TestCase):
+
+    @udf.skipIfNot(docker_db_environment.is_available, reason="This test requires a docker-db environment")
+    def test_connect_via_paramiko_to_ssh_python3(self):
+        self.connect_via_paramiko_to_ssh("PYTHON3")
+
+
+    @udf.skipIfNot(docker_db_environment.is_available, reason="This test requires a docker-db environment")
+    def test_connect_via_paramiko_to_ssh_python2(self):
+        self.connect_via_paramiko_to_ssh("PYTHON")
+
+
+    def connect_via_paramiko_to_ssh(self, python_version):
+        schema="test_connect_via_paramiko_to_ssh_"+python_version
+        env=docker_db_environment.DockerDBEnvironment(schema)
+        try:
+            self.query(udf.fixindent("DROP SCHEMA %s CASCADE"%schema),ignore_errors=True)
+            self.query(udf.fixindent("CREATE SCHEMA %s"%schema))
+            self.query(udf.fixindent("OPEN SCHEMA %s"%schema))
+            self.query(udf.fixindent('''
+                CREATE OR REPLACE {python_version} SCALAR SCRIPT connect_container(host varchar(1000), port int,username varchar(1000),password varchar(1000))  returns VARCHAR(100000) AS
+                import socket
+                def run(ctx):
+                    import paramiko
+                    try:
+                        ssh = paramiko.SSHClient()
+                        ssh.load_system_host_keys()
+                        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+                        ssh.connect(hostname=ctx.host,port = ctx.port,username=ctx.username,password=ctx.password)
+                        ssh.close()
+                        return "success"
+                    except paramiko.ssh_exception.NoValidConnectionsError as e:
+                        return "%s,%s,%s,%s,%s"%(str(e.errors),ctx.host,ctx.port,ctx.username,ctx.password)
+                /
+                '''.format(python_version=python_version)))
+            env.get_client().images.pull("panubo/sshd",tag="1.1.0")
+            container=env.run(name="ssshd",image="panubo/sshd:1.1.0",environment=["SSH_USERS=test_user:1000:1000","SSH_ENABLE_PASSWORD_AUTH=true"])
+            time.sleep(10)
+            result=container.exec_run(cmd=''' sh -c "echo 'test_user:test_user' | chpasswd" ''')
+            time.sleep(5)
+            print(result)
+            host=env.get_ip_address_of_container(container)
+            rows=self.query("select connect_container('%s',%s,'test_user','test_user')"%(host,22))
+            self.assertRowsEqual([("success",)], rows)
+            print(container.logs())
+        finally:
+            try:
+                self.query(udf.fixindent("DROP SCHEMA %s CASCADE"%schema))
+            except:
+                pass
+            try:
+                env.close()
+            except:
+                pass
+
+
+if __name__ == '__main__':
+    udf.main()
+

tests/test/standard-flavor/pysftp_connection_test.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python2.7
+
+import os
+import sys
+import time 
+
+sys.path.append(os.path.realpath(__file__ + '/../../../lib'))
+
+import udf
+import docker_db_environment
+
+class PysftpConnectionTest(udf.TestCase):
+
+    @udf.skipIfNot(docker_db_environment.is_available, reason="This test requires a docker-db environment")
+    def test_pysftp_connect_python3(self):
+        self.pysftp_connect("PYTHON3")
+
+
+    @udf.skipIfNot(docker_db_environment.is_available, reason="This test requires a docker-db environment")
+    def test_pysftp_connect_python2(self):
+        self.pysftp_connect("PYTHON")
+
+
+    def pysftp_connect(self, python_version):
+        schema="test_pysftp_connect"+python_version
+        env=docker_db_environment.DockerDBEnvironment(schema)
+        try:
+            self.query(udf.fixindent("DROP SCHEMA %s CASCADE"%schema),ignore_errors=True)
+            self.query(udf.fixindent("CREATE SCHEMA %s"%schema))
+            self.query(udf.fixindent("OPEN SCHEMA %s"%schema))
+            self.query(udf.fixindent('''
+                CREATE OR REPLACE {python_version} SCALAR SCRIPT connect_container(host varchar(1000), port int,username varchar(1000),password varchar(1000), input_string varchar(1000))  returns VARCHAR(100000) AS
+                import socket
+                import io
+                import traceback
+                import sys
+                def run(ctx):
+                    import pysftp
+                    cnopts = pysftp.CnOpts()
+                    cnopts.hostkeys = None 
+                    try:
+                        with pysftp.Connection(ctx.host, username=ctx.username, password=ctx.password,cnopts=cnopts) as sftp:
+                            with sftp.cd("tmp"):
+                                input_buffer = io.StringIO(ctx.input_string)
+                                sftp.putfo(input_buffer,"test_file")
+                                output_buffer = io.BytesIO()
+                                written=sftp.getfo('test_file',output_buffer)
+                                value=output_buffer.getvalue()
+                                value_decoded=value.decode("utf-8")
+                                return value_decoded
+                    except:
+                        return traceback.format_exc()
+                        
+                /
+                '''.format(python_version=python_version)))
+            env.get_client().images.pull("panubo/sshd",tag="1.1.0")
+            container=env.run(name="sshd_sftp",image="panubo/sshd:1.1.0",environment=["SSH_USERS=test_user:1000:1000","SSH_ENABLE_PASSWORD_AUTH=true","SFTP_MODE=true"],
+                                tmpfs={'/data': 'size=1M,uid=0'})
+            print(container.logs())
+            time.sleep(10)
+            print(container.logs())
+            result=container.exec_run(cmd=''' sh -c "echo 'test_user:test_user' | chpasswd" ''')
+            result=container.exec_run(cmd='''mkdir /data/tmp''')
+            result=container.exec_run(cmd='''chmod 777 /data/tmp''')
+            time.sleep(5)
+            print(result)
+            host=env.get_ip_address_of_container(container)
+            rows=self.query("select connect_container('%s',%s,'test_user','test_user','success')"%(host,22))
+            self.assertRowsEqual([("success",)], rows)
+            print(container.logs())
+        finally:
+            try:
+                self.query(udf.fixindent("DROP SCHEMA %s CASCADE"%schema))
+            except:
+                pass
+            try:
+                env.close()
+            except:
+                pass
+
+
+if __name__ == '__main__':
+    udf.main()
+