def search_atlas(ra, dec):
atlas_info = lc_cfg['atlas_info']
gateway_session1 = SSHSession(atlas_info[0]['address'],atlas_info[0]['username'], password=atlas_info[0]['password']).open()
if len(atlas_info)==3:
gateway_session2 = gateway_session1.get_remote_session(atlas_info[1]['address'],atlas_info[1]['username'], password=atlas_info[2]['password'])
remote_session = gateway_session2.get_remote_session(atlas_info[2]['address'], password=atlas_info[2]['password'])
elif len(atlas_info)==2:
remote_session = gateway_session1.get_remote_session(atlas_info[1]['address'], password=atlas_info[1]['password'])
else:
print('wrong format for atlas_params: too many jump connection')
today = dt.today()
con = sqlite3.connect(":memory:")
tdate = ' '+str(list(con.execute("select julianday('"+today.strftime("%Y-%m-%d")+"')"))[0][0]-lc_cfg['lookback_days']-2400000)
result=remote_session.get_cmd_output('./mod_force.sh '+str(ra)+' '+ str(dec)+tdate)
atlas_lc = at.Table(names=('jd','mag', 'mag_err','flux', 'fluxerr', 'filter','maj', 'min', 'apfit', 'sky', 'zp', 'zpsys'), dtype=('f8', 'f8', 'f8', 'f8', 'f8', 'S1' , 'f8', 'f8', 'f8', 'f8','f8', 'U8'))
split = result.split('\r\n')
for i in split[1:]:
k = i.split()
# if int(k[3])>int(k[4]):
atlas_lc.add_row([float(k[0]), float(k[1]), float(k[2]), float(k[3]), float(k[4]), k[5], float(k[12]), float(k[13]), float(k[15]), float(k[16]), float(k[17]), 'ab'])
return atlas_lc
def test_file(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
remotehost_ip, remotehost_port = docker_env.get_host_ip_port('remotehost')
remotehost_session = gateway_session.get_remote_session(
host=tests_util.get_host_ip(),
port=remotehost_port,
username='******',
password='******')
file_content = json.dumps(tests_util.create_random_json())
# create file in a location with root access needed should fail by default
with pytest.raises(IOError) as excinfo:
remotehost_session.file(remote_path='/etc/a_file',
content=file_content)
assert excinfo.value.errno == errno.EACCES
assert excinfo.value.strerror == 'Permission denied'
# do same command with root access
remotehost_session.file(remote_path='/etc/a_file',
content=file_content,
use_sudo=True)
def test_ssh_connection_error(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
# open first ssh session to gateway
gateway_session1 = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
# modify password from session 1
gateway_session1.run_cmd('echo "user1:newpassword" | sudo -S chpasswd')
# try to open 2nd session
with pytest.raises(exception.ConnectionError) as excinfo:
SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
assert type(excinfo.value.__cause__
) == paramiko.ssh_exception.AuthenticationException
# set back correct password from session 1
gateway_session1.run_cmd('echo "user1:password1" | sudo -S chpasswd')
# try again to open 2nd session
gateway_session2 = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
assert gateway_session2.is_active()
def test_get_cmd_output(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
assert gateway_session.get_cmd_output('hostname') == 'gateway.example.com'
def test_unknown_host():
with pytest.raises(exception.ConnectionError) as excinfo:
SSHSession(host='unknown_host', username='******').open()
assert type(excinfo.value.__cause__) == socket.gaierror
with pytest.raises(exception.ConnectionError) as excinfo:
SSHSession(host='unknown_host', username='******').open(retry=2)
assert type(excinfo.value.__cause__) == socket.gaierror
def test_get_exit_code(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
assert gateway_session.get_exit_code('ls') == 0
assert gateway_session.get_exit_code('dummy commmand') == 127
def connect(self, address, username=None, passwd=None):
if self.verbose:
print('Connecting session...')
self.gateway_session = SSHSession(address, username, password=passwd).open()
if self.verbose:
print('session %s@%s' % ( username, address ))
self.remote_session = self.gateway_session.get_remote_session(address, password=passwd)
return(self.check_connection())
def create_new_cert_on_host(host_session: SSHSession, certificate_file: CertificateFile, ca_cert: str, ca_key: str):
try:
ca_cert_file_path = '/tmp/ca.cert.pem'
ca_key_file_path = '/tmp/ca.key.pem'
host_session.run_cmd(f'echo "{ca_cert}" > {ca_cert_file_path}; echo "{ca_key}" > {ca_key_file_path} ')
host_session.run_cmd(f'openssl x509 -in {ca_cert_file_path} -out {certificate_file.file_path}.new -days 365 \
-signkey {ca_key_file_path} -sha256')
except Exception as e:
print("Could not create new certificate file")
raise e
def ConnectViaJH(self, JHname, user, pswd):
print("connecting the jumphost...")
gateway_session = SSHSession(JHname, user, password=pswd).open()
print("connecting the device...")
nexthop = '2a0b:2900:114a:50b::1:10'
self.remote_session = gateway_session.get_remote_session(
nexthop,
username='******',
private_key_file='D:\code\ssh\cso_id_rsa')
print("try pwd")
feedback = self.remote_session.get_cmd_output("bash -lc 'pwd'")
print(feedback)
def ssh_jumpserver_to_server():
""" create SSH client with jump server"""
from jumpssh import SSHSession
# establish ssh connection between your local machine and the jump server
gateway_session = SSHSession('steppingstone',
'my_user',
password='******').open()
# from jump server, establish connection with a remote server
remote_session = gateway_session.get_remote_session(
'remote.example.com', password='******')
#execute command on end server
remote_session.get_cmd_output('ls -lta')
def change_link(*args, **kwargs):
target_link = kwargs.get('link', 'T33L')
version = kwargs.get('version')
if kwargs.get('server').startswith('192'):
gateway_session = SSHSession('173.36.203.62',
'wbxbuilds',
password='******').open()
print("Connected to sshlogin server.")
remote_session = gateway_session.get_remote_session(
kwargs.get('server'),
kwargs.get('user', 'shuqli'),
password=kwargs.get('pass', 'wbx@Aa$hfcm'))
print(f"Connected to target server {kwargs.get('server')}.")
else:
remote_session = SSHSession(kwargs.get('server'),
kwargs.get('user', 'wbxroot'),
password=kwargs.get('pass',
'wbx@AaR00t')).open()
print("Starting to change link ...")
remote_session.get_cmd_output(
"cd /www/htdocs/client; sudo rm -f {target_link}; sudo ln -sf "
"`ls -lrt|grep WBXclient-{version}|grep ^d|tail -n1|awk '{{"
"print $NF}}'` {target_link}; sudo chown -h nobody.nobody "
"{target_link};".format(version=version, target_link=target_link))
ret = remote_session.get_exit_code(
f"test -e /www/htdocs/client/{target_link}")
print(ret)
if ret == 0:
return True
else:
return False
def test_request_with_body(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
remotehost_ip, remotehost_port = docker_env.get_host_ip_port(
'remotehost', private_port=5000)
rest_client = RestSshClient(gateway_session)
uri = 'http://%s:%s/echo-body' % (tests_util.get_host_ip(),
remotehost_port)
json_file_content = tests_util.create_random_json(5)
# test body specified in input
http_response = rest_client.post(uri, data=json.dumps(json_file_content))
assert http_response.status_code == 200
assert http_response.json() == json_file_content
# test body from local file
# 1. error raised when local file does not exist
with pytest.raises(exception.RestClientError) as exc_info:
rest_client.post(uri, local_file='missing_file')
assert 'Invalid file path given' in str(exc_info.value)
# 2. create file locally
with tempfile.NamedTemporaryFile() as tmp_local_file:
tmp_local_file.write(json.dumps(json_file_content).encode('utf-8'))
tmp_local_file.seek(0)
http_response = rest_client.post(uri, local_file=tmp_local_file.name)
assert http_response.status_code == 200
assert http_response.json() == json_file_content
# check file copied on remote host has been properly removed
assert not gateway_session.exists(path=tmp_local_file.name)
# test body from remote file
remote_file = 'remote_file.json'
# 1. error raised when remote file does not exist
with pytest.raises(exception.RestClientError) as exc_info:
rest_client.post(uri, remote_file=remote_file)
assert 'Invalid remote file path given' in str(exc_info.value)
# 2. create file remotely
gateway_session.file(remote_path=remote_file,
content=json.dumps(json_file_content))
http_response = rest_client.post(uri, remote_file=remote_file)
assert http_response.status_code == 200
assert http_response.json() == json_file_content
def test_put(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
remotehost_ip, remotehost_port = docker_env.get_host_ip_port('remotehost')
remotehost_session = gateway_session.get_remote_session(
host=tests_util.get_host_ip(),
port=remotehost_port,
username='******',
password='******')
# exception is raised when local file does not exist
local_path = 'missing_folder/missing_path'
with pytest.raises(IOError) as excinfo:
remotehost_session.put(local_path=local_path,
remote_path='/tmp/my_file')
assert excinfo.value.errno == errno.ENOENT
assert excinfo.value.strerror == "Local file '%s' does not exist" % local_path
# create random file locally
local_path = os.path.join(os.path.dirname(__file__), 'random_file')
dummy_json = tests_util.create_random_json()
with open(local_path, 'wb') as random_file:
random_file.write(json.dumps(dummy_json).encode('utf-8'))
try:
# copy file on remote session
remote_path = '/tmp/random_file'
assert remotehost_session.exists(remote_path) is False
remotehost_session.close()
remotehost_session.put(local_path=local_path, remote_path=remote_path)
assert remotehost_session.exists(remote_path) is True
# copy file on remote session as user2 with specific file permissions
remote_path = '/tmp/random_file2'
assert remotehost_session.exists(remote_path) is False
remotehost_session.put(local_path=local_path,
remote_path=remote_path,
owner='user2',
permissions='600')
assert remotehost_session.exists(remote_path) is True
assert remotehost_session.get_cmd_output(
"ls -l %s | awk '{print $3}'" % remote_path) == 'user2'
assert remotehost_session.get_cmd_output(
"stat -c '%a %n' " + remote_path + " | awk '{print $1}'") == '600'
finally:
os.remove(local_path)
def test_response_methods(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
remotehost_ip, remotehost_port = docker_env.get_host_ip_port(
'remotehost', private_port=5000)
rest_client = RestSshClient(gateway_session)
endpoint = 'http://%s:%s' % (tests_util.get_host_ip(), remotehost_port)
# check_for_success
with pytest.raises(exception.RestClientError):
rest_client.get(endpoint + '/dummy-uri').check_for_success()
# is_valid_json_body
assert rest_client.get(endpoint + '/json').is_valid_json_body() is True
assert rest_client.get(endpoint + '/').is_valid_json_body() is False
# json
with pytest.raises(exception.RestClientError) as exc_info:
rest_client.get(endpoint + '/').json()
assert 'http response body is not in a valid json format' in str(
exc_info.value)
def test_active_close_session_with_context_manager(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
with SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******') as gateway_session:
assert gateway_session.is_active()
remotehost_ip, remotehost_port = docker_env.get_host_ip_port(
'remotehost')
remotehost_session = gateway_session.get_remote_session(
host=tests_util.get_host_ip(),
port=remotehost_port,
username='******',
password='******')
assert remotehost_session.is_active()
# check that gateway session is well closed
assert not gateway_session.is_active()
# remote session is also automatically closed
assert not remotehost_session.is_active()
# try reopening same session
gateway_session.open()
assert gateway_session.is_active()
assert gateway_session.get_exit_code('ls') == 0
def test_methods(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
remotehost_ip, remotehost_port = docker_env.get_host_ip_port(
'remotehost', private_port=5000)
rest_client = RestSshClient(gateway_session)
uri = 'http://%s:%s/echo-method' % (tests_util.get_host_ip(),
remotehost_port)
# check proper http method is used for each function
header_name = 'Request-Method'
if sys.version_info[0] == 2:
# HTTP header names in the response are all lowercase in Python 2.x.
header_name = 'request-method'
assert rest_client.get(uri).headers[header_name] == 'GET'
assert rest_client.options(uri).headers[header_name] == 'OPTIONS'
assert rest_client.post(uri).headers[header_name] == 'POST'
assert rest_client.put(uri).headers[header_name] == 'PUT'
assert rest_client.patch(uri).headers[header_name] == 'PATCH'
assert rest_client.delete(uri).headers[header_name] == 'DELETE'
assert rest_client.head(uri).headers[header_name] == 'HEAD'
def get_remote_session(tunnel_session: SSHSession, host_address: str, host_user: str,
host_key_path: str = ID_RSA_PATH) -> SSHSession:
try:
return tunnel_session.get_remote_session(host_address, host_user, private_key_file=host_key_path)
except Exception as e:
print("Could not connect to remote host")
raise e
def test_basic_auth(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
rest_client = RestSshClient(gateway_session)
uri = 'http://%s/authentication-required' % REMOTE_HOST_IP_PORT
# wrong auth param format
with pytest.raises(exception.RestClientError) as exc_info:
rest_client.request('GET', uri, auth="invalid_auth_format")
assert 'Invalid auth parameter' in str(exc_info.value)
# authentication in error
http_response = rest_client.request('GET',
uri,
auth=("wrong_user", "wrong_password"))
assert http_response.status_code == 401
assert 'You have to login with proper credentials' in http_response.text
# authentication in success
http_response = rest_client.request('GET', uri, auth=("admin", "secret"))
assert http_response.status_code == 200
assert http_response.text == "Authentication successful"
def test_get(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
remotehost_ip, remotehost_port = docker_env.get_host_ip_port('remotehost')
remotehost_session = gateway_session.get_remote_session(
host=tests_util.get_host_ip(),
port=remotehost_port,
username='******',
password='******')
# create random file on remote host and ensure it is properly there
remote_path = "remote_file"
remotehost_session.file(remote_path=remote_path,
content=json.dumps(
tests_util.create_random_json()))
assert remotehost_session.exists(remote_path)
# download that file in local folder
local_folder = '/tmp/'
remotehost_session.get(remote_path=remote_path, local_path=local_folder)
local_file_path = os.path.join(local_folder, os.path.basename(remote_path))
assert os.path.isfile(local_file_path)
os.remove(local_file_path)
# download that file locally specifying local filename
local_file_path = '/tmp/downloaded_file_' + util.id_generator(size=20)
remotehost_session.get(remote_path=remote_path, local_path=local_file_path)
os.remove(local_file_path)
# get remote file from location not accessible from current user and owned by root
local_folder = '/tmp/'
restricted_remote_path = os.path.join('/etc', remote_path)
remotehost_session.run_cmd([
'sudo mv %s %s' % (remote_path, restricted_remote_path),
'sudo chown root:root %s' % restricted_remote_path,
'sudo chmod 700 %s' % restricted_remote_path,
])
remotehost_session.get(remote_path=restricted_remote_path,
local_path=local_folder,
use_sudo=True)
local_file_path = os.path.join(local_folder, os.path.basename(remote_path))
assert os.path.isfile(local_file_path)
os.remove(local_file_path)
def get_cert_expiration_date(host_session: SSHSession, certificate_file: CertificateFile, ) -> datetime:
try:
date_from_host = host_session.get_cmd_output(
f'openssl x509 -enddate -noout -in "{certificate_file.file_path}" |cut -d= -f 2)')
return convert_pem_date_to_datetime(date_from_host)
except Exception as e:
print("Could not get certificate expiration date")
raise e
def config(self, hostname, username, password, workstation_id):
host_session = SSHSession(hostname, username, password=password).open()
self.host = {
'id': workstation_id,
'hostname': hostname,
'username': username,
'password': password,
'session': host_session
}
def test_init_from_session(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip, port=gateway_port, username='******', password='******')
with RestSshClient(gateway_session) as rest_client:
http_response = rest_client.get('http://' + REMOTE_HOST_IP_PORT)
assert http_response.status_code == 200
assert http_response.text == 'Hello, World!'
def login():
for widget in frame.winfo_children():
widget.destroy()
gatewaySession = SSHSession('users.isi.deterlab.net', entryUsername.get(), password=entryPassword.get()).open()
ltmap = gatewaySession.get_cmd_output('cat /proj/' + entryProject.get() + '/exp/' + entryExperiment.get() + '/tbdata/ltmap')
if not os.path.isfile('img/' + entryExperiment.get() + '.png'):
gatewaySession.get(remote_path='/proj/' + entryProject.get() + '/exp/' + entryExperiment.get() + '/tbdata/' + entryExperiment.get() + '.png', local_path='img/')
experimentLabel = tk.Label(frame, text="Experiment: " + entryExperiment.get() + " Project: " + entryProject.get(), bg="white", pady=30)
experimentLabel.pack()
for line in ltmap.split('\n'):
#check if first character is h
count = 1
if line[0] == 'h':
nodeName=line[line.find(' ')+1:-1]
label = tk.Label(frame, text="Node " + nodeName, bg="gray")
label.pack()
buttonNew = tk.Button(
frame,
text="Login to " + nodeName,
width=15,
padx=10,
pady=5,
#height=5
command=partial(sshToNode, nodeName)
)
buttonNew.pack()
topologyLabel = tk.Label(frame, text="Topology image:", pady=5)
topologyLabel.pack()
image = Image.open("img/" + entryExperiment.get() + ".png")
img = ImageTk.PhotoImage(image)
panel = tk.Label(frame, image=img)
panel.pack()
root.mainloop()
def get_host_certs_list(host_session: SSHSession, certs_path: str, ) -> list:
try:
certs_list = []
host_certs_output_list = (host_session.get_cmd_output(f'find {certs_path} -name "*.cert.pem"')).split('\r\n')
for cert_path in host_certs_output_list:
certs_list.append(CertificateFile(cert_path,host_session.username, host_session.host))
return certs_list
except Exception as e:
print("Could not get hosts certificates list")
raise e
def test_handle_big_json_files(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port()
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
remotehost_session = gateway_session.get_remote_session(
host='remotehost', port=22, username='******', password='******')
# generate big json file on remotehost
remote_path = '/tmp/dummy.json'
dummy_json = tests_util.create_random_json(50000)
remotehost_session.file(remote_path=remote_path,
content=json.dumps(dummy_json))
# read file from remote and check json is valid and identical to source
dummy_json_from_remote = json.loads(
remotehost_session.get_cmd_output('cat %s' % remote_path))
assert dummy_json == dummy_json_from_remote
def check_pfx(path_pfx_file, password, bastion, remote_host):
p12 = crypto.load_pkcs12(open(path_pfx_file, 'rb').read(), password)
private_key = crypto.dump_privatekey(crypto.FILETYPE_PEM,
p12.get_privatekey())
public_certificate = crypto.dump_certificate(crypto.FILETYPE_PEM,
p12.get_certificate())
# try:
# ca_certificate = crypto.dump_certificate(crypto.FILETYPE_PEM, p12.get_ca_certificates())
gateway_session = SSHSession(host=bastion,
port=7022,
password=None,
missing_host_key_policy=None,
username='******')
remote_session = gateway_session.get_remote_session(remote_host,
password=None,
username='******',
port=7022)
remote_session.put('./remote_backup.sh',
'/root/remote_backup.sh',
owner='root',
permissions='0700')
remote_session.run_cmd('/root/remote_backup.sh')
remote_session.file(remote_path='/etc/apache/passl/pa.cert.key',
content=private_key,
owner='root',
permissions='644')
remote_session.file(remote_path='/etc/apache/passl/pa.cert.cert',
content=public_certificate,
owner='root',
permissions='644')
# remote_session.file(remote_path='/etc/apache/passl/pa.cert.intermediate', content=ca_certificate, owner='root',
# permissions='644')
print(remote_session.get_cmd_output('ls -alh'))
print(
remote_session.get_cmd_output(
"ls -alh /etc/apache/passl/backup-$(date +'%F')"))
print(remote_session.get_cmd_output('ls -alh /var/qmail/control/'))
remote_session.close()
gateway_session.close()
def create_list_active_devices():
lista_equipos_activos = []
try:
with open("testbed.yaml","r") as file:
yaml_to_dict = yaml.load(file)
for nombre_equipo in yaml_to_dict["devices"]:
#print(yaml_to_dict["devices"][nombre_equipo])
ip_device = yaml_to_dict["devices"][nombre_equipo]["connections"]["cli"]["ip"]
password_device = yaml_to_dict["devices"][nombre_equipo]["credentials"]["default"]["password"]
username_device = yaml_to_dict["devices"][nombre_equipo]["credentials"]["default"]["username"]
try:
#print("conectandose a "+ip_device)
gateway_session = SSHSession(ip_device,username=username_device,password=password_device).open()
gateway_session.close()
lista_equipos_activos.append(nombre_equipo)
except Exception as e:
print(e)
print(lista_equipos_activos)
return(lista_equipos_activos)
except Exception as e:
print(e)
def test_run_cmd_silent(docker_env, caplog):
caplog.set_level(logging.DEBUG)
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
# run command and check full command is logged
text = 'text with public and private data'
cmd = "echo '%s'" % text
assert gateway_session.run_cmd(cmd).output == text
assert cmd in caplog.text
# check nothing is logged when silent is True
text = 'another text with public and private data'
cmd = "echo '%s'" % text
assert gateway_session.run_cmd(cmd, silent=True).output == text
assert cmd not in caplog.text
# check data is concealed when silent is a list
text = 'a third text with public and private data'
cmd = "echo '%s'" % text
assert gateway_session.run_cmd(cmd, silent=['third',
'private data']).output == text
assert cmd not in caplog.text
assert 'a XXXXXXX text with public and XXXXXXX' in caplog.text
# check data is concealed when silent is a list with regexp
text = 'another text to test regexp'
cmd = "echo '%s'" % text
assert gateway_session.run_cmd(cmd, silent=['\s+']).output == text
assert cmd not in caplog.text
assert 'anotherXXXXXXXtextXXXXXXXtoXXXXXXXtestXXXXXXXregexp' in caplog.text
def test_get_remote_session(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
remotehost_ip, remotehost_port = docker_env.get_host_ip_port('remotehost')
remotehost_session = gateway_session.get_remote_session(
host=tests_util.get_host_ip(),
port=remotehost_port,
username='******',
password='******')
# run basic command on remote host
assert remotehost_session.get_cmd_output(
'hostname').strip() == 'remotehost.example.com'
# request twice the same remote session just return the existing one
assert gateway_session.get_remote_session(
host=tests_util.get_host_ip(),
port=remotehost_port,
username='******',
password='******') == remotehost_session
# request another remote session to another host while an existing one already exists
remotehost2_ip, remotehost2_port = docker_env.get_host_ip_port(
'remotehost2')
remotehost2_session = gateway_session.get_remote_session(
host=tests_util.get_host_ip(),
port=remotehost2_port,
username='******',
password='******')
# check that new session is active
assert remotehost2_session.is_active()
assert remotehost2_session.get_cmd_output(
'hostname').strip() == 'remotehost2.example.com'
# check that previous session from gateway has been automatically closed
assert not remotehost_session.is_active()
def test_input_data(docker_env):
gateway_ip, gateway_port = docker_env.get_host_ip_port('gateway')
gateway_session = SSHSession(host=gateway_ip,
port=gateway_port,
username='******',
password='******').open()
commands = [
'read -p "Requesting user input value?" my_var', 'echo $my_var'
]
# without input given, command will hang until timeout is reached
with pytest.raises(exception.TimeoutError):
gateway_session.run_cmd(commands, timeout=5)
# with input given, command should run correctly and return the value entered
assert gateway_session.get_cmd_output(commands,
input_data={
'Requesting user input value':
'dummy_value'
}).split()[-1] == "dummy_value"
