Add info about remote mode in README.md

v.shepard · v.shepard · commit 12aa7bab9df4 · 2023-08-03T15:55:06.000+02:00
diff --git a/README.md b/README.md
@@ -173,6 +173,33 @@ with testgres.get_new_node().init() as master:
 Note that `default_conf()` is called by `init()` function; both of them overwrite
 the configuration file, which means that they should be called before `append_conf()`.
 
+### Remote mode
+Testgres supports the creation of PostgreSQL nodes on a remote host. This is useful when you want to run distributed tests involving multiple nodes spread across different machines.
+
+To use this feature, you need to use the RemoteOperations class.
+Here is an example of how you might set this up:
+
+```python
+from testgres import ConnectionParams, RemoteOperations, TestgresConfig, get_remote_node
+
+# Set up connection params
+conn_params = ConnectionParams(
+    host='your_host',  # replace with your host
+    username='user_name',  # replace with your username
+    ssh_key='path_to_ssh_key'  # replace with your SSH key path
+)
+os_ops = RemoteOperations(conn_params)
+
+# Add remote testgres config before test
+TestgresConfig.set_os_ops(os_ops=os_ops)
+
+# Proceed with your test
+def test_basic_query(self):
+    with get_remote_node(conn_params=conn_params) as node:
+        node.init().start()
+        res = node.execute('SELECT 1')
+        self.assertEqual(res, [(1,)])
+```
 
 ## Authors
 
diff --git a/testgres/__init__.py b/testgres/__init__.py
@@ -1,4 +1,4 @@
-from .api import get_new_node
+from .api import get_new_node, get_remote_node
 from .backup import NodeBackup
 
 from .config import \
@@ -52,6 +52,7 @@
 
 __all__ = [
     "get_new_node",
+    "get_remote_node",
     "NodeBackup",
     "TestgresConfig", "configure_testgres", "scoped_config", "push_config", "pop_config",
     "NodeConnection", "DatabaseError", "InternalError", "ProgrammingError", "OperationalError",
diff --git a/testgres/api.py b/testgres/api.py
@@ -37,10 +37,18 @@ def get_new_node(name=None, base_dir=None, **kwargs):
     """
     Simply a wrapper around :class:`.PostgresNode` constructor.
     See :meth:`.PostgresNode.__init__` for details.
+    """
+    # NOTE: leave explicit 'name' and 'base_dir' for compatibility
+    return PostgresNode(name=name, base_dir=base_dir, **kwargs)
+
+
+def get_remote_node(name=None, conn_params=None):
+    """
+    Simply a wrapper around :class:`.PostgresNode` constructor for remote node.
+    See :meth:`.PostgresNode.__init__` for details.
     For remote connection you can add the next parameter:
     conn_params = ConnectionParams(host='127.0.0.1',
                                    ssh_key=None,
                                    username=default_username())
     """
-    # NOTE: leave explicit 'name' and 'base_dir' for compatibility
-    return PostgresNode(name=name, base_dir=base_dir, **kwargs)
+    return get_new_node(name=name, conn_params=conn_params)
diff --git a/testgres/node.py b/testgres/node.py
@@ -146,8 +146,9 @@ def __init__(self, name=None, port=None, base_dir=None, conn_params: ConnectionP
 
         # basic
         self.name = name or generate_app_name()
-
-        if conn_params.ssh_key:
+        if testgres_config.os_ops:
+            self.os_ops = testgres_config.os_ops
+        elif conn_params.ssh_key:
             self.os_ops = RemoteOperations(conn_params)
         else:
             self.os_ops = LocalOperations(conn_params)
@@ -157,7 +158,6 @@ def __init__(self, name=None, port=None, base_dir=None, conn_params: ConnectionP
         self.host = self.os_ops.host
         self.ssh_key = self.os_ops.ssh_key
 
-        testgres_config.os_ops = self.os_ops
         # defaults for __exit__()
         self.cleanup_on_good_exit = testgres_config.node_cleanup_on_good_exit
         self.cleanup_on_bad_exit = testgres_config.node_cleanup_on_bad_exit
diff --git a/testgres/operations/remote_ops.py b/testgres/operations/remote_ops.py
@@ -17,7 +17,7 @@
 sshtunnel.TUNNEL_TIMEOUT = 5.0
 
 
-error_markers = [b'error', b'Permission denied', b'fatal']
+error_markers = [b'error', b'Permission denied', b'fatal', b'No such file or directory']
 
 
 class PsUtilProcessProxy:
@@ -203,7 +203,10 @@ def makedirs(self, path, remove_existing=False):
             cmd = "rm -rf {} && mkdir -p {}".format(path, path)
         else:
             cmd = "mkdir -p {}".format(path)
-        exit_status, result, error = self.exec_command(cmd, verbose=True)
+        try:
+            exit_status, result, error = self.exec_command(cmd, verbose=True)
+        except ExecUtilException as e:
+            raise Exception("Couldn't create dir {} because of error {}".format(path, e.message))
         if exit_status != 0:
             raise Exception("Couldn't create dir {} because of error {}".format(path, error))
         return result
diff --git a/testgres/utils.py b/testgres/utils.py
@@ -87,9 +87,12 @@ def get_bin_path(filename):
     # check if it's already absolute
     if os.path.isabs(filename):
         return filename
+    if tconf.os_ops.remote:
+        pg_config = os.environ.get("PG_CONFIG_REMOTE") or os.environ.get("PG_CONFIG")
+    else:
+        # try PG_CONFIG - get from local machine
+        pg_config = os.environ.get("PG_CONFIG")
 
-    # try PG_CONFIG - get from local machine
-    pg_config = os.environ.get("PG_CONFIG")
     if pg_config:
         bindir = get_pg_config()["BINDIR"]
         return os.path.join(bindir, filename)
@@ -139,7 +142,11 @@ def cache_pg_config_data(cmd):
         return _pg_config_data
 
     # try specified pg_config path or PG_CONFIG
-    pg_config = pg_config_path or os.environ.get("PG_CONFIG")
+    if tconf.os_ops.remote:
+        pg_config = pg_config_path or os.environ.get("PG_CONFIG_REMOTE") or os.environ.get("PG_CONFIG")
+    else:
+        # try PG_CONFIG - get from local machine
+        pg_config = pg_config_path or os.environ.get("PG_CONFIG")
     if pg_config:
         return cache_pg_config_data(pg_config)
 
diff --git a/tests/README.md b/tests/README.md
@@ -27,3 +27,32 @@ export PYTHON_VERSION=3  # or 2
 # Run tests
 ./run_tests.sh
 ```
+
+
+#### Remote host tests
+
+1. Start remote host or docker container
+2. Make sure that you run ssh
+```commandline
+sudo apt-get install openssh-server
+sudo systemctl start sshd
+```
+3. You need to connect to the remote host at least once to add it to the known hosts file
+4. Generate ssh keys
+5. Set up params for tests
+
+
+```commandline
+conn_params = ConnectionParams(
+    host='remote_host',
+    username='username',
+    ssh_key=/path/to/your/ssh/key'
+)
+os_ops = RemoteOperations(conn_params)
+```
+If you have different path to `PG_CONFIG` on your local and remote host you can set up `PG_CONFIG_REMOTE`, this value will be
+using during work with remote host.
+
+`test_remote` - Tests for RemoteOperations class.
+
+`test_simple_remote` - Tests that create node and check it. The same as `test_simple`, but for remote node. 
diff --git a/tests/test_simple_remote.py b/tests/test_simple_remote.py
