SSH Tunneling with Robot Framework-SSH LIbrary - robotframework

Question

I am using Robot Framework SSH Library for my automation.
I need to establish SSH Tunnel to a remote machine using Robot Framework and then execute set of tests on the remote machine.
Looks like RF SSH Library do not have support for this.
Can someone point me to any other options available?
Thank you!

Answer 1

You could use Robot Framework to open SSH connection, copy test files, run them and copy results back.
You will need two files, first one is ssh.txt
*** Settings ***
Library SSHLibrary
Suite Setup Open Connection And Log In
Suite Teardown Copy And Delete Files And Close Connections
*** Variables ***
${HOST} your.server.here
${USERNAME} username
${PASSWORD} password
*** Testcases ***
Run Tests on remote server
Put File real-test.txt
Run Test In Server real-test.txt
Sleep 1s
*** Keywords ***
Open Connection And Log In
Open Connection ${HOST}
Login ${USERNAME} ${PASSWORD}
Copy And Delete Files And Close Connections
Copy Results From Server
Clean Up Server real-text.txt
Close All Connections
Run Test In Server
[Arguments] ${filename}
${rc}= Execute Command pybot ${filename} return_stdout=False return_rc=True
Should Be Equal As Numbers ${rc} 0
Copy Results From Server
GetFile log.html
GetFile output.xml
GetFile report.html
Clean Up Server
[Arguments] ${filename}
Write rm log.html
Write rm output.xml
Write rm report.html
Write rm ${filename}
the 2nd file is where real tests are, real-test.txt:
*** Settings ***
Library OperatingSystem
*** Testcases ***
Test 1
FileShouldExist real-test.txt
run this by specifying output files to avoid filename collisions when log files are copied back from server:
pybot -o conn.xml -r conn.html -l connlog.html ssh.txt

Answer 2

I recently did something like this but created the functionality in Python which I then imported to Robot as a keyword.
The jist of it was:
in SSHTunnel.py:
from sshtunnel import SSHTunnelForwarder
(other imports)
class SSHTunnel:
def create_ssh_tunnel(self):
ssh_server = SSHTunnelForwarder(
(host, int(port)),
ssh_username=username,
ssh_password=pass,
remote_bind_address=(remote_bind_host, int(remote_bind_port))
)
ssh_server.start()
def stop_ssh_tunnel(self):
ssh_server.stop()
Now you add the SSHTunnel.py file to the Robot Library and call the keyword Create SSH Tunnel in the beginning of the testcase (can also be in Test Setup or Suite Setup) and Stop SSH Tunnel at the end.
Hope that helps.

Answer 3

Library SSHLibrary
Open Connection host_server
Login With Public Key test /test.pem test12345
Create Local SSH Tunnel 9191 remote_host remote_port bind_address=127.0.0.1
#Once the connection is made you can directly access the resources in remote_host, for eg : i am trying to connect mysql db in remote host
Connect To Database Using Custom Params pymysql database='testDb', user='testuser', password='test123', host='127.0.0.1', port=9191

Answer 4

You can achieve this with the help of 'local port forwarding' feature.
Ref: https://help.ubuntu.com/community/SSH/OpenSSH/PortForwarding.
Use this command on the test server(where the robot is running) in an instance:
ssh -4 -L <listening_port/forwarding_port>:<destination_ip>:destination_port> username#jump_box.com
eg)
ssh -4 -L 50025:10.122.56.45:23 anishg#jumpbox.teski.com
Use the following command in another instance to work in the destination server:
telnet localhost <listening port>
eg)
telnet localhost 50025
Here you can execute the commands as like you are working on the destination server, as the session is opened.
In Robot, this can be achieved by this way also:
The Step (1) - Port forwarding is done in a shell script and this shell script is called in your robot framework.
Do Telnet/other in localhost with port specified
sample.sh:
ssh -4 -L 50025:10.122.56.45:23 anishg#jumpbox.teski.com
Robot Code:
*** Test Cases ***
Port Forwarding
Start Process ./sample.sh shell=True #Port is opened
Log To Console SHELL IS Executing
Telnet.Open Connection localhost port=50025 #Normal op as in destn server
Note: I used jump_box as I dont have access to destination server from my test instance.