def _open_tunnels(self):
self.tunnels = {}
auth = {
"ssh_username": self.user,
"ssh_password": self.password,
"ssh_pkey": self.pkey
}
if self.gateway:
self.tunnels["gateway"] = open_tunnel(
ssh_address_or_host=self.gateway,
remote_bind_address=self.host,
block_on_close=False,
**auth)
self.tunnels["gateway"].start()
self.host = ("localhost", self.tunnels["gateway"].local_bind_port)
self.tunnels["socket"] = open_tunnel(
ssh_address_or_host=self.host,
remote_bind_address=(self.SOCKET_HOST, self.SOCKET_PORT),
block_on_close=False,
**auth)
self.tunnels["socket"].start()
self.tunnels["ssh"] = open_tunnel(ssh_address_or_host=self.host,
remote_bind_address=(self.SSH_HOST,
self.SSH_PORT),
block_on_close=False,
**auth)
self.tunnels["ssh"].start()
self.host = ("localhost", self.tunnels["socket"].local_bind_port)
def start(self, remote=False):
if remote:
REMOTE_SERVER_IP = 'sunfire.comp.nus.edu.sg'
PRIVATE_SERVER_IP = '137.132.86.228'
username = input("Enter ssh username: "******"Enter ssh password: ")
key = 'Sixteen byte key' #remember to hide
tunnel1 = sshtunnel.open_tunnel(
(REMOTE_SERVER_IP, 22),
remote_bind_address=(PRIVATE_SERVER_IP, 22),
ssh_username=username,
ssh_password=password,
# local_bind_address=('127.0.0.1', 8081),
block_on_close=False)
tunnel1.start()
print('[Tunnel Opened] Tunnel into Sunfire opened ' +
str(tunnel1.local_bind_port))
tunnel2 = sshtunnel.open_tunnel(
ssh_address_or_host=(
'localhost', tunnel1.local_bind_port), # ssh into xilinx
remote_bind_address=('127.0.0.1', 10022), # binds xilinx host
ssh_username='******',
ssh_password='******',
local_bind_address=('127.0.0.1',
10022), # localhost to bind it to
block_on_close=False)
tunnel2.start()
self.connectAndIdentify('127.0.0.1', 10022, self.dancerID)
else:
self.connectAndIdentify('127.0.0.1', 10022, self.dancerID)
def main():
debug = os.environ.get('DEBUG')
logging.basicConfig(level=logging.DEBUG if debug else logging.INFO)
delay = int(os.environ.get('POLL_PERIOD', '60'))
server = os.environ['JENKINS_URI']
status = StatusBoard(pwm=True)
job_names = [os.environ.get('JENKINS_JOB_%d' % (i + 1)) for i in range(5)]
job_color = [None for _ in job_names]
ssh_relay = os.environ.get('SSH_RELAY')
ssh_user = os.environ.get('SSH_USER')
ssh_key = os.environ.get('SSH_KEY')
while True:
try:
logging.info("Setting up ssh tunnel via %s@%s", ssh_user,
ssh_relay)
url = urlparse(server)
host = url.netloc.split(':')[0]
port = url.port if url.port else 80
with sshtunnel.open_tunnel(ssh_relay,
ssh_username=ssh_user,
ssh_pkey=ssh_key,
remote_bind_address=(host, port),
local_bind_address=('localhost',
12345)):
poll_server(
url._replace(netloc='localhost:12345').geturl(), status,
job_names, job_color)
time.sleep(delay)
except ConnectionError:
logging.exception("Unable to connect")
display_warning(delay, status)
job_color = [None for _ in job_names]
def execute(self, method, **kwargs):
try:
print(self.use_ssh)
print(bool(self.use_ssh))
conn = None
result = None
if self.use_ssh:
print("DSFKLSDJFL:KDSJFLK:DJF USING SSH")
with open_tunnel(
(self.ssh_host, self.ssh_port),
ssh_username=self.ssh_usr,
ssh_password=self.ssh_pass,
remote_bind_address=(self.svr, self.db_port),
local_bind_address=(self.svr,
self.db_port)) as sshserver:
conn = psycopg2.connect(host=self.svr,
database=self.dbname,
user=self.usr,
password=self.passcode)
result = method(conn, **kwargs)
sshserver.stop()
return result
else:
print("GHGHGHGHGGHG NOT using SSH")
conn = psycopg2.connect(host=self.svr,
database=self.dbname,
user=self.usr,
password=self.passcode,
port=self.db_port)
return method(conn)
except (Exception, psycopg.DatabaseError) as error:
print(error)
finally:
if conn is not None:
conn.close()
def main(config, input_stream=None):
tunnel = None
try:
LOGGER.info(config)
if bool(config.get('use_ssh_tunnel')) == True:
LOGGER.info(
f"use_ssh_tunnel is set to true; connecting to {config['redshift_host']}:{config['redshift_port']} via {config['ssh_jump_server']}:{config['ssh_jump_server_port']}"
)
tunnel = sshtunnel.open_tunnel(
(config['ssh_jump_server'], int(
config['ssh_jump_server_port'])),
ssh_username=config['ssh_username'],
ssh_pkey=config['ssh_private_key_path'],
ssh_private_key_password=config['ssh_private_key_password']
if 'ssh_private_key_password' in config else None,
remote_bind_address=(config['redshift_host'],
int(config['redshift_port'])))
tunnel.start()
time.sleep(1)
config[
'redshift_host'] = '127.0.0.1' # rewrite the config to go through the tunnel
config['redshift_port'] = tunnel.local_bind_port
else:
LOGGER.debug(
f"use_ssh_tunnel is not set or is false; connecting directly to {config['redshift_host']}:{config['redshift_port']}"
)
with psycopg2.connect(
connection_factory=MillisLoggingConnection,
host=config.get('redshift_host'),
port=config.get('redshift_port', 5439),
dbname=config.get('redshift_database'),
user=config.get('redshift_username'),
password=config.get('redshift_password')) as connection:
s3_config = config.get('target_s3')
s3 = S3(s3_config.get('aws_access_key_id'),
s3_config.get('aws_secret_access_key'),
s3_config.get('bucket'),
s3_config.get('key_prefix'),
aws_session_token=s3_config.get('aws_session_token'))
redshift_target = RedshiftTarget(
connection,
s3,
redshift_schema=config.get('redshift_schema', 'public'),
logging_level=config.get('logging_level'),
default_column_length=config.get('default_column_length',
1000),
persist_empty_tables=config.get('persist_empty_tables'))
if input_stream:
target_tools.stream_to_target(input_stream,
redshift_target,
config=config)
else:
target_tools.main(redshift_target)
finally:
if tunnel is not None:
tunnel.stop()
def getTunnel(self):
tunnel = open_tunnel((self._host, 22),
ssh_username='******',
ssh_pkey=self._pubkey,
remote_bind_address=('127.0.0.1', 8834),
local_bind_address=('0.0.0.0', ))
return tunnel
def _get_connection(self, sql, params, method_instance):
"""
Creates a connection to the database
Args:
sql: The original SQL query.
params: The original params.
method_instance: An instance of the method requesting the database connection.
Returns: The results of the original method instance.
"""
if self.use_ssh:
with open_tunnel(
(self.ssh_host, self.ssh_port),
ssh_username=self.ssh_user,
ssh_pkey=self.ssh_key_path,
remote_bind_address=(self._db_host, self.db_port),
local_bind_address=(self.ssh_local_bind_address,
self.ssh_local_bind_port)) as tunnel:
if self._config.ssh_logging_level:
tunnel.logger = create_logger(
loglevel=self._config.ssh_logging_level)
host = tunnel.local_bind_host
port = tunnel.local_bind_port
return self._database_connection_sub_method(
host, port, method_instance, sql, params)
else:
host = self._db_host
port = self._db_port
return self._database_connection_sub_method(
host, port, method_instance, sql, params)
def query_from_mongodb(db_name,
collection_name,
query_conditions,
columns,
conn_info=config.mongo_conn_info):
"""
在mongodb中查询数据
:param db_name:
:param collection_name:
:param query_conditions:
:param columns: 指定返回的列。（未生效，待调试）
:param conn_info:
:return:
"""
with sshtunnel.open_tunnel(
ssh_address_or_host=(config.base_ip, 22),
ssh_password=config.ssh_root_password,
ssh_username='******',
remote_bind_address=(conn_info['host'], conn_info['port']),
local_bind_address=('0.0.0.0', conn_info['port'])) as tunnel:
client = pymongo.MongoClient(port=conn_info['port'],
username=conn_info['username'],
password=conn_info['passwd'])
db = client[db_name]
collection = db[collection_name]
res = []
for i in collection.find(query_conditions, columns):
# res.append(list(i.values()))
res.append(i)
# print(res)
return res
def wrapper(*args, **kwargs):
try:
remote_host, remote_port = query_runner.host, query_runner.port
except NotImplementedError:
raise NotImplementedError(
"SSH tunneling is not implemented for this query runner yet."
)
stack = ExitStack()
try:
bastion_address = (details["ssh_host"],
details.get("ssh_port", 22))
remote_address = (remote_host, remote_port)
auth = {
"ssh_username": details["ssh_username"],
**settings.dynamic_settings.ssh_tunnel_auth(),
}
server = stack.enter_context(
open_tunnel(bastion_address,
remote_bind_address=remote_address,
**auth))
except Exception as error:
raise type(error)("SSH tunnel: {}".format(str(error)))
with stack:
try:
query_runner.host, query_runner.port = server.local_bind_address
result = f(*args, **kwargs)
finally:
query_runner.host, query_runner.port = remote_host, remote_port
return result
def get_deployment_target_client(target: MachineDeploymentBlock):
with open(target.bastion_ssh_key_path,
'r') as bastion_key_file_handler:
bastion_key = paramiko.RSAKey.from_private_key(
StringIO(bastion_key_file_handler.read()))
with open(target.deployment_target_ssh_key_path,
'r') as bastion_key_file_handler:
deployment_target_key = paramiko.RSAKey.from_private_key(
StringIO(bastion_key_file_handler.read()))
with open_tunnel(ssh_address_or_host=(target.bastion_address, 22),
remote_bind_address=(target.deployment_target_address,
22),
ssh_username=target.bastion_user_name,
ssh_pkey=bastion_key) as tunnel:
logger.info(
f"Opened SSH tunnel to {target.deployment_target_address} via {target.bastion_address} "
)
with paramiko.SSHClient() as client:
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect('localhost',
port=tunnel.local_bind_port,
username=target.deployment_target_user_name,
pkey=deployment_target_key,
compress=True,
banner_timeout=60)
yield client
def __enter__(self):
from sshtunnel import open_tunnel
wrapped_conn = get_hook(self.wrapped_conn_id)
self.tunnel = open_tunnel(
(self.remote_ip, self.remote_port),
ssh_username=self.ssh_username,
ssh_pkey=self.ssh_pkey,
ssh_password=self.ssh_password,
remote_bind_address=(wrapped_conn.conn_params.host,
wrapped_conn.conn_params.port),
)
self.tunnel.start()
self.tunneled_conn = wrapped_conn.__class__.__new__(
wrapped_conn.__class__)
self.tunneled_conn.__init__(
ConnectionParams(
conn_type=wrapped_conn.conn_params.conn_type,
host=self.tunnel.local_bind_host,
port=self.tunnel.local_bind_port,
login=wrapped_conn.conn_params.login,
password=wrapped_conn.conn_params.password,
extra=wrapped_conn.conn_params.extra,
))
return self.tunneled_conn.__enter__()
def engage(SERVER, PORT, USER, PASSWD):
with open_tunnel((SERVER, PORT),
ssh_username=USER,
ssh_password=PASSWD,
remote_bind_address=("127.0.0.1", 8080)) as server:
print(server.local_bind_port)
while not END_SERVER:
sleep(1)
def create_tunnel(tunnel_host, tunnel_port, tunnel_user, tunnel_password,
pg_host, pg_port):
server = sshtunnel.open_tunnel((tunnel_host, int(tunnel_port)),
ssh_username=tunnel_user,
ssh_password=tunnel_password,
remote_bind_address=(pg_host, int(pg_port)))
server.start()
port = server.local_bind_port
return port
def connect(self, service_host, port):
DEBUG('Create ssh tunnel:', self.user, self.passwd, self.host, 'bind:', service_host, port)
self.tunnel = sshtunnel.open_tunnel(
self.host, ssh_username=self.user, ssh_password=self.passwd,
remote_bind_address=(service_host, port),
set_keepalive=0.5,
#debug_level='TRACE'
)
return self.tunnel
def bastion_host():
with sshtunnel.open_tunnel(
(bastion_host_url, bastion_host_port),
ssh_username="******",
remote_bind_address=(nas_url, nas_port),
local_bind_address=(locally_bound_ip,
locally_bound_port)) as tunnel:
logger.info('Opening tunnel')
yield tunnel
async def _connect(self):
"""Creates a connection to the database, either directly or through a tunnel"""
log.spam("Attempting to connect to local database")
try:
self.dbPool = await aiomysql.create_pool(
user=DBUser,
password=DBPass,
host="127.0.0.1",
port=3306,
auth_plugin="mysql_native_password",
maxsize=10)
except:
# Probably working on a dev machine, create a tunnel
log.warning(
"Unable to connect to database, attempting to create SSH Tunnel"
)
self.tunnel = sshtunnel.open_tunnel(
(serverAddress, serverPort),
ssh_username=sshUser,
ssh_pkey="opensshkey.ppk",
remote_bind_address=(localAddress, localPort),
local_bind_address=(localAddress, localPort),
logger=utilities.getLog("tunnel", logging.CRITICAL))
self.tunnel.start()
while not self.tunnel.is_active:
# Wait for the tunnel to be considered active
time.sleep(0.1)
log.spam(
f"Connected to DB Server: {self.tunnel.is_active}. "
f"LocalAddr: {self.tunnel.local_bind_host}:{self.tunnel.local_bind_port}"
)
log.debug("Attempting to connect to tunneled database")
try:
self.dbPool = await aiomysql.create_pool(
user=DBUser,
password=DBPass,
host=self.tunnel.local_bind_host,
port=self.tunnel.local_bind_port,
auth_plugin="mysql_native_password",
maxsize=10,
)
except Exception as e:
log.critical(f"Failed to connect to db, aborting startup: {e}")
exit(1)
# Configure db to accept emoji inputs (i wish users didnt do this, but i cant stop em)
await self.execute('SET NAMES utf8mb4;')
await self.execute('SET CHARACTER SET utf8mb4;')
await self.execute('SET character_set_connection=utf8mb4;')
databases = await self.execute("SHOW SCHEMAS")
log.info(
f"Database connection established. {len(databases)} schemas found")
return True
def ssh_tunnel(ip, port):
"""Return a SSH tunnel to the Mongo db
"""
tunnel = open_tunnel(block_on_close=False,
ssh_address_or_host='jump01.slunow.bskyb.com',
ssh_port=22,
ssh_username=os.getenv('q'),
ssh_password=os.getenv('a'),
remote_bind_address=(ip, port))
tunnel.start()
return tunnel
def start_tunnel(self, user, password):
tunnel1 = sshtunnel.open_tunnel(
('sunfire.comp.nus.edu.sg', 22), #host address for ssh, 22
remote_bind_address=('137.132.86.243', 22), #xilinx address to bind to localhost port
ssh_username=user,
ssh_password=password,
block_on_close=False
)
tunnel1.start()
print('[Tunnel Opened] Tunnel into Sunfire opened' + str(tunnel1.local_bind_port))
tunnel2 = sshtunnel.open_tunnel(
ssh_address_or_host=('localhost', tunnel1.local_bind_port), #ssh into xilinx
remote_bind_address=('127.0.0.1', 8083), #binds xilinx host
ssh_username='******',
ssh_password='******',
local_bind_address=('127.0.0.1', 8083), #localhost to bind it to
block_on_close=False
)
tunnel2.start()
print('[Tunnel Opened] Tunnel into Xilinx opened')
async def main():
with open_tunnel((REMOTE_SERVER_IP, 22),
ssh_username=REMOTE_SERVER_USER,
ssh_pkey=REMOTE_SERVER_PUBKEY,
remote_bind_address=('127.0.0.1', REMOTE_BIND_PORT),
local_bind_address=('0.0.0.0', )) as tunnel:
async with aiohttp.ClientSession() as session:
async with session.get(
f"http://127.0.0.1:{tunnel.local_bind_port}/v1/policy/list"
) as response:
if response.status == 200:
policies = json.loads(await response.text())
print(json.dumps(policies, indent=2))
def get_deployment_target_client_context(
block_to_deploy: MachineDeploymentBlock):
with open(block_to_deploy.deployment_target_ssh_key_path,
'r') as ssh_key_file_handler:
deployment_target_key = paramiko.RSAKey.from_private_key(
StringIO(ssh_key_file_handler.read()))
if block_to_deploy.bastion_address is None:
with paramiko.SSHClient() as client:
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
logger.info(
f"Connecting directly to {block_to_deploy.deployment_target_address}, "
f"using key at {block_to_deploy.deployment_target_ssh_key_path}"
)
client.connect(
block_to_deploy.deployment_target_address,
port=22,
username=block_to_deploy.deployment_target_user_name,
pkey=deployment_target_key,
compress=True,
banner_timeout=60)
yield client
return
with open(block_to_deploy.bastion_ssh_key_path,
'r') as bastion_key_file_handler:
bastion_key = paramiko.RSAKey.from_private_key(
StringIO(bastion_key_file_handler.read()))
with open_tunnel(
ssh_address_or_host=(block_to_deploy.bastion_address, 22),
remote_bind_address=(block_to_deploy.deployment_target_address,
22),
ssh_username=block_to_deploy.bastion_user_name,
ssh_pkey=bastion_key) as tunnel:
logger.info(
f"Opened SSH tunnel to {block_to_deploy.deployment_target_address} via {block_to_deploy.bastion_address} "
)
with paramiko.SSHClient() as client:
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(
'localhost',
port=tunnel.local_bind_port,
username=block_to_deploy.deployment_target_user_name,
pkey=deployment_target_key,
compress=True,
banner_timeout=60)
yield client
def open_sshtunnel(thread):
with sshtunnel.open_tunnel(
("proxy-vm.ddns.net", 22),
ssh_username="******",
ssh_pkey="Public_Key.pem",
remote_bind_address=("0.0.0.0", 8000),
local_bind_address=('127.0.0.1', 54321)) as tunnel:
client = paramiko.SSHClient()
client.load_system_host_keys()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
#client.connect('127.0.0.1', 4444)
#do some operations with client session
#client.close()
#source: https://pypi.org/project/sshtunnel/
thread.join()
def test_local_side(self):
loc_port = random.randint(21000, 30000)
rem_host = '192.168.1.1'
rem_port = 443
print 'Trying to log in to tunnel'
tunnel = sshtunnel.open_tunnel(gateway = 'localhost',
ssh_port = SSH_PORT,
ssh_username = sshserver.SSH_CREDENTIALS[0],
ssh_password = sshserver.SSH_CREDENTIALS[1],
remote_bind_address_list=(rem_host, rem_port),
local_bind_address_list=('', loc_port))
tunnel.start()
tunnel._transport.open_session()
self.assertEqual(tunnel.local_bind_ports, [loc_port])
tunnel.stop()
def sshConnect():
base_path = Path(__file__).parent
file_path = (base_path / "misato")
__file = str(file_path)
sshtunnel.SSH_TIMEOUT = sshtunnel.TUNNEL_TIMEOUT = 10.0
server = sshtunnel.open_tunnel(
('168.61.73.89', 31415),
ssh_username='******',
ssh_pkey=__file,
ssh_private_key_password ='******',
remote_bind_address=('127.0.0.1', 27017)
)
return server
def sshtunconnect(address):
"""
Устанавливает соединение с пробросом порта по заданному IP адресу ( который был найден из JSON объекта) ранее и
передан в функцию в качестве параметра.
"""
server = open_tunnel(
publicipadress,
ssh_username="******",
# ssh_password="******",
ssh_pkey="srv.key", # можно использовать вместо пароля файл ключа
remote_bind_address=address,
local_bind_address=('localhost', 2222
) # адрес и порт куда происходит проброс
)
server.start()
print(server.local_bind_port)
def test_open_tunnel(self):
""" Test wrapper method mainly used from CLI """
server = sshtunnel.open_tunnel(
(self.saddr, self.sport),
ssh_username=SSH_USERNAME,
ssh_password=SSH_PASSWORD,
remote_bind_address=(self.eaddr, self.eport),
logger=self.log,
ssh_config_file=None,
)
self.assertEqual(server.ssh_host, self.saddr)
self.assertEqual(server.ssh_port, self.sport)
self.assertEqual(server.ssh_username, SSH_USERNAME)
self.assertEqual(server.ssh_password, SSH_PASSWORD)
self.assertEqual(server.logger, self.log)
self._test_server(server)
def insert_to_mongodb(db_name,
collections_and_conditions,
conn_info=config.mongo_conn_info):
with sshtunnel.open_tunnel(
ssh_address_or_host=(config.base_ip, 22),
ssh_password=config.ssh_root_password,
ssh_username='******',
remote_bind_address=(conn_info['host'], conn_info['port']),
local_bind_address=('0.0.0.0', conn_info['port'])) as tunnel:
client = pymongo.MongoClient(port=conn_info['port'],
username=conn_info['username'],
password=conn_info['passwd'])
db = client[db_name]
for collection_name, insert_condition in collections_and_conditions.items(
):
collection = db[collection_name]
collection.insert_one(insert_condition)
def tunneling(self,
host,
host_port,
pem_key_path,
remote_ip,
remote_port,
user="******",
local_ip="127.0.0.1",
local_port=10022):
"""ssh tunneling to private server that don't have public ip address"""
return sshtunnel.open_tunnel(
(host, host_port),
ssh_username=user,
ssh_pkey=pem_key_path,
remote_bind_address=(remote_ip, remote_port),
local_bind_address=(local_ip, local_port))
def test_remote_side(self):
rem_port = random.randint(21000, 30000)
rem_host = socket.gethostbyname_ex(socket.gethostname())[0]
print 'Trying to log in to tunnel'
tunnel = sshtunnel.open_tunnel(gateway = 'localhost',
ssh_port = SSH_PORT,
ssh_username = sshserver.SSH_CREDENTIALS[0],
ssh_password = sshserver.SSH_CREDENTIALS[1],
remote_bind_address_list=(rem_host, rem_port))
tunnel.start()
# tunnel._transport.open_channel(kind='session')
tunnel._transport.open_session()
self.assertEqual(tunnel.remote_bind_ports, [rem_port])
self.assertEqual(tunnel.remote_bind_hosts, [rem_host])
# chan.send('dir')
# print chan.recv(1024)
print 'Stopping tunnel'
tunnel.stop()
def ssh_tunnel(self) -> SSHTunnelForwarder:
"""
Get SSH Tunnel instance
:return:
:rtype:
"""
if self._ssh_tunnel is None and self._use_ssh:
self.logger.debug(f"Starting SSH Tunnel {self._ssh_ip}:{self._ssh_port}")
self.logger.debug(f"Username: {self._ssh_username}")
self.logger.debug(f"Password: {''.join('*' for x in self._ssh_password)}")
self._ssh_tunnel = sshtunnel.open_tunnel(
(self._ssh_ip, self._ssh_port),
ssh_username=self._ssh_username,
ssh_password=self._ssh_password,
remote_bind_address=(self._remote_bind_ip, self._remote_bind_port),
)
return self._ssh_tunnel
def run(self):
logger.info("Establishing SSH tunnel...")
local_args = {} if not self.local_port else {'local_bind_address': ('0.0.0.0', self.local_port)}
with sshtunnel.open_tunnel(
(self.ssh_params.host, self.ssh_params.port),
ssh_username=self.ssh_params.user,
ssh_pkey=self.ssh_params.pkey_file,
ssh_private_key_password=self.ssh_params.pkey_pass,
remote_bind_address=(self.remote_server, self.remote_port),
**local_args
) as tunnel:
self.local_port = tunnel.local_bind_port
self.is_running = True
logger.info("SSH tunnel established, port: %s" % self.local_port)
while not self.terminating:
time.sleep(0.5)
self.is_running = False
logger.info("Closing SSH tunnel")
def __init__(self, device, adb: ADB):
self._adb = adb
self._device = device
host, port = device.serial.split(":")
atexit.register(self.close)
self._tunnel = sshtunnel.open_tunnel(
self._adb.ssh_tunnel.ssh_host,
self._adb.ssh_tunnel.ssh_port,
ssh_username=self._adb.ssh_tunnel.ssh_username,
ssh_password=self._adb.ssh_tunnel.ssh_password,
remote_bind_address=(host, int(port))
)
self._tunnel.start()
self._ui_automator = UIAutomatorDevice(
device.serial,
adb_server_host="127.0.0.1",
adb_server_port=self._tunnel.local_bind_port
)
def init_tunnels(self, system=None):
"""
Initialize SSH tunnels using ``sshtunnel`` and ``paramiko`` libraries.
Arguments:
- system
Type: string
Default: ``None``
Description:
system to initialize the tunnels. If nothing given it initializes
tunnels for all systems in ``self.systems``.
Return:
``SSHTunnelForwarder`` instance (non-started) with all tunnels
already established
"""
if not self._check_if_using_gateway(system):
return
self.logger.info('Initializing tunnels')
if not self.conf:
self.conf = arguments.read_config(self.settings_file)
jumpbox_addr = self.conf.get('GATEWAY', 'ip_or_hostname')
jumpbox_port = self.conf.getint('GATEWAY', 'ssh_port')
rbal = []
lbal = []
tunnelports = {}
systems = [system] if system else self.systems
sshtunnel.SSH_TIMEOUT = arguments.DEFAULT_SSH_TIMEOUT
for _sys in systems:
rbal.append((self.conf.get(_sys, 'ip_or_hostname'),
self.conf.getint(_sys, 'ssh_port')))
lbal.append(('', self.conf.getint(_sys, 'tunnel_port')))
if len(tunnelports) != len(set(tunnelports.values())):
self.logger.error('Local tunnel ports MUST be different: {0}'
.format(tunnelports))
raise sshtunnel.BaseSSHTunnelForwarderError
try:
pwd = self.conf.get('GATEWAY', 'password').strip("\"' ") or None \
if self.conf.has_option('GATEWAY', 'password') else None
pkey = self.conf.get('GATEWAY', 'identity_file').strip("\"' ") \
or None if self.conf.has_option('GATEWAY', 'identity_file') \
else None
user = self.conf.get('GATEWAY', 'username') or None \
if self.conf.has_option('GATEWAY', 'username') else None
self.server = sshtunnel.open_tunnel(
ssh_address_or_host=(jumpbox_addr, jumpbox_port),
ssh_username=user,
ssh_password=pwd,
remote_bind_addresses=rbal,
local_bind_addresses=lbal,
threaded=True,
logger=self.logger,
ssh_pkey=pkey,
ssh_private_key_password=pwd,
set_keepalive=15.0,
allow_agent=False,
mute_exceptions=True,
skip_tunnel_checkup=False,
)
self.server.is_use_local_check_up = True # Check local side
self._start_server()
assert self.server.is_alive
# Add the system<>port bindings to the return object
self.server.tunnelports = dict(
list(zip(systems, self.server.local_bind_ports))
)
self.logger.debug('Registered tunnels: {0}'
.format(self.server.tunnelports))
except (sshtunnel.BaseSSHTunnelForwarderError, AssertionError):
self.logger.error('{0}Could not open connection to remote server: '
'{1}:{2}'.format(
'{0} | '.format(system) if system else '',
jumpbox_addr,
jumpbox_port
))
raise sshtunnel.BaseSSHTunnelForwarderError
