def test_scpget(self):
conn = SSHConnection('localhost', login=self.user)
srcfile = os.path.join(self.srcdir.name, 'a')
destfile = os.path.join(self.destdir.name, 'a')
text = 'some text'
self._writefile(text, srcfile)
conn.scpget(srcfile, self.destdir.name)
assert self._readfile(destfile) == text
def get_ssh_conn(ip_address, login='******', identity_file=None):
"""Return ssh connection."""
configfile = 'ssh_config'
if not os.path.isfile(configfile):
configfile = None
return SSHConnection(ip_address,
login=login,
configfile=configfile,
identity_file=identity_file)
def scp(self,
source,
dest_path,
mode,
erase_owner=False,
do_checksum=True,
configfile=None):
try:
# Check to see if the source exists, raises ERROR_FILE_NOT_FOUND
self.source_exists(source)
# get the sha256 checksum of the source file
sha256_checksum = checksum(source)
# set up the ssh connection
conn = SSHConnection(self.host,
login=self.user,
port=self.port,
configfile=configfile,
identity_file=self.ssh_key)
# scp the file
if erase_owner:
owner = None
else:
owner = self.user
conn.scp((source, ), target=dest_path, mode=mode, owner=owner)
if do_checksum:
# Now get the sha256 checksum of the remote file
checksum_path = dest_path
command = "if [ -d \"%s\" ]; then echo 'ISDIR'; else echo 'ISFILE'; fi" % dest_path
ret = conn.run(command)
try:
is_dir = ret.stdout.split()[0]
if is_dir.lower() == 'isdir':
checksum_path = "%s/%s" % (dest_path,
os.path.basename(source))
except IndexError:
raise SSHError("SCP failed:\n Command: %s\n stdout: %s\n stderr: %s" % \
(command, ret.stdout, ret.stderr))
command = "/usr/bin/sha256sum %s" % checksum_path
ret = conn.run(command)
try:
# the shell utility return the checksum + the file path, we only want the checksum
remote_checksum = ret.stdout.split()[0]
if sha256_checksum != remote_checksum:
raise SSHError("Checksums do not match.")
except IndexError:
raise SSHError("SCP failed:\n Command: %s\n stdout: %s\n stderr: %s" % \
(command, ret.stdout, ret.stderr))
except SSHError, ssh_e:
raise SCPError("SCP failed: %s" % str(ssh_e))
def publish():
from datetime import datetime as dt
from shutil import rmtree, copytree
from os.path import join
par_dir = CONFIG["output_dir"]
dir_name = "{}_{}".format(par_dir, dt.strftime(dt.now(), "%Y_%m_%d_%H"))
rmtree(dir_name, ignore_errors=True)
copytree(par_dir, dir_name)
if CONFIG["publish_remote"] in ("local", "localhost"):
makedirs(CONFIG["publish_dir"], exist_ok=True)
pubdir = join(CONFIG["publish_dir"], dir_name)
rmtree(pubdir, ignore_errors=True)
copytree(dir_name, pubdir)
if CONFIG["publish_url"] is not None:
print(
"The plots are available at " + CONFIG["publish_url"] + "/" + dir_name
)
elif CONFIG["publish_remote"] is not None:
from openssh_wrapper import SSHConnection
print("connecting to remote server... ", end="")
username, remote = CONFIG["publish_remote"].split("@")
conn = SSHConnection(remote, login=username)
print("done.")
print("preparing destination... ", end="")
conn.run("mkdir -p {}".format(CONFIG["publish_dir"]))
conn.run("rm -rf {}/{}".format(CONFIG["publish_dir"], dir_name))
print("done.")
conn.timeout = 0
print("copying plots... ", end="")
conn.scp((dir_name,), CONFIG["publish_dir"])
print("done.")
if CONFIG["publish_data"] is not None:
print("copying data... ", end="")
conn.scp(
(CONFIG["publish_data"],), join(CONFIG["publish_dir"], dir_name, "data")
)
print("done.")
print("fixing permissions... ", end="")
conn.run("chmod a+r -R {}".format(join(CONFIG["publish_dir"], dir_name)))
print("done.")
if CONFIG["publish_url"] is not None:
print("The plots are available at " + join(CONFIG["publish_url"], dir_name))
def __init__(self,
via_ssh=None,
ssh_username=None,
ssh_hostname=None,
ssh_key=None):
'''Constructor'''
self._via_ssh = via_ssh
self._ssh_username = ssh_username
self._ssh_hostname = ssh_hostname
self._ssh_key = ssh_key
if self._via_ssh is True:
if self._ssh_hostname is None:
raise Exception("No hostname defined")
self._ssh_connection = SSHConnection(server=self._ssh_hostname,
identity_file=self._ssh_key,
login=self._ssh_username)
def run(host, cmd):
print("Sending command " + (cmd) + "to host " + (host))
conn = SSHConnection(host)
ret = conn.run(cmd)
print(ret)
self.colors[key] = get_random_hex()
value.plot(kind='line',
color=self.colors[key],
ax=ax,
label=self.name + ' ' + key)
if __name__ == "__main__":
random.seed(42)
with open('params.json', 'r') as f:
params = json.load(f)
print('connect to host')
conn = SSHConnection(params['host'],
login=params['ssh_user'],
port=params['ssh_port'])
gpustats = {}
print('start monitoring')
if params['plot_graph']:
plt.ion()
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_xlim(0, params['steps'])
while True:
if params['plot_graph']:
ax.clear()
ax.set_xlim(0, params['steps'])
# In[3]:
response_dict = json.loads(r.text)
for i in response_dict:
print("key: ", i, "val: ", response_dict[i][0])
# print(r.__dict__)
# In[17]:
print(response_dict)
# In[4]:
from openssh_wrapper import SSHConnection
conn = SSHConnection('172.20.15.87', login='******')
# In[6]:
# https://mrcissp.com/2019/12/17/python-package-paramiko/
import paramiko
import socket
vhost = "172.22.250.48"
vport = 22
vusername = "******"
vpassword = "******"
# Lets create an Object SSH
SSH = paramiko.SSHClient()
# Lets override the default policy behavior
def connect(self):
"""
To establish the connection to resource.
"""
try:
p_module = sys._getframe().f_back.f_code.co_filename
p_function = sys._getframe().f_back.f_code.co_name
t = repr(traceback.format_stack())
#for line in t:
# print line
#logger.debug("Running connect function\n - called from "+p_module+"\n - by function "+p_function)
logger.debug(
"\n\nRunning connect function from %s\n - called from %s\n - by function %s\nTraceback :\n%s\n"
% (self.parent_module, p_module, p_function, t))
#logger.debug("\np_module = %s\np_function = %s\n" % (p_module, p_function))
if not self.configfile:
logger.debug("Variable 'self.configfile' is not defined")
logger.error(
"OpenSHH configuration file's path is not defined")
if not exists(self.configfile):
self.createConfFiles()
logger.debug("The socket " + join(
Communicator.socket_dir, '%s-%s@%s:%s' %
(self.parent_module, self.username, self.frontend,
self.port)) + " existance is " + str(
exists(
join(
Communicator.socket_dir, '%s-%s@%s:%s' %
(self.parent_module, self.username, self.frontend,
self.port)))))
if not exists(
join(
Communicator.socket_dir, '%s-%s@%s:%s' %
(self.parent_module, self.username, self.frontend,
self.port))):
logger.debug(
"No master conncection exists for %s so a new one will be created"
% self.parent_module)
def first_ssh():
try:
logger.debug(
"Running first_ssh function\n - Creating first connection for %s"
% self.parent_module)
#this is here because the threads are created at the same time, so the moment one creates the conection, the rest are going to cause an UnboundLocalError exception
#(which probably shouldn't be ocurring since ControlMaster is set to auto - only if they execute this at the same time)
if not exists(
join(
Communicator.socket_dir, '%s-%s@%s:%s' %
(self.parent_module, self.username,
self.frontend, self.port))):
command = 'ssh -F %s -i %s -p %s -T %s@%s' % (
self.configfile, self.private_key,
str(self.port), self.username, self.frontend)
pipe = subprocess.Popen(command.split(),
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
out, err = pipe.communicate()
if err:
if "too long for Unix domain socket" in str(
err) or "ControlPath too long" in str(err):
logger.debug(
"Socket path was too long for Unix domain socket.\n Creating sockets in ~/.ssh/dmr4g.\n Exception captured in first_ssh."
)
self._change_socket_dir()
logger.debug(
"Calling first_ssh once again, but with a new socket_dir"
)
first_ssh()
elif "disabling multiplexing" in str(err):
logger.debug(
"connect function: The multiplexing of connections isn't working. Eliminating "
+ self.parent_module + "'s socket file.")
self._delete_socket()
first_ssh()
elif "bind: No such file or directory" in str(
err) or "cannot bind to path" in str(err):
logger.debug(
"The connection through the socket %s-%s@%s:%s wasn't established since the socket directory %s hasn't been created yet."
% (self.parent_module, self.username,
self.frontend, self.port,
Communicator.socket_dir))
self.createConfFiles()
first_ssh()
else:
logger.debug(
"Unexpected error occured while running first_ssh:\n"
+ str(err))
logger.warning(str(err))
except UnboundLocalError as err:
logger.warning(
"Local variable referenced before assignment")
logger.debug(str(err))
t = threading.Thread(target=first_ssh, args=())
t.daemon = True
logger.debug("Starting thread with first_ssh")
t.start()
time.sleep(
5
) #so that there's time to make the first connection in case there was an error
if self.conn == None:
logger.debug("No conn exists (conn == " + str(self.conn) +
") for " + self.parent_module +
" so a new one will be created.")
self.conn = SSHConnection(self.frontend,
login=self.username,
port=str(self.port),
configfile=self.configfile,
identity_file=self.private_key,
ssh_agent_socket=self.agent_socket,
timeout=SSH_CONNECT_TIMEOUT)
logger.debug("Ending connect function from %s" %
self.parent_module)
except Exception as excep:
if "too long for Unix domain socket" in str(excep):
logger.debug(
"Socket path was too long for Unix domain socket.\n Creating sockets in ~/.ssh/dmr4g.\n Exception captured in connect's except."
)
self._change_socket_dir()
self.connect()
else:
logger.error(str(excep))
raise
