def pushBareConfig(veos_host, veos_ip, veos_config):
"""
Pushes a bare config to the EOS device.
"""
# Write config to tmp file
deviceConfig = "/tmp/" + veos_host + ".cfg"
with open(deviceConfig, "a") as tmpConfig:
tmpConfig.write(veos_config)
DEVREBOOT = False
veos_ssh = paramiko.SSHClient()
veos_ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
veos_ssh.connect(hostname=veos_ip,
username="******",
password="",
port="50001")
scp = SCPClient(veos_ssh.get_transport())
scp.put(deviceConfig, remote_path="/mnt/flash/startup-config")
scp.close()
veos_ssh.exec_command('FastCli -c "{0}"'.format(cpStartRun))
veos_ssh.exec_command('FastCli -c "{0}"'.format(cpRunStart))
stdin, stdout, stderr = veos_ssh.exec_command(
'FastCli -c "{0}"'.format(ztp_cmds))
ztp_out = stdout.readlines()
if 'Active' in ztp_out[0]:
DEVREBOOT = True
pS(
"INFO",
"Rebooting {0}...This will take a couple minutes to come back up".
format(veos_host))
#veos_ssh.exec_command("/sbin/reboot -f > /dev/null 2>&1 &")
veos_ssh.exec_command('FastCli -c "{0}"'.format(ztp_cancel))
veos_ssh.close()
return (DEVREBOOT)
def remote_exec_file(script, host, port, user, password, test_name, result_query, test_detail, log_file):
start = time.asctime()
cl = paramiko.SSHClient()
cl.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
cc = cl.connect(host, port=port, username=user, password=password)
except paramiko.ssh_exception.AuthenticationException:
print "Auth Error"
except paramiko.ssh_exception.SSHException:
print "Protocol Error"
except paramiko.transport:
print "General Error"
except socket.error:
print "Socket Error"
scp = SCPClient(cl.get_transport())
scp.put(script,script)
cl.exec_command("chmod +x ./{0}".format(script))
stdin, stdout, stderr = cl.exec_command("./{0}".format(script))
a = stdout.readlines()
cmd = str(a)
if result_query not in cmd:
print "Failed {0}\n".format(test_name)
print "Test detail: \n" + test_detail + "\n"
print "Result: \n" + cmd + "\n"
stop = time.asctime()
test_logger(log_file, test_name, start, stop, "Fail")
if result_query in cmd:
print "Pass {0}".format(test_name)
print "Test detail: \n" + test_detail + "\n"
print "Result: \n" + cmd + "\n"
stop = time.asctime()
test_logger(log_file, test_name, start, stop, "Pass")
def sendFiles():
# Open the file with the password located in it and prepare for use in SSH and SCP
passwordFile = open("password.txt", "r")
passwordSave = passwordFile.read()
password = passwordSave.replace("\n", "")
# initialize the SSH client and connect to the other RPi
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.connect(hostname='192.168.0.26', username="******", password=password)
# initialize the SCP client to prepare to send files
scp = SCPClient(ssh.get_transport())
# prepare all the images to send from one Pi to the Other
scp.put('images',
recursive=True,
remote_path='/home/pi/Documents/flaskServer/static/')
# Once done close the SCP client
scp.close()
# Remove all images from one raspberry pi and recreate the images folder
sp.call(["sudo", "rm", "-r", "images"])
sp.call(["mkdir", "images"])
# notify in console that the job has been completed.
print("SSH Complete")
def job():
#usage = get_storage_usage().replace('%', '')
#Get current healthbot timestamp
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
print ("Healthbot timestamp {}".format(st))
usage = 63
print ("healthbot storage {}".format(usage))
print ("healthbot pwd {}".format(os.getcwd()))
if int(usage) >= 90:
ssh = createSSHClient(details['dest']['server'], details['dest']['port'], details['dest']['user'], details['dest']['password'])
scp = SCPClient(ssh.get_transport())
scp.put(details['source_path'], details['dest']['path'])
ssh.close()
hb_status = subprocess.run(['healthbot', 'status'], stdout=subprocess.PIPE).stdout.decode('utf-8')
print ("hb_status {}".format(hb_status))
send_email(details['sender'], details['receiver'], details['sender_password'], usage, hb_status)
print ("Mail sent")
if datetime.datetime.now().hour == 00 and datetime.datetime.now().minute == 00:
print ("Healthbot storage is good and taking regular backup at 00:00")
ssh = createSSHClient(details['dest']['server'], details['dest']['port'], details['dest']['user'], details['dest']['password'])
scp = SCPClient(ssh.get_transport())
scp.put(details['source_path'], details['dest']['path'])
ssh.close()
res = backup_influx()
def transfer_file(self, pull=False):
if pull is False:
if not self.local_file_exists():
raise FileTransferError(
'Could not transfer file. Local file doesn\'t exist.')
if not self.enough_remote_space():
raise FileTransferError(
'Could not transfer file. Not enough space on device.')
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(
hostname=self.device.host,
username=self.device.username,
password=self.device.password,
port=self.port,
allow_agent=False,
look_for_keys=False)
scp = SCPClient(ssh.get_transport())
try:
if pull:
scp.get(self.remote, self.local)
else:
scp.put(self.local, self.remote)
except Exception as e:
print(e)
raise FileTransferError
finally:
scp.close()
return True
class Sync:
client = None
scp = None
writting = False
sync_queue = []
channel = None
def __init__(self, channel):
Logger.Logger.debug('Init sync mon created [{}]'.format(channel.host))
logging.getLogger('paramiko').setLevel(logging.DEBUG)
host = str(channel.host)
self.client = SSHClient()
self.client.load_system_host_keys()
try:
self.client.connect(hostname=host,
username=channel.user,
key_filename=channel.key)
self.scp = SCPClient(self.client.get_transport())
except Exception as e:
Logger.Logger.debug('Exception in scp syncer {}'.format(e))
Logger.Logger.debug('Mon created')
def sync(self, filename):
Logger.Logger.debug('Call sync for file {}'.format(filename))
if self.writting:
self.sync_queue.append(filename)
self.sync_queue = list(set(self.sync_queue))
return
self.writting = True
self.sync_queue.append(filename)
self.sync_queue = list(set(self.sync_queue))
self.start()
return True
@throttle(3)
def start(self):
self.writting = True
while len(self.sync_queue) > 0:
filename = self.sync_queue.pop(0)
Logger.Logger.debug('Sync {} to server {}'.format(
filename, self.channel.host))
try:
self.scp.put(
self.channel.watch_path + filename,
filename.replace(self.channel.watch_path,
self.channel.server_path))
except Exception as e:
Logger.Logger.debug('EXCEPTION: {}'.format(e))
if len(self.sync_queue) == 1:
self.sync_queue = []
self.writting = False
Logger.Logger.debug('Sync done {}')
def scp_compressed():
"""A function that uses the paramiko library to ssh into the required server
and sends the file via Secure Copy Protocol (SCP) to /root/ftpinbox/
"""
try:
global filename, success
filename = request.form['filename']
print("Logging into SCP with compression")
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(server,
port=22,
username='******',
password='******',
compress=True)
ssh.load_system_host_keys()
print("Login to " + server + " Successful")
print("Starting Transfer")
scp_put = SCPClient(ssh.get_transport())
scp_put.put(filename, remote_path='/root/ftpinbox/' + filename)
print("Transfer complete")
success = True
except:
print("Unable to complete using SCP-C connection")
def copy(self):
"""Push it !"""
from scp import SCPClient
ssh_connection = self.get_connection(self.destination.hostname,
self.destination.port,
self.destination.username)
try:
scp = SCPClient(ssh_connection.get_transport())
except Exception as e:
LOGGER.error("Failed to initiate SCPClient: " + str(e))
ssh_connection.close()
raise
try:
scp.put(self.origin, self.destination.path)
except OSError as osex:
if osex.errno == 2:
LOGGER.error(
"No such file or directory. File not transfered: %s. Original error message: %s",
self.origin, str(osex))
else:
LOGGER.error("OSError in scp.put: " + str(osex))
raise
except Exception as e:
LOGGER.error("Something went wrong with scp: " + str(e))
LOGGER.error("Exception name {}".format(type(e).__name__))
LOGGER.error("Exception args {}".format(e.args))
raise
finally:
scp.close()
class Sender(object):
def __init__(self,server,username,password,dest_path,from_path):
self.dest_path = dest_path
self.from_path = from_path
self.recorder = Recorder.Recorder()
self.ssh = SSHClient()
self.ssh.load_system_host_keys()
self.ssh.connect(server,username=username,password=password)
self.sftp = self.ssh.open_sftp()
self.scp = SCPClient(self.ssh.get_transport())
def send(self,file_path):
if op.exists(file_path):
file_modify_time = time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(os.stat(file_path).st_mtime))
if not self.recorder.isSynced(file_path,file_modify_time):
new_file_path = os.path.join(self.dest_path+'/',file_path.split(self.from_path+os.sep)[1])
new_file_path = new_file_path.replace('\\','/')
new_file_dir,new_file = op.split(new_file_path)
if not rexists(self.sftp,new_file_dir):
rmkdir(self.sftp,new_file_dir)
print 'uploading %s .....' % (file_path)
self.scp.put(file_path,new_file_path)
self.recorder.record(file_path,file_modify_time)
else:
pass
def Update(sip, S_md5, App, path):
ssh = paramiko.SSHClient()
key = paramiko.RSAKey.from_private_key_file(key_file)
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for ip in sip:
ip = ip.strip()
Redis.lpush(Key, '-' * 60)
Redis.lpush(Key, 'publish ' + path + ' to ' + ip + '\n')
try:
ssh.connect(ip, 22, username, pkey=key, timeout=15)
cmd = "mkdir -p {0}".format(web_path)
ssh.exec_command(cmd)
scp = SCPClient(ssh.get_transport())
scp.put('%s%s.zip' % (web_path, App), web_path)
cmd = '/usr/bin/md5sum %s/%s.zip' % (web_path, App)
stdin, stdout, stderr = ssh.exec_command(cmd)
R_md5 = stdout.read().split()[0]
if R_md5 == S_md5:
Redis.lpush(Key, '%s md5 verify --->pass!' % App)
Redis.lpush(Key, 'unzip start ......')
cmds = ['cd %s && /usr/bin/unzip -qo %s.zip && /bin/rm -f %s.zip' % (web_path, App, App),
'[ -e %s ] && echo ok' % tag_path]
for cmd in cmds:
stdin, stdout, stderr = ssh.exec_command(cmd)
result_zip = stdout.read().strip()
if result_zip == 'ok':
Redis.lpush(Key, '%s --->unzip success!' % App)
Redis.lpush(Key, 'backup start ......')
cmds = ('/bin/mkdir -p %s' % bak_path,
'[ -e %s/%s ] && /bin/rm -rf %s/%s' % (bak_path, App, bak_path, App),
'[ -e %s%s ] && /bin/mv %s%s %s/%s' % (web_path, App, web_path, App, bak_path, App))
for cmd in cmds:
stdin, stdout, stderr = ssh.exec_command(cmd)
result_backup = stderr.read()
if result_backup:
Redis.lpush(Key, result_backup)
Redis.lpush(Key, '%s --->backup fail !' % App)
else:
Redis.lpush(Key, '%s --->backup success!' % App)
Redis.lpush(Key, 'publish start ......')
cmd = '/bin/mv %s %s%s' % (tag_path, web_path, App)
stdin, stdout, stderr = ssh.exec_command(cmd)
result_rsync = stderr.read()
if result_rsync:
Redis.lpush(Key, result_rsync)
Redis.lpush(Key, '%s --->publish fail !' % App)
else:
Redis.lpush(Key, '%s --->publish success!' % App)
ssh.close()
Redis.lpush(Key, '-' * 60)
else:
Redis.lpush(Key, '%s --->unzip fail !' % App)
else:
Redis.lpush(Key, 'S_MD5:%r' % S_md5)
Redis.lpush(Key, 'R_MD5:%r' % R_md5)
Redis.lpush(Key, ' verify %s on %s fail !!!' % (App, ip))
except Exception as e:
Redis.lpush(Key, 'Update:{0}'.format(e))
ssh.close()
sys.exit()
def create(tpr, cluster, shell, job_name="workdir", duration="24:00:00", nodes=1, processes=16, script=None, partition=None, ntasks_per_node=16):
"""
- Argument validation
- Copy from cwd to locker (on local machine)
- Copy from local locker to remote locker
- Submit
"""
if not os.path.exists(configuration.config.lockers): os.mkdir(configuration.config.lockers)
# Create workdir, copy files over there
assert not os.path.exists("workdir")
id0 = str(uuid.uuid4())
workdir = "%s/%s" % (configuration.config.lockers, id0)
local_dir = os.getcwd()
ignore = shutil.ignore_patterns("\#*", "workdir*", "analysis*", "test*", "trash*")
print("local copy:", "src=", local_dir, "dst=", workdir)
shutil.copytree(local_dir, workdir, symlinks=False, ignore=ignore)
os.symlink(workdir, "workdir")
# Setup SSH client to copy files over via scp
dst = "%s/.lockers/" % (cluster.path)
print("remote copy:", "src=", workdir, "dst=", cluster.name,":",)
scp = SCPClient(shell.get_transport(), socket_timeout = 600)
try:
scp.put(workdir, dst, recursive=True)
except SCPException, e:
print "SCPException",e
shutil.rmtree(workdir)
os.remove("workdir")
return None
def copySCPfiles(hashed_file_name):
try:
ScreenOutput("Copying Test", "To Server")
time.sleep(3)
hashed_file_local_path1 = log_files + "/" + hashed_file_name + "_Upload"
hashed_file_local_path2 = log_files + "/" + hashed_file_name + "_Download"
hashed_file_remote_path1 = hashed_file_name + "_Upload"
hashed_file_remote_path2 = hashed_file_name + "_Download"
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(scphost, port=int(scpport), username=scpuser, password=scppass)
scp = SCPClient(ssh.get_transport())
ScreenOutput("Copying Test", "Upload")
time.sleep(1)
scp.put(hashed_file_local_path1, hashed_file_remote_path1)
ScreenOutput("Copying Test", "Download")
time.sleep(1)
scp.put(hashed_file_local_path2, hashed_file_remote_path2)
scp.close()
ScreenOutput('Test Copied', 'To Server')
time.sleep(1)
except Exception, e:
ScreenOutput("Copy To", "Server Failed")
time.sleep(3)
ScreenOutput("Restarting", "Speed Test")
time.sleep(2)
executeTesting()
def main(file, key, encrypt, host, username, password):
"""
The main function. Takes multiple parameters which are prompted if not given on the command line.
:param file: The paht of the file to encrypt or decrypt and send.
:param key: The key to encrypt or decrypt.
:param encrypt: Tells if the operation is an encryption or a decryption.
:param host: The host where to send the file.
:param username: Username on the host.
:param password: Password if needed. If not needed '-' should be used to tell that there is no password needed.
"""
ssh = SSHClient()
ssh.load_system_host_keys()
if password != "-":
ssh.connect(host, username=username, password=password)
else:
ssh.connect(host, username=username)
scp = SCPClient(ssh.get_transport())
if encrypt:
print("Encrypting... ", end="")
to_send = encrypt_file(file, key)
print("Done.")
print("Sending to {}...".format(host), end="")
scp.put(to_send)
print("Done.")
else:
print(decrypt_file(file, key))
def transfer_file(module, dest):
file_size = os.path.getsize(module.params['local_file'])
if not enough_space(module):
module.fail_json(
msg='Could not transfer file. Not enough space on device.')
hostname = module.params['host']
username = module.params['username']
password = module.params['password']
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname=hostname, username=username, password=password)
full_remote_path = '{}{}'.format(module.params['file_system'], dest)
scp = SCPClient(ssh.get_transport())
try:
scp.put(module.params['local_file'], full_remote_path)
except:
time.sleep(10)
temp_size = verify_remote_file_exists(
module, dest, file_system=module.params['file_system'])
if int(temp_size) == int(file_size):
pass
else:
module.fail_json(msg='Could not transfer file. There was an error '
'during transfer. Please make sure remote '
'permissions are set.',
temp_size=temp_size,
file_size=file_size)
scp.close()
ssh.close()
return True
def send_file(local_file, remote_path, ip, username, password, logger=None):
# Отсылает файл local_file в remote_path удаленной машины по scp
if remote_path[len(remote_path) - 1] != '/': remote_path += '/'
ssh = SSHClient()
ssh.set_missing_host_key_policy(AutoAddPolicy())
ssh.load_system_host_keys()
if logger is not None: logger.info("SCP SEND: connecting to %s" % (ip))
try:
ssh.connect(ip, username=username, password=password)
except:
if logger is not None: logger.info("SCP SEND: failed to connect to %s" % (ip))
return False
else:
if logger is not None: logger.info("SCP SEND: connected to %s" % (ip))
try:
if logger is not None: logger.info("SCP SEND: sending file %s" % (local_file))
scp = SCPClient(ssh.get_transport())
scp.put(local_file, remote_path)
except:
if logger is not None: logger.error("SCP SEND: error: failed to send file %s" % (local_file))
ssh.close()
return False
else:
if logger is not None: logger.info("SCP SEND: file sent to %s@%s:%s " % (username, ip, remote_path))
ssh.close()
return True
class Target:
def __init__(self, hostname, uname, pword, num, port=22):
self.hostname = hostname
self.uname = uname
self.pword = pword
self.target_num = num
self.port = port
self.ssh = None
self.is_open = False
self.scp = None
def conn(self):
# print("Opening SSH connection to target...")
self.ssh = paramiko.SSHClient() # use ssh.exec_command("") to perform an action.
self.ssh.load_system_host_keys()
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.ssh.connect(self.hostname, port=self.port, username=self.uname, password=self.pword)
self.scp = SCPClient(self.ssh.get_transport()) # don't call this, but use the above function instead.
self.is_open = True
# TODO: fix rm -rf bug
def scpFiles(self, filename, a, recur=True): # call this with a filename and false if it is a single file
print "files: "
print (a)
self.ssh.exec_command("rm ", a)
self.scp.put(a, recursive=recur)
def close(self):
self.is_open = False
self.ssh.close()
def scp2(Key, arg, wline, swline):
try:
ssh = paramiko.SSHClient()
key = paramiko.RSAKey.from_private_key_file(key_file)
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for ip in ips:
ip = ip.strip()
Redis.lpush(Key, 'sync ' + line + ' to ' + ip + '\n')
ssh.connect(ip, 22, username, pkey=key, timeout=30)
scp = SCPClient(ssh.get_transport())
cmd = 'mkdir -p ' + wline
stdin, stdout, stderr = ssh.exec_command(cmd)
if os.path.isdir(swline):
scp.put(swline, wline, recursive=True)
else:
scp.put(swline, swline)
ssh.close()
if arg == 'publish':
if os.path.isdir(swline):
dirs = create_paths(swline)
for path in dirs:
Verify(Key, ip, path)
else:
Verify(Key, ip, swline)
except Exception as e:
Redis.lpush(Key, 'scp2:{0} fail'.format(e))
ssh.close()
def test_vdbench_run(self, test_vars): # noqa: F811
log = logging.getLogger("test_vdbench_run")
node_ip = test_vars["deploy_vd_outputs"]["node_0_ip_address"]["value"]
with SSHTunnelForwarder(
test_vars["public_ip"],
ssh_username=test_vars["controller_user"],
ssh_pkey=test_vars["ssh_priv_key"],
remote_bind_address=(node_ip, 22),
) as ssh_tunnel:
sleep(1)
try:
ssh_client = create_ssh_client(
test_vars["controller_user"],
"127.0.0.1",
ssh_tunnel.local_bind_port,
key_filename=test_vars["ssh_priv_key"])
scp_client = SCPClient(ssh_client.get_transport())
try:
scp_client.put(test_vars["ssh_priv_key"], r"~/.ssh/id_rsa")
finally:
scp_client.close()
commands = """
~/copy_idrsa.sh
cd
./run_vdbench.sh inmem32node3.conf uniquestring1
""".split("\n")
run_ssh_commands(ssh_client, commands)
finally:
ssh_client.close()
def scp(self, local_path, remote_path, get=False, timeout=10):
"""Copy files from local_path to remote_path or vice versa.
connect() method has to be called first!
:param local_path: Path to local file that should be uploaded; or
path where to save remote file.
:param remote_path: Remote path where to place uploaded file; or
path to remote file which should be downloaded.
:param get: scp operation to perform. Default is put.
:param timeout: Timeout value in seconds.
:type local_path: str
:type remote_path: str
:type get: bool
:type timeout: int
"""
if not get:
logger.trace('SCP {0} to {1}:{2}'.format(
local_path,
self._ssh.get_transport().getpeername(), remote_path))
else:
logger.trace('SCP {0}:{1} to {2}'.format(
self._ssh.get_transport().getpeername(), remote_path,
local_path))
# SCPCLient takes a paramiko transport as its only argument
scp = SCPClient(self._ssh.get_transport(), socket_timeout=timeout)
start = time()
if not get:
scp.put(local_path, remote_path)
else:
scp.get(remote_path, local_path)
scp.close()
end = time()
logger.trace('SCP took {0} seconds'.format(end - start))
def scp2(Key,arg,wline,swline):
try:
ssh = paramiko.SSHClient()
key = paramiko.RSAKey.from_private_key_file(key_file)
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for ip in ips:
ip = ip.strip()
Redis.lpush(Key,'sync '+line+' to '+ip+'\n')
ssh.connect(ip,22,username,pkey=key,timeout=30)
scp = SCPClient(ssh.get_transport())
cmd ='mkdir -p '+wline
stdin, stdout, stderr = ssh.exec_command(cmd)
if os.path.isdir(swline):
scp.put(swline,wline,recursive=True)
else:
scp.put(swline,swline)
ssh.close()
if arg == 'publish':
if os.path.isdir(swline):
dirs = create_paths(swline)
for path in dirs:
Verify(Key,ip,path)
else:
Verify(Key,ip,swline)
except Exception as e:
Redis.lpush(Key,'scp2:{0}'.format(e))
ssh.close()
def retry_upload_files(ssh_session, file_name=FAILED_UPLOAD_FILE):
'''
if files are not uploaded sucessfull, they will be reupload here.
The list of failed uploaded files are in FAILED_UPLOAD_FILE
:param scp: scp object from paramiko transport
:param file_name: the file contains the list of all failed uploading files
:return:
'''
# if that file does not exist. Nice! get out immediately
if not Path(FAILED_UPLOAD_FILE).is_file():
return
sshSession = getSSHSession(remote)
scp = SCPClient(sshSession.get_transport(), progress=__progress)
all_files = open(file_name)
# remove the \n line
all_files = [line for line in all_files if len(line) > 1]
logger.info("RE-Uploading file to server %s ", str(all_files))
for line in all_files:
src_dest_pair = line.split('@@')
dest_folder = src_dest_pair[-1].strip()
source_file = src_dest_pair[0].strip()
try:
scp.put(source_file, remote_path=dest_folder)
logger.debug('uploading %s to %s', source_file, dest_folder)
except SCPException as e:
logger.debug('Cannot upload %s to %s', source_file, dest_folder)
logger.debug(str(e))
scp.close()
def pushtestfiles(target):
ssh = paramiko.SSHClient()
# ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# ssh.connect(remoteip, username="******", password = "******")
privatekeyfile = os.path.expanduser('~/.ssh/id_rsa')
mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile)
ssh.connect(hostname="192.168.1.225", username="******", pkey=mykey)
scp = SCPClient(ssh.get_transport())
scp.put('diskspeed2.py')
scp.close()
# host="raspberrypi.local"
# user="******"
client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
privatekeyfile = os.path.expanduser('~/.ssh/id_rsa')
# client.load_system_host_keys()
mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile)
client.connect(hostname="192.168.1.225", username="******", pkey=mykey)
# client.connect(host, username=user)
stdin, stdout, stderr = client.exec_command('python diskspeed2.py')
pwd = stdout.read().splitlines()
for elem in pwd:
print(elem)
scp.close()
return None
class FileManager:
def __init__(self, host="10.4.20.69", port=22, user_name="", passwd=""):
self.host = host
self.port = port
self.user = user_name
self.passwd = passwd
self.ssh_client = paramiko.SSHClient()
self.ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy)
self.ssh_client.connect(host, port, user_name, passwd)
self.scpclient = SCPClient(self.ssh_client.get_transport(),
socket_timeout=15.0)
def upload_file(self, local_path, remote_path):
try:
self.scpclient.put(local_path, remote_path)
except FileNotFoundError as e:
logger.error("Can't find local file at: " + local_path)
logger.error(e)
else:
logger.info("Successful upload 1 file! ")
def get_file(self, remote_path, local_path):
try:
self.scpclient.get(remote_path, local_path)
except FileNotFoundError as e:
logger.error("Can't find remote file at: " + remote_path)
logger.error(e)
else:
logger.info("Successful download 1 file! ")
def close(self):
self.ssh_client.close()
def copy_python(ssh_client, ip, date):
if update_shell_flag == 1:
rm_cmd = 'rm -rf %s/%s' % (scp_dir, old_shell_name)
stdin, stdout, stderr = ssh_client.exec_command(rm_cmd)
out_info = stdout.readlines()
scp_client = SCPClient(ssh_client.get_transport(), socket_timeout=15)
re_try = 5
while re_try > 0:
stdin, stdout, stderr = ssh_client.exec_command('ls %s' % (scp_dir))
res = stdout.readlines()
if 'pirate_arm.py\n' in res:
stdin, stdout, stderr = ssh_client.exec_command(
'cat %s/%s |grep "%s"' % (scp_dir, shell_name, shell_date))
res = stdout.readlines()
if len(res) == 1 and res[0].find('No such file or directory') == (
-1):
scp_client.close()
return True
else:
scp_client.put(shell_name, scp_dir)
print(ip + ' Instead Python done')
time.sleep(1)
else:
scp_client.put(shell_name, scp_dir)
print(ip + ' New Dev,Copy Python done')
time.sleep(1)
scp_client.close()
return False
def transfer_file(self, pull=False):
if pull is False:
if not self.local_file_exists():
raise FileTransferError(
'Could not transfer file. Local file doesn\'t exist.')
if not self.enough_remote_space():
raise FileTransferError(
'Could not transfer file. Not enough space on device.')
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname=self.device.host,
username=self.device.username,
password=self.device.password,
port=self.port,
allow_agent=False,
look_for_keys=False)
scp = SCPClient(ssh.get_transport(), socket_timeout=30.0)
try:
if pull:
scp.get(self.remote, self.local)
else:
scp.put(self.local, self.remote)
except Exception as e:
raise FileTransferError
finally:
scp.close()
return True
class HaWebHook():
def __init__(self,
webhook_url,
ssh_host=None,
ssh_username=None,
target_dir=None):
self.webhook_url = webhook_url
self.ssh_host = ssh_host
if self.ssh_host:
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.connect(ssh_host, username=ssh_username)
self.scp = SCPClient(ssh.get_transport())
self.target_dir = target_dir
@retry(wait_fixed=2000, stop_max_delay=60000)
def send(self, label, img_path):
log.info(str(label))
if self.ssh_host:
log.info("scp %s to %s on %s" %
(img_path, self.target_dir, self.ssh_host))
self.scp.put(img_path, self.target_dir)
url = self.webhook_url.format(quote_plus(label),
os.path.basename(img_path))
requests.post(url)
def drop(ssh, localFile, remoteLocation):
scp = SCPClient(ssh.get_transport())
# Drop list of files
if (isinstance(localFile, list) and isinstance(remoteLocation, list)):
localFileList = localFile
remoteLocList = remoteLocation
for lfile, rloc in zip(localFileList, remoteLocList):
try:
scp.put(lfile, rloc)
except Exception as e:
print("[-] ", str(e))
print_green("[+] [IP] - " + ssh.get_transport().getpeername()[0] +
" | Successfully dropped: " + lfile + " | Dest: " +
rloc)
# Drop single file
else:
try:
scp.put(localFile, remoteLocation)
except Exception as e:
print("[-] ", str(e))
print_green("[+] [IP] - " + ssh.get_transport().getpeername()[0] +
" | Successfully dropped: " + localFile + " | Dest: " +
remoteLocation)
def AtualizaFw(self):
try:
ssh = SSHClient()
ssh.set_missing_host_key_policy(AutoAddPolicy())
ssh.connect(self.ip, username=self.usuario, password=self.senha)
scp = SCPClient(ssh.get_transport())
scp.put(self.fw, '/tmp/fwupdate.bin')
stdin, stdout, stderr = ssh.exec_command('/sbin/fwupdate -m\n')
print("Firmware atualizado - %s" % self.ip)
ssh.close()
except ConnectionResetError:
ssh.close()
except ConnectionRefusedError:
ssh.close()
except OSError:
ssh.close()
except ssh_exception.AuthenticationException:
ssh.close()
except ssh_exception.SSHException:
ssh.close()
except AttributeError:
ssh.close()
except Exception:
ssh.close()
except:
ssh.close()
class WebCam:
def __init__(self, cam_num, ssh):
self.cam_num = cam_num
self.last_frame = np.zeros((1,1))
self.ssh = ssh
self.scp = SCPClient(self.ssh.get_transport(), socket_timeout=None)
def initialize(self):
self.cap = cv2.VideoCapture(self.cam_num)
self.frame_width = int(self.cap.get(3))
self.frame_height = int(self.cap.get(4))
def getSingleCap(self):
ret, self.last_frame = self.cap.read()
return self.last_frame
def getMultiFrames(self, frames, name):
VID_NAME = '{}.mp4'.format(name)
vid_out = cv2.VideoWriter(VID_FOLDER + VID_NAME, cv2.VideoWriter_fourcc(*'MP4V'), 10, (self.frame_width, self.frame_height))
for i in range(frames):
frame = self.getSingleCap()
vid_out.write(frame)
vid_out.release()
self.videoTransfer(VID_FOLDER + VID_NAME, VID_NAME)
def videoTransfer(self, filename, VID_NAME):
try:
self.scp.put(filename, REMOTE_VID_FOLDER + VID_NAME)
except SCPException:
raise IOError("Remote directory not available")
def close_camera(self):
self.cap.release()
return self.ssh
def task(zeros, ranges, margin, public_ip):
key = paramiko.RSAKey.from_private_key_file("") #pls put key file location
client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ec2 = boto3.resource('ec2')
try:
client.connect(hostname=public_ip, username="******", pkey=key)
scp = SCPClient(client.get_transport())
scp.put('Task_T.py', recursive=True, remote_path='/home/ubuntu')
stdin, stdout, stderr = client.exec_command('python3 Task_T.py' + ' ' +
str(zeros) + ' ' +
str(ranges) + ' ' +
str(margin))
data = stdout.read().splitlines()
for line in data:
if (line.decode()):
print(line.decode())
client.close()
ec2.instances.filter(Filters=[{
'Name': 'instance-state-name',
'Values': ['running']
}]).terminate()
except Exception as e:
print(e)
def upload_test(self, filenames, recursive, expected=[]):
destination = b'/tmp/upp\xC3\xA9' + next(unique_names)
chan = self.ssh.get_transport().open_session()
chan.exec_command(b'mkdir ' + destination)
assert chan.recv_exit_status() == 0
previous = os.getcwd()
try:
os.chdir(self._temp)
scp = SCPClient(self.ssh.get_transport())
scp.put(filenames, destination, recursive)
chan = self.ssh.get_transport().open_session()
chan.exec_command(
b'echo -ne "' +
destination.decode('iso-8859-1')
.encode('ascii', 'backslashreplace') +
b'" | xargs find')
out_list = b''
while True:
data = chan.recv(1024)
if not data:
break
out_list += data
prefix = len(destination) + 1
out_list = [l[prefix:] for l in out_list.splitlines()
if len(l) > prefix]
self.assertEqual(normalize_paths(out_list), set(expected))
finally:
os.chdir(previous)
chan = self.ssh.get_transport().open_session()
chan.exec_command(b'rm -Rf ' + destination)
assert chan.recv_exit_status() == 0
def put_file_to_scp_service(self,
file_name,
remote_path="/A8/",
local_path="D:\python_eg"):
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy)
ssh_client.connect(self.__host, self.__port, self.__username,
self.__password)
scpclient = SCPClient(ssh_client.get_transport(), socket_timeout=15.0)
# local_path = file_path + "\\" + img_name
file_path_lo = local_path + '/' + file_name
file_path_re = remote_path
print(file_path_lo)
print(file_path_re)
try:
scpclient.put(file_path_lo, file_path_re) # 上传到服务器指定文件
#scpclient.get(file_path_re, file_path_lo) # 从服务器中获取文件
except FileNotFoundError as e:
print(e)
print("system could not find the specified file" + local_path)
result = "system could not find the specified file" + local_path
else:
print("文件上传成功")
result = "File uploaded successfully"
ssh_client.close()
return result
def push(self, src_path, dest_path, push_timeout=None):
"""
Push file on dut
:param src_path: str
:param src_path: Source path of file
:type dest_path: str
:param dest_path: Destination path on DUT
:type push_timeout: int
:param push_timeout: timeout to push the file
:rtype: tuple
:return: Boolean indicating operation succeed or not, message
"""
verdict = False
msg = "fail to push file %s onto %s, no opened connection" % (src_path, dest_path)
if self.__protocol is not None:
try:
scp_client = SCPClient(self.__protocol.get_transport())
scp_client.put(src_path, dest_path)
verdict = True
msg = "Pushed file %s onto %s" % (src_path, dest_path)
except Exception as ex:
msg = "Error happen when pushing file %s onto %s :%s" % (src_path, dest_path, str(ex))
return verdict, msg
def scp_file(ip, uname, pswd, image): ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.load_system_host_keys() ssh.connect(ip, username=uname, password=pswd) scp = SCPClient(ssh.get_transport()) scp.put(image, '/tmp/flashimg')
def backup_influx():
db_user = details['influxDB']['username']
db_pwd = details['influxDB']['password']
db_details = details['influxDB']['database']
dbs = db_details.keys()
print ("dbs: {}".format(dbs))
for db in dbs:
print ("db: {}".format(db))
for msrmt in db_details[db]:
print ("measurement {}".format(msrmt))
csv_file = get_filename(db, msrmt)
cli = "influx -username {} -password \"{}\" -database '{}' -host 'localhost' -execute 'SELECT * FROM \"{}\".\"{}\".\"{}\" where time > now() -1d order by time desc' -format 'csv' > {}".format(db_user, db_pwd, db, db, db, msrmt, csv_file)
print ("influx cli {}".format(cli))
#exec_influx = subprocess.run([cli], stdout=subprocess.PIPE).stdout.decode('utf-8')
exec_influx = os.system(cli)
#scp_cli = 'scp {} -P 13022 [email protected]:/root/hb_backup/.'.format(csv_file)
ssh = createSSHClient(details['dest']['server'], details['dest']['port'], details['dest']['user'], details['dest']['password'])
scp = SCPClient(ssh.get_transport())
scp.put('/home/juniper/'+str(csv_file), details['dest']['path'])
ssh.close()
os.remove(csv_file)
return "Success"
def set_sshcfg(self, **kw):
node = kw['node']
nodeinfo = kw['nodeinfo']
tmp_remote_dir = "/tmp/%s/.ssh/" % nodeinfo['username']
try:
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(
paramiko.MissingHostKeyPolicy())
ssh_client.connect(nodeinfo['bmcip'],
username=nodeinfo['username'],
password=nodeinfo['password'])
except (NoValidConnectionsError) as e:
return self.callback.error(
"Unable to connect to bmc %s" % nodeinfo['bmcip'], node)
if not ssh_client.get_transport().is_active():
return self.callback.error(
"SSH session to bmc %s is not active" % nodeinfo['bmcip'],
node)
if not ssh_client.get_transport().is_authenticated():
return self.callback.error(
"SSH session to bmc %s is not authenticated" %
nodeinfo['bmcip'], node)
ssh_client.exec_command("/bin/mkdir -p %s\n" % tmp_remote_dir)
scp = SCPClient(ssh_client.get_transport())
scp.put(self.copy_sh_file, tmp_remote_dir + "copy.sh")
scp.put(self.local_public_key, tmp_remote_dir + "id_rsa.pub")
ssh_client.exec_command("%s/copy.sh %s" %
(tmp_remote_dir, nodeinfo['username']))
ssh_client.close()
return self.callback.info("ssh keys copied to %s" % nodeinfo['bmcip'])
def connect_clients(hostname, username, password, cmd):
try:
date_now = time.strftime('%Y_%m_%d_%H_%M_%S',
time.localtime(time.time()))
client = paramiko.SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(hostname=hostname, username=username, password=password)
if upload_flag != 0 or download_flag != 0:
scpclient = SCPClient(client.get_transport(), socket_timeout=15.0)
print(cmd)
if upload_flag == 1:
scpclient.put(cmd, remote_path)
elif download_flag == 1:
scpclient.get(cmd, os.path.abspath("."))
else:
shell = client.invoke_shell()
shell.sendall(cmd + "\n")
shell.sendall("exit\n")
except Exception as e:
print("[%s] %s target failed, the reason is %s" %
(date_now, hostname, str(e)))
else:
print("[%s] %s target success" % (date_now, hostname))
finally:
client.close()
def copy_to_server(self, in_folder, out_folder):
self.ssh_client.connect(hostname=ADDR, username=USR_NAME, password=PWD)
print('connecting to on_prem_server using ssh')
stdin, stdout, stderr = self.ssh_client.exec_command('ls')
print(stdout.readlines())
scp_client = SCPClient(self.ssh_client.get_transport())
scp_client.put(in_folder, recursive=True, remote_path=out_folder)
def transfer(self, evo_name):
#compress
#shutil.make_archive(self.temp_zip_dir+evo_name, 'zip', '../../../PymoNNto_Dev')
zipDir('../../../PymoNNto_Dev/', self.temp_zip_dir + evo_name + '.zip',
[
'.git', '.idea', '\\StorageManager\\', '\\NetworkStates\\',
'\\Evo\\', '\\__pycache__\\', '\\midis\\'
])
#transfer
#self.exec_cmd(self.get_transfer_cmd(evo_name))
ssh = self.get_ssh_connection()
scp = SCPClient(ssh.get_transport())
src = self.temp_zip_dir + evo_name + '.zip'
dst = self.main_path + evo_name + '.zip'
scp.put(src, dst)
ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command(
self.get_extract_cmd(evo_name))
ssh_stdout.channel.recv_exit_status()
#extract
#self.exec_cmd(self.get_extract_cmd(evo_name))
os.remove(self.temp_zip_dir + evo_name + '.zip')
ssh.close()
scp.close()
def transfer_file(self, dest):
"""Begin to transfer file by scp"""
if not self.local_file_exists():
self.module.fail_json(
msg='Could not transfer file. Local file doesn\'t exist.')
if not self.enough_spajctanner.network_cloudengine.ce():
self.module.fail_json(
msg='Could not transfer file. Not enough spajctanner.network_cloudengine.ce on devijctanner.network_cloudengine.ce.')
hostname = self.module.params['provider']['host']
username = self.module.params['provider']['username']
password = self.module.params['provider']['password']
port = self.module.params['provider']['port']
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname=hostname, username=username, password=password, port=port)
full_remote_path = '{0}{1}'.format(self.file_system, dest)
scp = SCPClient(ssh.get_transport())
try:
scp.put(self.local_file, full_remote_path)
exjctanner.network_cloudengine.cept Exjctanner.network_cloudengine.ception:
time.sleep(10)
file_exists, temp_size = self.remote_file_exists(
dest, self.file_system)
file_size = os.path.getsize(self.local_file)
if file_exists and int(temp_size) == int(file_size):
pass
else:
scp.close()
self.module.fail_json(msg='Could not transfer file. There was an error '
'during transfer. Please make sure the format of '
'input parameters is right.')
def copy_file(local_file_path, dest_path, host=cfg.HOST_CONF['HOST'], port=cfg.HOST_CONF['PORT'], user=cfg.HOST_CONF['USER'], password=cfg.HOST_CONF['PASSWORD'], mode = 'PUT'):
transport = None
if not path.exists(local_file_path):
if mode is 'GET':
mkdir(local_file_path)
else:
print "Local file path doesnt exist %s" %(local_file_path)
paramiko.util.log_to_file(cfg.PARAMIKO_LOG)
transport = paramiko.Transport((host, port))
try:
transport.connect(username=user, password=password)
transport.get_exception()
scp = SCPClient(transport)
except:
print "Error while connecting to host %s:%s" %(host, port)
#scp.put('test_eth.sh', 'test_eth_1.sh')
#scp.get('test_eth_1.sh')
if mode is 'PUT':
#print "copying file from %s to %s on host %s " %(local_file_path, dest_path, host)
scp.put(local_file_path, dest_path)
else:
#print scp.get(dest_path,local_file_path, recursive=True)
scp.get(dest_path, recursive=True)
#print scp.get(dest_path, local_path="path_to_directory where store this directory", recursive= True)
scp.close()
def put_magic_wllt(ssh, passphrase):
print("LOCAL_WALLET_PATH", LOCAL_WALLET_PATH)
# Check if local wallet exists
if path.exists(LOCAL_WALLET_PATH): # replace with get_wallet_db()
command = "gpg -c --batch --no-symkey-cache --compress-algo none --passphrase "+ passphrase + " " + REMOTE_WALLET_PATH + "/" + WALLET_NAME
try:
scp = SCPClient(ssh.get_transport(), progress4=progress4)
scp.put(f"{get_wallet_db()}", REMOTE_WALLET_PATH)
# Encrypt it
#stdin, stdout, stderr = ssh.exec_command(command)
#lines = stdout.readlines()
#if lines:
# print('Lines:',lines)
result = "Copied local wallet to device\n"
except Exception as e:
print("Couldn\'t connect, connection error:", e)
result = "Failed to copy wallet to device"
else:
result = "Couldn\'t find local wallet.db file, exiting..."
scp.close()
ssh.close()
print(result)
return result
def put_file(self,mac_addr,function_name):
scp = None
file_path = self._lookup_function_files(function_name)
print file_path
if(os.path.exists(file_path)):
if(os.path.isdir(file_path)):
if(self.scp_clients.has_key(mac_addr)):
ssh = self.scp_clients[mac_addr]
scp = SCPClient(ssh.get_transport())
print scp
print file_path
try:
scp.put(file_path,recursive=True)
except:
print "SCPException"
#files = os.listdir(file_path)
## assumes no directory in the element dir
#for item in files:
# print item
# scp.put(file_path+'/'+item) #Not portable use os.path.join
if(os.path.isfile(file_path)):
if(self.scp_client.has_key(mac_addr)):
scp = self.scp_clients[mac_addr]
scp.put(file_path)
pass
return True
def put(self, files, remote_path=None, out_stream=sys.stdout, verbose=False):
"""
Copy a file from the local system to the remote system.
:param files:
:param remote_path:
:param out_stream:
:param verbose:
:return: :rtype:
"""
if remote_path is None:
remote_path = files
self.display("scp '{src}' '{dest}'".format(src=files, dest=remote_path),
out_stream=out_stream, verbose=verbose)
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(Project.address, Project.port, Project.user, Project.password)
scp = SCPClient(ssh.get_transport())
# scp = SCPClient(self.ssh.get_transport())
# noinspection PyBroadException
try:
info("\nfiles: %s" % repr(files))
info("remote_path: %s" % remote_path)
output = scp.put(files, '"{dest}"'.format(dest=remote_path), recursive=True) or ''
except Exception:
try:
output = scp.put(files, remote_path, recursive=True) or ''
except Exception as ex:
output = str(ex)
self.display("\n" + output, out_stream=out_stream, verbose=verbose)
return output
def push_config(self, client, restart=False):
self.write_config()
scp = SCPClient(client.get_transport())
scp.put(str(self._local_config_path), str(self._remote_config_path))
if restart:
client.exec_command(self.RESTART_COMMAND)
time.sleep(10)
def ssh_scp(path):
ssh = _init_ssh()
ha_path = app.config.get('HAPROXY_PATH')
ha_cmd = "/usr/sbin/service haproxy restart"
scp = SCPClient(ssh.get_transport())
scp.put(path,ha_path)
stdin, stdout, stderr = ssh.exec_command(ha_cmd)
return stderr.read()
def upload_iso(iso_path, storage_name):
host_ip = get_mgmt_ip_by_storagename(storage_name)
ssh = createSSHClient(host_ip, 22, "root", "arbre1234")
scp = SCPClient(ssh.get_transport())
if os.path.isfile(iso_path):
scp.put(iso_path)
else:
return False
def run(self):
try:
# run a command and wait for it to finish
def run(command):
_, stdout, _ = ssh.exec_command(command)
stdout.channel.recv_exit_status()
# send the webapp a textual progress update
listener = Listener()
def log(text):
listener.publish(('project', self.project.name, 'deploy', 'status'), { 'text': text })
# prevent accidentally deploying on the server itself
# (this doesn't prevent deploying to the server's public
# IP address, so there's still a security problem here)
if self.host in ['127.0.0.1', '0.0.0.0']:
raise Exception('you\'re trying to deploy to the server!')
# create temporary build file
path = os.path.join(tempfile.mkdtemp(), 'deploy.launch')
xml = roslaunch_xml_for_file(self.project.project_file_path, self.remote_deploy_path)
open(path, 'w').write(xml)
log('Created file: deploy.launch')
# create a ssh session
log('Connecting to %s@%s...' % (self.user, self.host))
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(AutoAddPolicy())
ssh.connect(self.host, username=self.user, password=self.password)
log('Connected to remote machine')
# clean the deploy location
run('rm -fr %s' % self.remote_deploy_path)
run('mkdir -p %s' % self.remote_deploy_path)
log('Cleaned deploy location')
# copy the launch file over
scp = SCPClient(ssh.get_transport())
scp.put(path, remote_path=self.remote_deploy_path)
log('Copied file: deploy.launch')
# run the file
command = 'cd %s && roslaunch deploy.launch' % self.remote_deploy_path
channel = ssh.invoke_shell()
channel.send(command + '\nexit\n')
log('Ran command: roslaunch deploy.launch')
# wait for the command to finish
import time
while not self.die:
time.sleep(0.1)
except:
import traceback
log('Exception:\n' + traceback.format_exc())
ssh.close()
log('Connection was closed')
def transfer_file(self, hostname=None, username=None, password=None, pull=False):
"""Transfer the file to the remote device over SCP.
Note:
If any arguments are omitted, the corresponding attributes
of ``self.device`` will be used.
Args:
hostname (str): OPTIONAL - The name or
IP address of the remote device.
username (str): OPTIONAL - The SSH username
for the remote device.
password (str): OPTIONAL - The SSH password
for the remote device.
Returns:
True if successful.
Raises:
FileTransferError: if the transfer isn't successful.
"""
if pull is False:
if not self.local_file_exists():
raise FileTransferError(
'Could not transfer file. Local file doesn\'t exist.')
if not self.enough_space():
raise FileTransferError(
'Could not transfer file. Not enough space on device.')
hostname = hostname or self.device.host
username = username or self.device.username
password = password or self.device.password
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(
hostname=hostname,
username=username,
password=password,
port=self.port,
allow_agent=False,
look_for_keys=False)
full_remote_path = '{}{}'.format(self.file_system, self.dst)
scp = SCPClient(ssh.get_transport())
try:
if pull:
scp.get(full_remote_path, self.src)
else:
scp.put(self.src, full_remote_path)
except:
raise FileTransferError(
'Could not transfer file. There was an error during transfer. Please make sure remote permissions are set.')
finally:
scp.close()
return True
def addMacs(user, passwd, ip):
'''Connects to DD-WRT router with ip address ip over ssh. Then SCPs the
maclist into the DD-WRT /root/ directory. Feeds this file into a Shell-
Variable, then updates the mac filterlist and commits the config.
Input: user: username, string
passwd: password, string
ip: ip address to connect to, string
Output: void'''
client = paramiko.SSHClient()
client.load_system_host_keys()
client.set_missing_host_key_policy(AllowAllKeys())
try:
statusChangeOneIP(ip, bcolors.OKBLUE + 'connecting' + bcolors.ENDC)
client.connect(ip, username=user, password=passwd)
except BadHostKeyException:
statusChangeOneIP(ip, bcolors.FAIL + 'Host Key Exception' +\
bcolors.ENDC)
client.close()
return
except AuthenticationException:
user = raw_input('Authentication Exception, username: '******'Password: '******'SSH Exception' + bcolors.ENDC)
client.close()
return
except socket_error:
statusChangeOneIP(ip, bcolors.FAIL + 'cannot reach device' +\
bcolors.ENDC)
client.close()
return
statusChangeOneIP(ip, bcolors.OKBLUE + 'connected' + bcolors.ENDC)
try:
scp = SCPClient(client.get_transport())
'''Copy the parse mac addresses over to /root/, wait a second to make
sure transfer is complete, then set the _maclist variables on the router
and commit changes'''
scp.put(installpath + '/macsParsed.txt', 'macs.txt')
time.sleep(1)
client.exec_command('nvram set ath0_maclist="$(cat macs.txt)" && '\
'nvram set wl0_maclist="$(cat macs.txt)" && nvram commit')
statusChangeOneIP(ip, bcolors.OKGREEN + 'changes committed' +\
bcolors.ENDC)
#print('Changes commited')
except SSHException:
statusChangeOneIP(ip, bcolors.FAIL + 'SSH Exception' + bcolors.ENDC)
client.close()
return
client.close()
def put_file(self, source, destination):
assert os.path.isfile(source)
try:
scp = SCPClient(self.__ssh.get_transport())
scp.put(source, destination)
except Exception as err:
print err
return {'status': 'KO'}
return {'status': 'OK'}
def scp(self, filename, remote_path):
config = SSHConfig()
config.parse(open(os.path.expanduser('~/.ssh/config')))
o = config.lookup('geodata')
ssh_client = SSHClient()
ssh_client.load_system_host_keys()
ssh_client.connect(o['hostname'], username=o['user'])
scp = SCPClient(ssh_client.get_transport())
scp.put(filename, remote_path=remote_path)
def copy(hostname, username, filepath, remotefile):
ssh = SSHClient()
# ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(hostname, username=username)
ssh.exec_command("mkdir -p " + remotefile[0:remotefile.rindex('/')])
# SCPCLient takes a paramiko get_transportt as its only argument
scp = SCPClient(ssh.get_transport())
scp.put(filepath, remotefile)
def parseBytesFromIface(self, sense, hnbIndex):
logger.info('getting time and bytes for sense: %s -- hnb: %s' % (sense, hnbIndex))
bytesTimeConfig = ConfigParser.ConfigParser()
bytesTimeConfFile = open('/var/tmp/bytes-time-%s-%d.conf' % (sense, hnbIndex), 'w')
bytesTimeConfig.add_section('snapshot')
ifbIfaces = []
htbQueues = []
edge = config.get('rol', 'edgeType')
if edge == 'UL':
htbQueues = json.loads(config.get('hnbs', 'ulHtbQueues'))
ifbIfaces = json.loads(config.get('hnbs', 'ulIfbIfaces'))
else:
htbQueues = json.loads(config.get('hnbs', 'dlHtbQueues'))
ifbIfaces = json.loads(config.get('hnbs', 'dlIfbIfaces'))
logger.info('htbQueues: %s -- ifbIfaces: %s' % (htbQueues, ifbIfaces))
timeStamps = []
ifaceBytes = []
Pos = 0
for hnbIter, hnb in enumerate(ifbIfaces):
timeStampsIface = []
ifaceBytesIface = []
for ifaceIndex, iface in enumerate(hnb):
output = subprocess.check_output('tc -s -d class show dev %s' % iface, shell=True)
timeStamp = time.time()
logger.info('Timestamp from iface %s: %f seconds' % (iface, timeStamp))
queue = ''
for row in output.split('\n'):
if queue != '':
ifaceByte = row.split(' ')[2]
logger.info('timeStamp: %s -- ifaceBytes: %s' % (timeStamp, ifaceByte))
timeStampsIface.append(timeStamp)
ifaceBytesIface.append(ifaceByte)
queue = ''
if 'class' in row:
queue = row.split(' ')[2]
if (hnb[ifaceIndex], queue) not in self.getCombinations(ifbIfaces, htbQueues):
queue = ''
timeStamps += [timeStampsIface]
ifaceBytes += [ifaceBytesIface]
logger.info('ifbIfaces: %s' % ifbIfaces)
logger.info('htbQueues: %s' % htbQueues)
logger.info('timeStamps: %s' % timeStamps)
logger.info('ifaceBytes: %s' % ifaceBytes)
bytesTimeConfig.set('snapshot', 'ifbIfaces', json.dumps(ifbIfaces))
bytesTimeConfig.set('snapshot', 'htbQueues', json.dumps(htbQueues))
bytesTimeConfig.set('snapshot', 'timeStamps', json.dumps(timeStamps))
bytesTimeConfig.set('snapshot', 'ifaceBytes', json.dumps(ifaceBytes))
bytesTimeConfig.write(bytesTimeConfFile)
bytesTimeConfFile.close()
if edge == 'DL':
nodes = json.loads(config.get('algorithms', 'nodes'))
ssh = self.createSSHClient(nodes[0])
scp = SCPClient(ssh.get_transport())
scp.put('/var/tmp/bytes-time-%s-%d.conf' % (sense, hnbIndex), '/var/tmp/bytes-time-%s-%d.conf' % (sense, hnbIndex))
def http_config(hostname, username, password):
connect = createSSHClient(hostname, 22, username, password)
""" Installing Apache on the servers"""
print "\n Installing Apache on the Servers "
stdin, stdout, stderr = connect.exec_command('apt-get -y install apache2')
print 'This is output =',stdout.readlines()
print 'This is error =',stderr.readlines()
"""Copying the index.php file"""
print "\n Copying the Index.php file remotely"
# ssh = createSSHClient(hostname, 22, username, password)
scp = SCPClient(connect.get_transport())
scp.put(local_path, remote_path)
"""Customizing Apache on the servers"""
print "\n Customizing Apache "
stdin, stdout, stderr = connect.exec_command('mv /var/www/html/index.html /var/www/html/index.html_backup')
print 'This is output =',stdout.readlines()
print 'This is error =',stderr.readlines()
"""Changing Permissions on index.php file"""
print "\n Changing File permissions "
stdin, stdout, stderr = connect.exec_command('chown root:root /var/www/html/index.php')
print 'This is output =',stdout.readlines()
print 'This is error =',stderr.readlines()
"""Customizing Apache on the servers"""
print "\n Changing File permissions "
stdin, stdout, stderr = connect.exec_command('chmod 644 /var/www/html/index.php')
print 'This is output =',stdout.readlines()
print 'This is error =',stderr.readlines()
"""Restarting the Apache server"""
print "\n Restarting the Apache Server "
stdin, stdout, stderr = connect.exec_command('service apache2 restart')
print 'This is output =',stdout.readlines()
print 'This is error =',stderr.readlines()
"""Verify that http server is up and can spit out Hello World"""
print "\n Verifying http server"
stdin, stdout, stderr = connect.exec_command('curl -sv "http://localhost"| grep -i hello')
list_http = stdout.readlines()
print 'This is output =',list_http
print 'This is error =',stderr.readlines()
i = 0
for each in list_http:
if re.search(r'Hello', each) != None:
print "\n ***HTTP server is up and running with Hello World*** \n\n\n"
exit
else:
i =+1
if i > 0:
print "\n ***HTTP Server does not have Hello World*** \n\n\n"
connect.close()
def copy(handler, src, dest, recursive=False):
"""
:param client: NodeHandler
:param src: source file path (local)
:param dest: destination file path (remote)
:recursive: folder + all subfolders, files?
"""
# Context manager doesnt work properly? try later -_-
scp = SCPClient(handler.client.get_transport())
scp.put(src, dest, recursive=recursive)
def backup_to_server(servers, tarfile): ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(AutoAddPolicy()) for server in servers: ssh.connect(server['host'], port=server['port'], username=server['user'], password=server['password']) # SCPCLient takes a paramiko transport as its only argument scp = SCPClient(ssh.get_transport()) scp.put(tarfile, server['dir'])
def transferFile(origin, destination): hostname = 'fii.to' port = 22 username = '******' password = '******' ssh = paramiko.SSHClient() ssh.load_system_host_keys() ssh.connect(hostname, username=username, password=password) scp = SCPClient(ssh.get_transport()) scp.put(origin, destination)
def scp(file, path, ip, user, password):
"""Uses paramiko and scp module built on top of it to SCP vEOS to the VM.
Inputs are the .swi filename from arguments, and a path."""
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.connect(hostname=ip, username=user, password=password)
scp = SCPClient(ssh.get_transport())
print "\nWriting " + file + " to " + path
scp.put(file, remote_path=path)
scp.close()
def transport_assembly_run( seed_name, tfilename, workdir='./build' ):
# Push package: to-be processed packages are placed in 'put' directory.
# Pulled package: finished work is in the 'get' directory.
retry = 1
# Credentials wide out in the open:
ssh = createSSHClient(CL_SERVER_NAME, 22, CL_SERVER_USER, CL_SERVER_PW)
while (retry < 10):
try:
scp = SCPClient(ssh.get_transport())
scp.put(tfilename, 'run')
# If it got this far, it succeeded
break;
except Exception as err:
print '=============='
print err[0]
print ' Retry attemp #'+retry
print '=============='
sleep(5)
#
# Server Processing Phase
#
waittime = 0
while (waittime < 600):
try:
scp = SCPClient(ssh.get_transport())
# Check the log file
scp.get('get/'+seed_name+'_run.log', local_path=workdir)
line = tail("-1", os.path.join(workdir,seed_name+'_run.log') ).strip()
print line
if 'Assembly Complete' in line:
break
if 'ERROR' in line:
exit(1)
except Exception as err:
print '=============='
print err[0]
print '=============='
if 'No such file or directory' in err[0]:
print "---- No status yet ----"
sleep(2)
waittime = waittime + 1
scp.close()
# Compile complete. Download results.
try:
scp.get('get/'+seed_name+'_assembly.dat', local_path=workdir)
os.rename( os.path.join(workdir, seed_name+'_assembly.dat'), os.path.join(workdir,'assembly.dat'))
except Exception as err:
print '=============='
print err[0]
print '=============='
exit(1)
return True
