I'm using SSHTunnelForwarder with Python 3.7. After finishing my work, I run server.stop() and hangs.

I believe it caused by socketserver.ThreadingMixIn https://docs.python.org/3.7/library/socketserver.html#socketserver.ThreadingMixIn

Changed in version 3.7: socketserver.ForkingMixIn.server_close() and socketserver.ThreadingMixIn.server_close() now waits until all child processes and non-daemonic threads complete. Add a new socketserver.ForkingMixIn.block_on_close class attribute to opt-in for the pre-3.7 behaviour.

Here's my work around. I changed the attribute server._server_list[0].block_on_close = False, and it behave like usual. It closed normally and not being hang.

I'm not sure if setting block_on_close = False is a good way or not.

Issue #135 may have the same cause.

Hello

I am using psycopg2 2.7.4 to connect to the PostgreSQL database server using asynchronous support. It is working absolutely fine. I have used sshtunnel v0.1.3 in pgAdmin4. When I connect the PostgreSQL database server using ssh tunnel and run the valid/correct query it works fine, but when I run any wrong query(invalid column of table) my application gets hang on conn.poll() function.

Please refer the code how we use conn.poll() with timeouts https://git.postgresql.org/gitweb/?p=pgadmin4.git;a=blob;f=web/pgadmin/utils/driver/psycopg2/connection.py;h=4f11c12b30882209c308cb3558e67189c97ea31e;hb=15fe26a7106610b710f3de5b604cd038302c926a#l1363

Can anyone please provide some pointers, suggestions? Similar question I have asked on psycopg2 ML.

To figure out the solution, I have performed following test case:

• Issue is reproducible only when server is connected using SSH Tunnel and any wrong query will be executed.
• Create SSH Tunnel using ssh command "ssh -L 3333:127.0.0.1:5444 172.16.195.213". Create new server with Host = 127.0.0.1 and port = 3333. Open Query Tool and run the wrong query. Issue is not reproducible.
• Enable logging of sshtunnel module by providing logger object in SSHTunnelForwarder() call. No useful logs found.
• Enable logging of psycopg2 connection. No useful logs found.

Note: I have verified the database server log and every time query gets executed.

The following script works and "FINISH" is printed, but it never exits to the shell:

import threading

from sshtunnel import SSHTunnelForwarder

with SSHTunnelForwarder(
    "localhost",
    ssh_username="localuser",
    ssh_password="localpass",
    remote_bind_address=('127.0.0.1', 5984),
    local_bind_address=('127.0.0.1', 9000)
) as server:

    print(server.local_bind_port)
    # these don't help
    # server.stop()
    # server.close()

# [t.close() for t in threading.enumerate() if t.__class__.__name__ == "Transport"]

print('FINISH!')

Python is waiting on threads to finish, but they never do. After running this script in iPython I can see the threads:

threading.enumerate()
[<_MainThread(MainThread, started 140735243972608)>,
 <HistorySavingThread(IPythonHistorySavingThread, started 123145307557888)>,
 <paramiko.Transport at 0x3880470 (cipher aes128-ctr, 128 bits) (connected; awaiting auth)>,
 <paramiko.Transport at 0x3874630 (cipher aes128-ctr, 128 bits) (connected; awaiting auth)>,
 <paramiko.Transport at 0x3191ba8 (cipher aes128-ctr, 128 bits) (connected; awaiting auth)>,
 <paramiko.Transport at 0x3874550 (cipher aes128-ctr, 128 bits) (active; 0 open channel(s))>,
 <paramiko.Transport at 0x3191c88 (cipher aes128-ctr, 128 bits) (connected; awaiting auth)>,
 <paramiko.Transport at 0x387bac8 (cipher aes128-ctr, 128 bits) (connected; awaiting auth)>,
 <paramiko.Transport at 0x3803e48 (cipher aes128-ctr, 128 bits) (connected; awaiting auth)>,
 <paramiko.Transport at 0x3874f60 (cipher aes128-ctr, 128 bits) (connected; awaiting auth)>]

If I uncomment the last line which explicitly closes the paramiko.Transport threads, the script exits correctly. It seems like I'm missing something, but even so this default behavior is confusing.

Since the addition of is_use_local_check_up parameter in 64af238 the default behaviour is not to check the local side of the tunnel. I see here two issues:

• Being not backwards compatible with versions prior to 0.0.5 (which may be a decision made by @pahaz which I respect)
• Not being able to set directly the way we want it to behave. Now we've first to create an SSHTunnelForwarder object, then change its is_use_local_check_up value to True.

I added a new method for SSHTunnelForwarder to force those checks.

Hi All, I posted a question about using SSH Tunnel on Stack Exchange recently, but I'm not sure if that was the right place for it (and I didn't get any answer). Would it have been better to post it on here? This is the "Issues" section which doesn't really seem right... I'm a bit lost :-(

Thanks in advance. Stuart.

This line of code

https://github.com/pahaz/sshtunnel/blob/bd4ae32344a3a68ce27b1ad27c992687613b3182/sshtunnel.py#L1021

prevents the or at

https://github.com/pahaz/sshtunnel/blob/bd4ae32344a3a68ce27b1ad27c992687613b3182/sshtunnel.py#L1026

to kick in and allow for DEFAULT_SSH_DIRECTORY to be searched. With the result that no keys are found even when there are plenty!

When running sshtunnel as a thread, exceptions from the handler are printed to the console directly. This is often not a desired feature, since the console will become cluttered by error messages for any connection in error -- even when the majority of connections are successful. This pull request adds a boolean flag silent, that suppresses the exceptions while continuing to correctly log these errors using the Python logging module.

With the addition of the logging.raiseExceptions flag, sshtunnel can now be operated in a completely silent way.

import paramiko
from sshtunnel import *
import logging

logging.raiseExceptions = False

server = SSHTunnelForwarder(
    ssh_address=('1.2.3.4', 22),
    ssh_username='username',
    ssh_private_key=paramiko.RSAKey.from_private_key_file('...'),
    remote_bind_address=('127.0.0.1', 80),
    local_bind_address=('127.0.0.1', 80),
    silent=True,
)

server.start()

I could not manage it.. Has anybody tried that ? Which options should be used ?

I was (seemingly) able to connect to SSH using paramiko with Pageant, but I could not establish working tunnel for MySQL

I can provide more details if anyone is interested.

I'm finding that my scripts are hanging forever even after I close the tunnel. This happens in versions 0.2.1 and 0.2.0, but not 0.1.5. So I think something has happened to break this.

Note that in my use case I do not want to use a context manager. I'm deploying inside an AWS Lambda function, and I want to cache the connection between Lambda invocations, which means I need to assign the tunnel object to a global variable. I also have some unit tests with the unittest module's setUp() and tearDown() functions.

The difference between .start() and the context manager seems to be:

.daemon_forward_servers = True
.daemon_transport = True

What's the meaning of these parameters? Why are the defaults different between context manager and a function?

Steps to reproduce

We'll SSH to localhost, so run:

ssh key-gen
cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

Then run this script:

from sshtunnel import SSHTunnelForwarder
from time import sleep

server = SSHTunnelForwarder(
    ssh_address_or_host='localhost',
    remote_bind_address=('localhost', 80),
    local_bind_address=('localhost', 8088),
    ssh_username='ec2-user',
    ssh_port=22,
    ssh_pkey='~/.ssh/epic_ssh_unit_test_key.private',
    ssh_config_file=None,
    allow_agent=False,
    set_keepalive=10,
    threaded=True
)
print("About to start")
server.start()

while not server.is_active:
    sleep(1)
    
print("SSH up")

server.stop()
while server.is_active:
    sleep(1)
print("Server stopped")

If I add:

server.daemon_forward_servers = True
server.daemon_transport = True

just before server.start() then it does work.

Note that it does work with the context manager:

import sshtunnel

with sshtunnel.open_tunnel(
        ssh_address_or_host='localhost',
        remote_bind_address=('localhost', 80),
        local_bind_address=('localhost', 8088),
        ssh_username='ec2-user',
        ssh_port=22,
        ssh_pkey='~/.ssh/epic_ssh_unit_test_key.private',
        ssh_config_file=None,
        allow_agent=False,
        set_keepalive=10,
        threaded=True
    ) as tunnel:

    print("SSH up")

print("Server stopped")

I think this is related to #169 , but hard to tell since there's no detail there.

I'm connecting to a variety of database (Oracle, PostgreSQL und MS SQL) via SQLAlchemy. Connecting to an Oracle database makes the tunnel hang. This does not happen for PostgreSQL or MS SQL or when using plink to create the tunnel.

I've created a trace log.

oracle-hang.txt

This is Python 3.6.2 64-bit on Windows. All modules have the latest version. Regards, Thorsten

This is a bit of a heisenbug. If I open a tunnel on my laptop from localhost:65000 to dbserver:1521 through server jumpserv, and then open a connection through it (in my case it was cx_Oracle accessing dbserver), closing the SSHTunnelForwarder without closing the dbserver connection prior works fine - the connection drops and the closing finishes. However, if the same tunnel is opened on jumpserv, from localhost:6500 to server dbserver:1521 through server jumpserv, and then I open the same connection through it, closing the SSHTunnelForwarder without closing the dbserver connection prior leads to a deadlock. This can lead to strange behaviour, as the same code works fine when executed on one machine and deadlocks on another. If you'd like, I can try to provide minimal code samples.

It would be nice if sshtunnel was packaged in a more modern way - inside it's own sshtunnel package directory with __init__.py, and the ability to break up the package into multiple .py modules. I also believe this would be helpful with adding of mypy static type checking support.

Mypy is presently not happy with sshtunnel, as it is not annotated with python types in it's variables and function signatures.

If you try importing sshtunnel in a project, and you run mypy against it, you will get messages similar to this:

myproject/ssh_tunnel.py:2: error: Skipping analyzing "sshtunnel": module is installed, but missing library stubs or py.typed marker
myproject/main.py:13: error: Skipping analyzing "sshtunnel": module is installed, but missing library stubs or py.typed marker
myproject/main.py:13: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
Found 2 errors in 2 files (checked 32 source files)
[cargo-make] ERROR - Error while executing command, exit code: 1
[cargo-make] WARN - Build Failed.

I created this issue to track progress of sshtunnel working well with Mypy - being able to check sshtunnel's static typing. This also would encompass adding static typing to sshtunnel, which will aid testing.

Hello dear

I am working on a client-side connection that will open a tunnel on a server with a user that doesn't have permission to run command and the user only can use port forwarding so on client-side ssh most run with the -N argument

now where I open my tunnel the tunnel will close by the server because the ssh tunnel didn't pass -N

how can I solve this issue?

I'm trying to use SSH agent to tunnel to a remote machine, but I want to explicitly ONLY allow key-based authentication (from the client side) based on a key passed in at runtime, not based off of whatever the OS has saved at the time. However, SSHTunnelForwarder appears to be ignoring these directives and is successfully connecting every time, even when I deliberately pass in the incorrect key. Minimum viable example below:

import time

from sshtunnel import SSHTunnelForwarder

tunnel = SSHTunnelForwarder(
    'my.server.ip.address',
    ssh_config_file=None,
    ssh_username='edgeot',
    ssh_pkey='/home/fshriver/test_keys/test_key',
    local_bind_address=('127.0.0.1', 9555),
    remote_bind_address=('127.0.0.1', 9555),
    allow_agent=False
)

tunnel.start()

print(tunnel.tunnel_is_up)

time.sleep(10)

tunnel.close()

As stated, if I've ssh'd into the server before then sshtunnel will never fail to ssh in, even when I change the key to some non-existent filepath. I believe this is because it's still using the ssh agent, but my understanding is allow_agent=False should disable that. Is that incorrect behavior? Am I missing something?