Paramiko. Reverse Forward Tunnel Question- Help Appreciated

Question

So I've been working with the Paramiko Libary. I have a client and two servers Server A & Server B. The client connects to Server A, and then requests a reverse-forwarded tunnel to Server B, there is a lot more functionality to write into it but my problem at the moment is very fundamental and likely has a very simply answer I'm just somehow overlooking or not understanding.

What I am trying to do at this point is have Server A send some information to Server B every time it connects to it, which due to a timer on the client should after a connection is closed be each minute. (reconnecting each time)

I want to have Server A send, Server B some information every time it connects to it. Now my question relates to how I'd achieve that.

My first thought was to have the client send a command to Server A after the reverse tunnel is connected, I suspect and here my understanding may be wrong, thus why I'm checking here. The command (which is a string) will be forwarded by Server A to Server B, whilst I am looking for the response to that command to be sent Server B.

The other option as I see it is to have Server A push the data to Server B. But I don't know how to check for when a reverse-forwarded-tunnel is created, I could do it for any connection but then that seems inefficient, as the client will get some data, then the data will once again be sent as the reverse forward tunnel is created. (Again likely overlooking something simple here)

So I'm curious given my code's present state what could I do, could change that would let me check for when a reverse-forward-tunnel is made to Server B so I can send the data I want to send to it.

Thank you for taking the time to try and help me here, and yes I understand hardcoding in passwords etc is a bad idea for application security.

The code below is the client & server code (which again need some work but are getting there.)

client Code

import getpass
import os
import socket
import select
import sys
import threading
import paramiko
from paramiko import Channel
import schedule
import time
import string
import random
from optparse import OptionParser

IP = '127.0.0.1'
USER = 'user'
PASSWORD = 'CrabRave'
PORT = 900
REMOTE_PORT = 443
REMOTE_IP = ... ###Remote IP will go here.

def handler(chan, host, port):
    sock = socket.socket()
    try:
        sock.connect((IP, PORT))
    except Exception as e:
        Timer()

def ssh_client(IP, PORT, USER, PASSWORD):
    client = paramiko.SSHClient()
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    client.connect(IP, PORT, USER, PASSWORD)
    ssh_session = client.get_transport().open_session()

def reverse_forward_tunnel(PORT, REMOTE_IP, REMOTE_PORT, transport):
    transport.request_port_forward("", PORT)
    while True:
        chan = transport.accept(1000)
        if chan is None:
            continue
        thr = threading.Thread(
            target=handler, args=(chan, REMOTE_IP, REMOTE_PORT))
        thr.setDaemon(True)
        thr.start()

def Timer():
    if Channel.is_active():
        schedule.every(1).seconds.do(Timer)
    else: schedule.every(1).minutes.do(main)

def main():
    client = ssh_client
    
    try:
        ssh_client(IP, PORT, USER, PASSWORD)
    except Exception as E:
        Timer()
    
    try:
        reverse_forward_tunnel(PORT, REMOTE_IP, REMOTE_PORT, client.get_transport())
    except KeyboardInterrupt:
        Timer()
    
    try: Timer()
    except Exception as E:
        Timer
    
if __name__ == '__main__':
    main()

Server Code

from ABC import abstractmethod
from sys import platform
from Shell import Shell
from cmd import Cmd
from src.server_base import ServerBase
from src.ssh_server_interface import SshServerInterface
from src.shell import Shell
from src.ssh_server import SshServer
import base64
import os
import socket
import sys
import paramiko
import threading
import string
import random

my_key = ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits) for _ in range(100))

class Shell(Cmd):
    use_rawinput=False
    promt='My Shell> '

    def __init__(self, stdin=None, stdout=None):
        super(Shell, self).__init__(completkey='tab', stdin=stdin, stdout =stdout)

    def print(self, value):
        if self.stdout and not self.stdout.closed:
            self.stdout.write(value)
            self.stdout.flush()

    def printline(self, value):
        self.print(value + '\r\n')

    def emptyline(self):
        self.print('\r\n')

class ServerBase(ABC):
    def __init__(self):
        self._is_running = threading.Event()
        self._socket = None
        self.client_shell = None
        self._listen_thread = None

    def start(self, address='127.0.0.1', port=900, timeout=1):
        if not self._is_running.is_set():
            self._is_running.set()
            self._socket(socket.AF_INET, socket.SOCK_STREAM)

            if platform == "linux" or platform == "linux2":
                self._socket.setsocketopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, True)

            self._socket.settimeout(timeout)
            self._socket.bind((address, port))
            
            self._listen_thread = threading.Thread(target=self._listen)
            self._listen_thread.start()

    def stop(self):
        if self._is_running.is_set():
            self._is_running.clear()
            self._listen_thread.join()
            self._socket.close()

    def listen(self):
        while self._is_running.is_set():
            try:
                self._socket.listen()
                client, addr = self._socket.accept()
                self.connection_function(client)
            except socket.timeout:
                pass 
        
        @abstractmethod
        def connection_function(self, client):
            pass

class SshServerInterface(paramiko.ServerInterface):

    def check_channel_request(self, kind, chanid):
        if kind == "session":
            return paramiko.OPEN_SUCCEEDED

    def check_auth_password(self, username: str, password: str) -> int:
        if (username == "user") and (password == "CrabRave"):
            return paramiko.AUTH_SUCCESSFUL
        return paramiko.AUTH_FAILED

    def check_channel_pty_request(self, channel: Channel, term: bytes, width: int, height: int, pixelwidth: int, pixelheight: int, modes: bytes):
        return True

    def check_channel_shell_request(self, channel: Channel) -> bool:
        return True

    def check_channel_env_request(self, channel: Channel, name: bytes, value: bytes) -> bool:
        return True

    def check_port_forward_request(self, address: str, port: int) -> int:
        return port

class SshServer(ServerBase):

    def __init__(self, host_key_file, host_key_file_password=None):
        super(SshServer, self).__init__()
        self._host_key = paramiko.RSAKey.from_private_key_file(StringIO.StringIO(my_key))

    def connection_function(self, client):
        try:
            session = paramiko.Transport(client)
            session.add_server_key(self._host_key)

            server = SshServerInterface()
            try:
                session.start_server(server=server)
            except paramiko.SSHException:
                return
            
            channel = session.accept()
            stdio = channel.makefile('rwU')
            
            self.client = Shell(stdio, stdio)
            self.client_shell.cmdloop()

            session.close()
        except:
            pass

if __name__ == '__main__':
    server = SshServer(my_key)
    server.start()