def report(self):
'''
Get instance and connection info for all enabled projects.
'''
client = SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(env['OS_SSH_HOST'], username=env['OS_SSH_USERNAME'], password=env['OS_SSH_PASSWORD'])
for project in self.project_list:
if not eval(project[2]) or project[1] in ('admin', 'services'):
continue
ttys = []
stdin, stdout, stderr = client.exec_command('source /etc/nova/openrc && nova list --tenant %s'%project[0])
output = stdout.read()
serverlist = filter(lambda x: x.count(project[0]), output.splitlines()).__len__()
stdin, stdout, stderr = client.exec_command('source /etc/nova/openrc && neutron floatingip-list --tenant-id %s -F floating_ip_address'%project[0])
floatingips = re.findall('\d+\.\d+\.\d+\.\d+', stdout.read())
print "====INFO====", project[1], project[2], project[0], serverlist, floatingips
ttys = []
for ip in floatingips:
if not self.ping_ip_reachable(ip):
continue
sshp = SshconnectionProcess(ip)
sshp.run()
ttys += sshp.return_result()
self.report_result.append({project[1].encode('ascii'): \
{'instance':serverlist, 'connection':ttys.__len__(), 'enable': eval(project[2]), \
'tenant_id':project[0].encode('ascii'), 'floatingips':floatingips}})
client.close()
def run(self):
if self.GITHUB_TOKEN is None:
logging.critical('No github OAuth token defined in the GITHUB_TOKEN env variable')
sys.exit(1)
if self.SSH_PKEY is None:
logging.critical('SSH_KEY not configured, please set it to you private SSH key file')
sys.exit(1)
github = Github(self.GITHUB_TOKEN)
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.SSH_PKEY = os.path.expanduser(self.SSH_PKEY)
orga = github.get_organization('nuxeo') # type: Organization
repo = orga.get_repo('nuxeo.com') # type: Repository
opened_pulls = [('/var/www/nuxeo.com/pr-%d.' % pull.number) + self.PREVIEW_DOMAIN for pull in repo.get_pulls()]
try:
proxy = ProxyCommand(('ssh -i %s -W 10.10.0.63:22 ' % self.SSH_PKEY) + self.BASTION_IP)
ssh.connect('10.10.0.63', username='******', sock=proxy, key_filename=self.SSH_PKEY)
_, stdout, _ = ssh.exec_command('ls -d /var/www/nuxeo.com/pr-*')
[ssh.exec_command('rm -rf ' + line.strip()) for line in stdout.readlines() if line.strip() not in opened_pulls]
ssh.close()
except SSHException, e:
logging.critical('Could work on remote: %s', e)
sys.exit(1)
def install_kinto_remotely(id_alwaysdata, credentials, ssh_host, prefixed_username, status_handler):
logs = StringIO()
# SSH Login
ssh = SSHClient()
ssh.set_missing_host_key_policy(AutoAddPolicy())
ssh.connect(ssh_host, username=prefixed_username, password=credentials[1], look_for_keys=False)
# Install pip
retry = 30
error = None
while retry > 0:
try:
stdin, stdout, stderr = ssh.exec_command(
"PYTHONPATH=~/.local/ easy_install-2.6 --install-dir=~/.local -U pip"
)
retry = 0
except ssh_exception.AuthenticationException as e:
error = e
sleep(5)
retry -= 1
if retry == 0 and error is not None:
logs.write(error)
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
# Install virtualenv
stdin, stdout, stderr = ssh.exec_command(
"PYTHONPATH=~/.local/ ~/.local/pip install --user --no-binary --upgrade "
"setuptools virtualenv virtualenvwrapper"
)
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
# Create virtualenv
stdin, stdout, stderr = ssh.exec_command("~/.local/bin/virtualenv kinto/venv/ --python=python2.7")
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
# Install Kinto in the virtualenv
stdin, stdout, stderr = ssh.exec_command("kinto/venv/bin/pip install kinto[postgresql] kinto-attachment flup")
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
# Run kinto migration to setup the database.
stdin, stdout, stderr = ssh.exec_command("kinto/venv/bin/kinto --ini kinto/kinto.ini migrate")
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
ssh.close()
def ssh_instance_pass(step, instance_name, password):
out = bash('ssh %s -A -f -L 11112:%s:22 root@%s -N' % (SSH_OPTS, world.instances[instance_name]['ip'], config['cloud']['master']))
if out.successful():
from paramiko.client import SSHClient
client = SSHClient()
client.load_system_host_keys()
client.connect('localhost', username='******', password=password, port=11112)
#stdin, stdout, stderr = client.exec_command('hostname')
client.exec_command('hostname')
print 'done'
client.close()
def fetch_moosefs_drive_content(self, remote_host_ip: str) -> dict:
# A sample result dictionary
# result_dict = {
# 'files': ['temp_file101', 'temp_file102'],
# 'cotent': [file 1 content here', 'file 2 content here' ]
# }
try:
result_dict = dict()
result_dict['files'] = list()
result_dict['content'] = list()
mfsClientVM = SSHClient()
mfsClientVM.set_missing_host_key_policy(paramiko.AutoAddPolicy())
mfsClientVM.load_system_host_keys()
mfsClientVM.connect(hostname=remote_host_ip,
username=self.remote_host_username)
print("Fetching file and its content on VM with IP: " +
remote_host_ip)
# Fetch file name on client VM
stdin, stdout, stderr = mfsClientVM.exec_command(
'cd /mnt/mfs/; ls')
outlines = stdout.readlines()
stdin.close()
file_name = ''.join(outlines)
file_name = str(file_name).rstrip('\n')
result_dict['files'].append(file_name)
print('File name is: ' + file_name)
# Fetch file content on client VM
stdin, stdout, stderr = mfsClientVM.exec_command(
'cd /mnt/mfs/; cat ' + file_name)
outlines = stdout.readlines()
stdin.close()
file_content = ''.join(outlines)
file_content = str(file_content).rstrip('\n')
result_dict['content'].append(file_content)
print('File Content is: ' + file_content)
mfsClientVM.close()
return result_dict
except Exception as e:
print(
"Something went wrong while fetching the moosefs drive content"
)
print("Error Details: " + str(e))
return None
def __power_off_linux():
cfg = SSHConfig.from_path(Path.home() / ".ssh" / "config")\
.lookup(SSH_INSTANCE)
ssh = SSHClient()
ssh.set_missing_host_key_policy(AutoAddPolicy())
ssh.connect(
**{
"hostname": cfg.get("hostname"),
"port": cfg.get("port") or 22,
"username": cfg.get("user"),
"password": cfg.get("password"),
"key_filename": cfg.get("identityfile"),
})
ssh.exec_command("sudo poweroff")
class SshClient():
def __init__(self):
self.ssh_client = SSHClient()
def ssh_login(self, host_ip, username, password):
try:
# 设置允许连接known_hosts文件中的主机（默认连接不在known_hosts文件中的主机会拒绝连接抛出SSHException）
self.ssh_client.set_missing_host_key_policy(AutoAddPolicy())
self.ssh_client.connect(host_ip, port=22, username=username, password=password)
except AuthenticationException:
print('username or password error')
return 1001
except NoValidConnectionsError:
print('connect time out')
return 1002
except:
print("Unexpected error:", sys.exc_info()[0])
return 1003
return 1000
def execute_some_command(self, command):
stdin, stdout, stderr = self.ssh_client.exec_command(command)
print(stdout.read().decode())
return stdout.read().decode()
def ssh_logout(self):
self.ssh_client.close()
class SSHTarget:
def __init__(self, host, port=22, timeout=10):
self.host = host
self.port = int(port)
self.timeout = timeout
self.ssh_client = SSHClient()
self.ssh_client.set_missing_host_key_policy(AutoAddPolicy())
def connect(self, username, password):
self.ssh_client.connect(self.host,
self.port,
username,
password,
timeout=self.timeout)
def connect_with_key(self, username, key):
self.ssh_client.connect(self.host,
self.port,
username,
key_filename=key,
timeout=self.timeout)
def close(self):
self.ssh_client.close()
def send(self, data):
tdin, stdout, stderr = self.ssh_client.exec_command(data)
if stderr.readline() != "":
Logger.warning("STDERR was not null! (" +
stderr.read().decode("utf-8") + ")")
return stdout.read().decode("utf-8")
class MySSHClient():
def __init__(self):
self.ssh_client = SSHClient()
def ssh_login(self, host_ip, username, password):
try:
self.ssh_client.set_missing_host_key_policy(AutoAddPolicy())
self.ssh_client.connect(host_ip,
port=22,
username=username,
password=password)
except AuthenticationException:
log.warning('username or password error')
return 1001
except NoValidConnectionsError:
log.warning('connect time out')
return 1002
except:
log.warning('unkown error')
print("Unexpect error:", sys.exc_info()[0])
return 1003
return 1000
def ssh_logout(self):
log.warning('will exit host')
self.ssh_client.close()
def execute_some_command(self, command):
_, stdout, _ = self.ssh_client.exec_command(command)
print(stdout.read().decode())
class RemoteClient(object):
def __init__(self, host, ip=None, user='******'):
self.host = host
self.ip = ip
self.user = user
self.client = SSHClient()
self.sftpclient = None
self.client.set_missing_host_key_policy(AutoAddPolicy())
self.client.load_system_host_keys()
logging.debug("RemoteClient created for host: %s", host)
def startup(self):
try:
logging.debug("Trying to connect to remote server %s", self.host)
self.client.connect(self.host, port=22, username=self.user)
self.sftpclient = self.client.open_sftp()
except PasswordRequiredException:
raise ClientNotSetupException('Pubkey is encrypted.')
except SSHException as e:
raise ClientNotSetupException(e)
except:
if self.ip:
logging.warning("Connection with hostname failed. Retrying "
"with IP")
self._try_with_ip()
else:
logging.error("Connection to %s failed.", self.host)
raise ClientNotSetupException('Could not connect to the host.')
def _try_with_ip(self):
try:
logging.debug("Connecting to IP:%s User:%s", self.ip, self.user)
self.client.connect(self.ip, port=22, username=self.user)
self.sftpclient = self.client.open_sftp()
except PasswordRequiredException:
raise ClientNotSetupException('Pubkey is encrypted.')
except SSHException as e:
raise ClientNotSetupException(e)
except socket.error:
logging.error("Connection with IP (%s) failed.", self.ip)
raise ClientNotSetupException('Could not connect to the host.')
def run(self, command):
if not self.client:
raise ClientNotSetupException(
'Cannot run procedure. Client not initialized')
buffers = self.client.exec_command(command)
output = []
for buf in buffers:
try:
output.append(buf.read())
except IOError:
output.append('')
return tuple(output)
class MySshClient():
def __init__(self):
self.ssh_client = SSHClient()
# 此函数用于输入用户名密码登录主机
def ssh_login(self, host_ip, username, password):
try:
# 设置允许连接known_hosts文件中的主机（默认连接不在known_hosts文件中的主机会拒绝连接抛出SSHException）
self.ssh_client.set_missing_host_key_policy(AutoAddPolicy())
self.ssh_client.connect(host_ip, port=22, username=username, password=password)
except AuthenticationException:
logging.warning('username or password error')
return 1001
except NoValidConnectionsError:
logging.warning('connect time out')
return 1002
except:
logging.warning('unknow error')
print("Unexpected error:", sys.exc_info()[0])
return 1003
return 1000
# 此函数用于执行command参数中的命令并打印命令执行结果
def execute_some_command(self, command):
stdin, stdout, stderr = self.ssh_client.exec_command(command)
res=stdout.read().decode()
print(res)
return res
# 此函数用于退出登录
def ssh_logout(self):
logging.warning('will exit host')
self.ssh_client.close()
def execute_remote_command(ip, command, quiet=False, username=REMOTE_USER):
client = SSHClient()
client.set_missing_host_key_policy(IgnoreHostKeyPolicy)
client.connect(ip, username=username)
stdin, stdout, stderr = client.exec_command(command)
rc = stdout.channel.recv_exit_status()
out = stdout.read().decode('utf-8').splitlines()
err = stderr.read().decode('utf-8').splitlines()
client.close()
if rc != 0 and not quiet:
log = logging.getLogger('TPCH')
log.error("ssh command returned %d" % rc)
log.error("ssh -l %s %s %s" % (username, ip, command))
print(command)
for line in out:
print(line)
for line in err:
print(line)
print()
if rc != 0:
raise RuntimeError(command)
return out, err
def connect(self, instance, ssh_user, ssh_ports, cmd, ssh_key_name):
"""
execute a command on instance with ssh and return if cmd param is not None
connect to ssh if cmd is None
:param instance:
:param ssh_user:
:param ssh_ports:
:param ssh_key_name:
:param cmd: execute this command if not None
:return:
"""
# get instance public ip
ssh_ip = instance.ip
# we need to find the ssh key
try:
key_file = open(os.path.join(os.path.expanduser(self._key_path), ssh_key_name), 'r')
except FileNotFoundError:
try:
key_file = open(os.path.join(os.path.expanduser(self._key_path), ssh_key_name + '.pem'), 'r')
except FileNotFoundError:
raise CourirSshException('private key %(key_name)s nor %(key_name)s.pem not found' % {
'key_name': ssh_key_name
})
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
logger.debug('connecting to %s with port %s and user %s', ssh_ip, ssh_ports[0], ssh_user)
mykey = RSAKey.from_private_key(key_file)
# we try with each ssh_port we have
for count, ssh_port in enumerate(ssh_ports):
try:
logger.debug(ssh_ip)
logger.debug(ssh_port)
client.connect(hostname=ssh_ip, port=int(ssh_port), username=ssh_user, pkey=mykey, timeout=4)
if cmd is None:
with NamedTemporaryFile(mode='w+') as tmp_key_file:
mykey.write_private_key(tmp_key_file, password=None)
tmp_key_file.flush()
cmd = 'ssh -i %s %s@%s -p %s' % (tmp_key_file.name, ssh_user, ssh_ip, ssh_port)
logger.debug(cmd)
os.system(cmd)
else:
stdin, stdout, stderr = client.exec_command(command=cmd)
out_str = stdout.read()
out_err = stderr.read().strip(' \t\n\r')
print(out_str)
if out_err != '':
print(out_err)
sys.exit(1)
except (ConnectionRefusedError, socket.timeout):
# we will try another tcp port
if count < len(ssh_ports):
continue
else:
raise CourirSshException('connection error')
def turn_off(id):
server = SERVERS.get(id)
if not server:
return server_not_found()
exit_status = -1
ssh_settings = server['ssh']
client = SSHClient()
client.load_system_host_keys()
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(ssh_settings['address'],
username=ssh_settings['username'],
password=ssh_settings['password'])
stdin, stdout, stderr = client.exec_command('shutdown -p now')
#print("stdout: " + str(stdout.readlines()))
#print("stderr: " + str(stderr.readlines()))
exit_status = stdout.channel.recv_exit_status()
print("Shutdown, exit status: %s" % exit_status)
client.close()
return jsonify({"success": exit_status == 0})
class PRISMASSHClient:
def __init__(self, address, user=None, passwd=None):
self.client = SSHClient()
self.client.set_missing_host_key_policy(AutoAddPolicy())
self.client.load_system_host_keys()
if user is None:
self.client.connect(address)
else:
if passwd is not None:
self.client.connect(address, username=user, password=passwd)
else:
self.client.connect(address, username=user)
def close(self):
self.client.close()
def list_from_directory(self, directory):
stdin, stdout, stderr = self.client.exec_command("ls " + directory)
result = stdout.read().splitlines()
return result
def download_file(self, remote_filepath, local_filepath):
sftp = self.client.open_sftp()
sftp.get(remote_filepath, local_filepath)
sftp.close()
def size_of_file(self, remote_filepath):
sftp = self.client.open_sftp()
stat = sftp.stat(remote_filepath)
sftp.close()
return stat.st_size
class MySshClient():
def __init__(self):
self.config = configparser.ConfigParser()
self.filename = os.path.join(os.path.dirname(__file__), args.filename).replace("\\", "/")
self.config.read(self.filename)
self.ssh_client = SSHClient()
self.shell = None
# 此函数用于输入用户名密码登录主机
def ssh_login(self):
try:
# 设置允许连接known_hosts文件中的主机（默认连接不在known_hosts文件中的主机会拒绝连接抛出SSHException）
self.ssh_client.set_missing_host_key_policy(AutoAddPolicy())
self.ssh_client.connect(hostname=self.config.get('ssh', 'host'), port=self.config.get('ssh', 'port'),
username=self.config.get('ssh', 'username'),
password=self.config.get('ssh', 'password'))
except AuthenticationException:
logging.warning('username or password error')
return False
except NoValidConnectionsError:
logging.warning('connect time out')
return False
except:
logging.warning('unknow error')
print("Unexpected error:", sys.exc_info()[0])
return False
return True
# 此函数用于执行command参数中的命令并打印命令执行结果
def execute_some_command(self,command):
try:
stdin, stdout, stderr = self.ssh_client.exec_command(command)
readlines = stdout.readlines()
str1 = stdout.read().decode()
for line in readlines:
print(line)
except Exception as e:
logging.error(str(e))
def multi_run_comment(self, command_list):
if not self.shell:
self.shell = self.ssh_client.invoke_shell()
try:
for cmd in command_list:
print("do cmd", cmd)
self.shell.send(cmd + '\n')
time.sleep(0.8)
recved_buff = self.shell.recv(1024)
print('recved_buff', recved_buff)
except Exception as e:
logging.error(str(e))
# 此函数用于退出登录
def ssh_logout(self):
logging.warning('will exit host')
self.ssh_client.close()
def run_command_on_instances(instances, command, env_file, key_file):
ec2r = boto3.resource('ec2')
ssh = SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for instance in instances['Instances']:
inst_id = instance['InstanceId']
instance_obj = ec2r.Instance(inst_id)
instance_obj.reload()
inst_ip = instance_obj.public_dns_name
sys.stderr.write("Copying env_file.txt to host...\n")
call([
'scp', '-i', key_file, env_file.name,
'ubuntu@%s:/home/ubuntu/env_file.txt' % inst_ip
])
time.sleep(2)
sys.stderr.write("Running command %s on remote host...\n" % (command))
ssh.connect(inst_ip, username='******', key_filename=key_file)
stdin, stdout, stderr = ssh.exec_command(command)
stdin.flush()
output = stdout.read().splitlines()
error = stderr.read().splitlines()
sys.stderr.write(
'Startup standard output\n%s:Startup standard error:\n%s\n' %
(output, error))
ssh.close()
def install_kinto_remotely(id_alwaysdata, credentials, ssh_host,
prefixed_username, status_handler):
logs = StringIO()
# SSH Login
ssh = SSHClient()
ssh.set_missing_host_key_policy(AutoAddPolicy())
ssh.connect(ssh_host,
username=prefixed_username,
password=credentials[1],
look_for_keys=False)
# Install pip
stdin, stdout, stderr = ssh.exec_command(
'PYTHONPATH=~/.local/ easy_install-2.6 --install-dir=~/.local -U pip')
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
# Install virtualenv
stdin, stdout, stderr = ssh.exec_command(
'PYTHONPATH=~/.local/ ~/.local/pip install --user --no-binary --upgrade '
'setuptools virtualenv virtualenvwrapper')
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
# Create virtualenv
stdin, stdout, stderr = ssh.exec_command(
'~/.local/bin/virtualenv kinto/venv/ --python=python2.7')
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
# Install Kinto in the virtualenv
stdin, stdout, stderr = ssh.exec_command(
'kinto/venv/bin/pip install kinto[postgresql] kinto-attachment flup')
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
# Run kinto migration to setup the database.
stdin, stdout, stderr = ssh.exec_command(
'kinto/venv/bin/kinto --ini kinto/kinto.ini migrate')
logs.write(stdout.read())
logs.write(stderr.read())
status_handler.ssh_logs = logs
ssh.close()
def exec_ssh_client_command(self, ssh_client: SSHClient, command: str) -> Tuple[int, bytes, bytes]:
self.log.info("Running command: %s", command)
# set timeout taken as params
stdin, stdout, stderr = ssh_client.exec_command(
command=command,
get_pty=self.get_pty,
timeout=self.timeout,
environment=self.environment,
)
# get channels
channel = stdout.channel
# closing stdin
stdin.close()
channel.shutdown_write()
agg_stdout = b''
agg_stderr = b''
# capture any initial output in case channel is closed already
stdout_buffer_length = len(stdout.channel.in_buffer)
if stdout_buffer_length > 0:
agg_stdout += stdout.channel.recv(stdout_buffer_length)
# read from both stdout and stderr
while not channel.closed or channel.recv_ready() or channel.recv_stderr_ready():
readq, _, _ = select([channel], [], [], self.cmd_timeout)
for recv in readq:
if recv.recv_ready():
line = stdout.channel.recv(len(recv.in_buffer))
agg_stdout += line
self.log.info(line.decode('utf-8', 'replace').strip('\n'))
if recv.recv_stderr_ready():
line = stderr.channel.recv_stderr(len(recv.in_stderr_buffer))
agg_stderr += line
self.log.warning(line.decode('utf-8', 'replace').strip('\n'))
if (
stdout.channel.exit_status_ready()
and not stderr.channel.recv_stderr_ready()
and not stdout.channel.recv_ready()
):
stdout.channel.shutdown_read()
try:
stdout.channel.close()
except Exception:
# there is a race that when shutdown_read has been called and when
# you try to close the connection, the socket is already closed
# We should ignore such errors (but we should log them with warning)
self.log.warning("Ignoring exception on close", exc_info=True)
break
stdout.close()
stderr.close()
exit_status = stdout.channel.recv_exit_status()
return exit_status, agg_stdout, agg_stderr
def setup_ssh_connection(ip, key, user='******', port=22, timeout=10):
"""
Construct an ssh connection to the VM instance.
"""
print "Attempting to setup ssh connection to %s@%s:%d" % (user, ip, port)
if key is None:
raise Exception("setup_ssh_connection: You didn't supply a key!")
try:
if os.getenv("BOCK_TEST_DEBUG", 0) > 0:
paramiko.common.logging.basicConfig(level=paramiko.common.DEBUG)
client = SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(ip, port, user, pkey=key, timeout=timeout)
print "SSH connection successful"
except SSHException as e:
print "Failed to ssh to %s (%s)" % (ip, e)
raise
# Check if this is a new ubuntu cloud image that discourages the use
# of the root account
cmd = "echo YES"
stdin, stdout, stderr = client.exec_command(cmd)
stdout = stdout.readline()
if stdout != "YES\n":
print "Test of ssh connection failed"
print "Got: %s" % stdout
if stdout == 'Please login as the user "ubuntu" rather than the user "root".\n':
print "New style ubuntu image found, using user ubuntu"
client = SSHClient()
client.set_missing_host_key_policy(paramiko.WarningPolicy())
client.connect(ip, port, "ubuntu", pkey=key, timeout=timeout)
print "SSH connection successful"
cmd = "echo YES"
stdin, stdout, stderr = client.exec_command(cmd)
stdout = stdout.readline()
if stdout != "YES\n":
print "Re-test of ssh connection failed"
print "Got: %s" % stdout
raise Exception("SSH connection test failed")
print "SSH connection using user 'ubuntu' successful"
return client
else:
raise Exception("SSH connection test failed")
return client
def setup_ssh_connection(ip, key, user='******', port=22, timeout=10):
"""
Construct an ssh connection to the VM instance.
"""
print "Attempting to setup ssh connection to %s@%s:%d" % (user, ip, port)
if key is None:
raise Exception("setup_ssh_connection: You didn't supply a key!")
try:
if os.getenv("BOCK_TEST_DEBUG", 0) > 0:
paramiko.common.logging.basicConfig(level=paramiko.common.DEBUG)
client = SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(ip, port, user, pkey=key, timeout=timeout)
print "SSH connection successful"
except SSHException as e:
print "Failed to ssh to %s (%s)" % (ip, e)
raise
# Check if this is a new ubuntu cloud image that discourages the use
# of the root account
cmd = "echo YES"
stdin, stdout, stderr = client.exec_command(cmd)
stdout = stdout.readline()
if stdout != "YES\n":
print "Test of ssh connection failed"
print "Got: %s" % stdout
if stdout == 'Please login as the user "ubuntu" rather than the user "root".\n':
print "New style ubuntu image found, using user ubuntu"
client = SSHClient()
client.set_missing_host_key_policy(paramiko.WarningPolicy())
client.connect(ip, port, "ubuntu", pkey=key, timeout=timeout)
print "SSH connection successful"
cmd = "echo YES"
stdin, stdout, stderr = client.exec_command(cmd)
stdout = stdout.readline()
if stdout != "YES\n":
print "Re-test of ssh connection failed"
print "Got: %s" % stdout
raise Exception("SSH connection test failed")
print "SSH connection using user 'ubuntu' successful"
return client
else:
raise Exception("SSH connection test failed")
return client
def timecheck(h):
cmd = "date +%s"
s = SSHClient()
print "> %s" % (h, )
s.set_missing_host_key_policy(AutoAddPolicy())
s.connect(hostname=h[1], username=h[0])
(_in, _out, _err) = s.exec_command(cmd, bufsize=4096)
print "< %s" % (h, )
return (h, _out.read())
def execute_cmd(ip_addr, cmd):
client = SSHClient()
client.load_system_host_keys()
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(ip_addr,
username=dtacq_un,
password=dtacq_pw)
_, aout, aerr = client.exec_command(cmd)
return aout.read(), aerr.read()
def timecheck(h): cmd = "date +%s" s = SSHClient() print "> %s" % (h,) s.set_missing_host_key_policy(AutoAddPolicy()) s.connect(hostname=h[1], username=h[0]) (_in, _out, _err) = s.exec_command( cmd, bufsize=4096) print "< %s" % (h,) return (h,_out.read())
def timecheck(h): cmd = "sudo sysctl -w net.core.somaxconn=16000;" s = SSHClient() print "> %s" % (h,) s.set_missing_host_key_policy(AutoAddPolicy()) s.connect(hostname=h[1], username=h[0])#, password='') (_in, _out, _err) = s.exec_command( cmd, bufsize=4096) print "< %s" % (h,) return (h,_out.read())
def _exec_ssh_cmd(self, cmdline):
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(self.droplet_ip, username='******',
key_filename=self.ssh_key_path)
stdin, stdout, stderr = client.exec_command(cmdline)
for line in stdout:
logging.info(line)
for line in stderr:
logging.info(line)
def _test_server(self, server, floating_ip):
if server.status != 'ACTIVE':
return Skipped()
result = Success()
ip_address = floating_ip.ip_address
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
try:
client.connect(ip_address,
username='******',
timeout=CONF.ssh_timeout)
except Exception as e:
return Failure("Failed to ssh to server.", exception=e)
stdin, stdout, stderr = client.exec_command('hostname -f')
stderr_output = stderr.read()
if stderr_output:
self.log.error('stderr: %r', stderr_output)
remote_hostname = stdout.read().strip().split('.', 1)[0]
expected_hostname = ('sanity-%s' % server.metadata['host_id']).split(
'.', 1)[0]
if remote_hostname != expected_hostname:
return Failure("Hostname mismatch the servers %s hostname is %s" %
(expected_hostname, remote_hostname))
stdin, stdout, stderr = client.exec_command(
'ping -c 5 %s' % self._state.get('external_test_ip', '8.8.8.8'))
stdout = stdout.read().strip()
match = self.ping_re.search(stdout)
if not match:
return Failure("Host has no external connectivity.", output=stdout)
else:
result = match.groupdict()
if int(result['received']) == 0:
return Failure("Host has no external connectivity.",
output=stdout)
else:
return Success(result=result)
return result
def run(self, project):
if not self.vm.start_VM():
return -1, ''
if not os.path.exists(os.path.join(project.tempdir, project.target)):
raise FileNotFoundError('Error: Executable file has not been created!')
copy_to_vm = [os.path.join(project.tempdir, project.target)]
copy_from_vm = ['CUnitAutomated-Results.xml']
print('Connecting to remote machine...')
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
client.load_system_host_keys()
client.connect(self.host, username=self.username, password=self.password, timeout=10)
return_code = 0
data = ''
with client.open_sftp() as sftp:
try:
self.rmtree(sftp, self.remote_path)
except FileNotFoundError:
pass
try:
sftp.mkdir(self.remote_path)
except OSError:
pass
for f in copy_to_vm:
remote_file = os.path.join(self.remote_path, os.path.basename(f))
sftp.put(f, remote_file)
sftp.chmod(remote_file, 0o777)
stdin, stdout, stderr = client.exec_command('cd {}; timeout {}s {}'.format(self.remote_path, self.timeout, remote_file))
return_code = stdout.channel.recv_exit_status()
print('[Remote] Error code: {}'.format(return_code))
stdout_string = '[Remote] ' + ''.join(stdout)
if stdout_string:
print('[Remote] STDOUT:')
print(stdout_string)
stderr_string = '[Remote] ' + ''.join(stderr)
if stderr_string:
print('[Remote] STDERR:')
print(stderr_string)
for f in copy_from_vm:
# get all result files
remote_file = os.path.join(self.remote_path, os.path.basename(f))
try:
with tempfile.TemporaryFile() as local_file:
sftp.getfo(remote_file, local_file)
local_file.seek(0)
data = local_file.read()
except FileNotFoundError:
print('Remote file not found!')
# delete all files in home directory
self.rmtree(sftp, self.remote_path)
client.close()
if self.shutdown_vm_after:
self.vm.stop_VM()
return return_code, data
def connect_to_ssh(addy):
username = input("Username: ")
password = getpass.getpass()
''' do a session and get info'''
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy)
client.connect(str(addy), 22, username=username, password=password)
output = client.exec_command('show configuration|no-more')
config = output[1].readlines()
#Works for juniper... don't print it, save to file after diff
compare_config(config, addy)
def _exec_ssh_cmd(self, cmdline):
pkey_buf = StringIO(self.state.pkey)
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(self.droplet_ip, username='******',
pkey=RSAKey.from_private_key(pkey_buf))
stdin, stdout, stderr = client.exec_command(cmdline)
for line in stdout:
logging.info(line)
for line in stderr:
logging.info(line)
def keystone_project_list(self):
'''
command: openstack project list, keystone tenant-list(deprecated)
'''
client = SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(env['OS_SSH_HOST'], username=env['OS_SSH_USERNAME'], password=env['OS_SSH_PASSWORD'])
stdin, stdout, stderr = client.exec_command('source /etc/nova/openrc && openstack project list --long')
output = stdout.read()
self.project_list = re.findall('(\w{32})\s+\|\s+([\w-]+)\s+\|\s+[\w\t]*\s+\|\s+(True|False)\s+\|', output)
client.close()
def neutront_floating_ip_list(self):
'''
command: neutron floatingip-list [--show-details], neutron floatingip-show FLOATINGIP_ID
'''
client = SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(env['OS_SSH_HOST'], username=env['OS_SSH_USERNAME'], password=env['OS_SSH_PASSWORD'])
stdin, stdout, stderr = client.exec_command('source /etc/nova/openrc && neutron floatingip-list')
output = stdout.read()
self.floating_ips = re.findall('([\w-]+)\s+\|\s+([\d.]+)\s+\|\s+([\d.]+)\s+\|\s+([\w-]+)', output)
client.close()
def _exec_ssh_cmd(self, cmdline):
pkey_buf = StringIO(self.state.pkey)
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(self.droplet_ip,
username='******',
pkey=RSAKey.from_private_key(pkey_buf))
stdin, stdout, stderr = client.exec_command(cmdline)
for line in stdout:
logging.info(line)
for line in stderr:
logging.info(line)
def recvr(h):
s = SSHClient()
print "> %s" % (h, )
s.set_missing_host_key_policy(AutoAddPolicy())
s.connect(hostname=h[1], username=h[0])
(_in, _out, _err) = s.exec_command(client_cmd, bufsize=4096)
_in.write(bytecode)
_in.flush()
print "< %s" % (h, )
err = _err.read()
if (err):
print err
return (h, _out.read())
class SSHOps:
def __init__(self):
self.client = SSHClient()
self.client.load_system_host_keys()
self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.client.connect("192.168.0.2", username='******', password='******')
def runCommand(self, comando):
stdin, stdout, stderr = self.client.exec_command(comando)
if stderr.channel.recv_exit_status() != 0:
return {"status": 1, "message": stderr.read()}
else:
return {"status": 0, "message": stdout.read()}
def recvr(h): s = SSHClient() print "> %s" % (h,) s.set_missing_host_key_policy(AutoAddPolicy()) s.connect(hostname=h[1], username=h[0]) (_in, _out, _err) = s.exec_command(client_cmd, bufsize=4096) _in.write(bytecode) _in.flush() print "< %s" % (h,) err = _err.read() if(err): print err return (h,_out.read())
def add_public_key(hostname, port, password):
ssh_client = SSHClient()
ssh_client.set_missing_host_key_policy(AutoAddPolicy)
ssh_client.connect(hostname, port=port, username='******', password=password)
try:
_, stdout, stderr = ssh_client.exec_command(
'mkdir -p -m 700 /root/.ssh && \
echo %r >> /root/.ssh/authorized_keys && \
chmod 600 /root/.ssh/authorized_keys' % Setting.ssh_public_key)
if stdout.channel.recv_exit_status() != 0:
raise Exception('Add public key error: ' +
''.join(x for x in stderr))
finally:
ssh_client.close()
def get_bmc_ip(self):
try:
client = SSHClient()
client.set_missing_host_key_policy(IgnoreHostKeyPolicy)
client.connect(
self._wedge_local_addr,
username=self.username,
password=self.password,
)
_, stdout, _ = client.exec_command("ip -o -4 addr show",
timeout=60)
return (stdout.read().decode().splitlines()[1].split()[3].split(
"/")[0])
except Exception:
return None
def configure_cfme(ipaddr, ssh_username, ssh_password, region, db_password):
cmd = "appliance_console_cli --region %s --internal --force-key -p %s" % (region, db_password)
client = SSHClient()
try:
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(ipaddr, username=ssh_username, password=ssh_password, allow_agent=False)
print "Will run below command on host: %s" % (ipaddr)
print cmd
stdin, stdout, stderr = client.exec_command(cmd)
status = stdout.channel.recv_exit_status()
out = stdout.readlines()
err = stderr.readlines()
return status, out, err
finally:
client.close()
class SshOps:
def __init__(self):
self.client = SSHClient()
self.client.load_system_host_keys()
self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
config = ConfigParser.ConfigParser()
config.read("/home/forlinux/www/4803-Python/ProjetoDexter/config.cfg")
self.client.connect(config.get("docker","address"))
def runCommand(self,command):
stdin,stdout,stderr = self.client.exec_command(command)
if stderr.channel.recv_exit_status() != 0:
return {"status":1,"message":stderr.read()}
else:
return {"status":0,"message":stdout.read()}
def executar_comando_remoto(com):
hosts = ["192.168.0.2"]
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for h in hosts:
try:
ssh.connect(h)
stdin,stdout,stderr = ssh.exec_command(com)
if stderr.channel.recv_exit_status() != 0:
print stderr.read()
else:
print stdout.read()
except Exception as e:
print "Nao conseguiu conectar ao servidor %s"%e
class SshOps:
def __init__(self):
self.ssh = SSHClient()
self.ssh.load_system_host_keys()
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.ssh.connect(hostname='127.0.0.1',
username='******',
password='******')
def runCommand(self, command):
stdin, stdout, stderr = self.ssh.exec_command(command)
if stderr.channel.recv_exit_status() != 0:
return {"status": 1, "message": stderr.read()}
else:
return {"status": 0, "message": stdout.read()}
def stop_instance(instance):
try:
stop_script_location = instance.tags['stop_script']
except KeyError:
stop_script_location = '~/shutdown.sh'
client = SSHClient()
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.load_system_host_keys()
client.connect(instance.ip_address, username="******")
stdin, stdout, stderr = client.exec_command('%s "%s" "%s"' % (stop_script_location, app.config["API_KEY"], app.config["MY_URL"] + "/api/v1/stats"))
try:
for s in [stdin, stdout, stderr]:
app.logger.info(s.read())
except IOError:
pass
client.close()
def executar_comando(servidor,senha):
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
ssh.connect("localhost",username="******",password=senha)
stdin, stdout, stderr = ssh.exec_command("ls -la")
if stderr.channel_recv_exit_status() != 0:
print stderr.read()
else:
print stdout.read()
except Exception as e:
print "A conexao falhou"
def executar_comando(usuario, senha):
ssh = SSHClient()
ssh.load_system_host_keys()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
ssh.connect('localhost', username =usuario, password=senha)
stdin, stdout, stderr = ssh.exec_command('ls -la')
if stderr.channel.recv_exit_status() != 0:
print stderr.read()
else:
print stdout.read()
except Exception as e:
print 'Falhou ao conectar: ', e
def _exec_command(command, switch_name=''):
if not switch_name:
switch_name = [s for s in current_app.config['switches']][0]
current_app.logger.info('running on %s: %s' % (switch_name, command))
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(current_app.config['switches'][switch_name]['address'],
username=current_app.config['switches'][switch_name]['user'],
key_filename=current_app.config['switches'][switch_name]['key'])
sin, sout, serr = client.exec_command(command)
output = sout.read().decode('ascii')
errout = serr.read().decode('ascii')
client.close()
if errout or 'Cmd exec error' in output:
abort(500, "Error executing '%s' on %s" % (command, switch_name))
current_app.logger.info('output from %s: %s' % (switch_name, output))
return output, errout
class SSH:
def __init__(self):
self.servidor = "192.168.0.2"
self.ssh = SSHClient()
self.ssh.load_system_host_keys()
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
self.ssh.connect(self.servidor)
def executarComandoRemoto(self,com):
try:
stdin,stdout,stderr = self.ssh.exec_command(com)
if stderr.channel.recv_exit_status() != 0:
return stderr.read()
else:
return stdout.read()
except Exception as e:
print "Nao conseguiu conectar ao servidor %s"%e
def configure_secondary_cfme(ipaddr, primary_ip, ssh_username, ssh_password, db_password):
cmd = "appliance_console_cli --hostname %s --dbname vmdb_production" \
"--fetch-key %s --username root --password %s --sshpassword %s" \
% (primary_ip, primary_ip, db_password, ssh_password)
client = SSHClient()
try:
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(ipaddr, username=ssh_username, password=ssh_password, allow_agent=False)
print "Will run below command on host: '%s'" % (ipaddr)
print cmd
stdin, stdout, stderr = client.exec_command(cmd)
status = stdout.channel.recv_exit_status()
out = stdout.readlines()
err = stderr.readlines()
return status, out, err
finally:
client.close()
def run_command(address, command):
connection = SSHClient()
connection.set_missing_host_key_policy(AutoAddPolicy())
while True:
try:
keys = ['~/.ssh/stage', '~/.ssh/prod']
keys = [os.path.expanduser(key) for key in keys]
connection.connect(address, username='******',
key_filename=keys)
break
except Exception:
log.warn('Unable to establish an SSH connection')
log.debug('Retrying in 10 seconds')
time.sleep(10)
log.debug('Established an SSH connection')
log.debug('Running {command} on {address}'.format(command=command,
address=address))
stdin, stdout, stderr = connection.exec_command(command)
try:
stdin = stdin.read()
except IOError:
stdin = None
try:
stdout = stdout.read()
except IOError:
stdout = None
try:
stderr = stderr.read()
except IOError:
stderr = None
log.debug('STDIN: {stdin}'.format(stdin = stdin))
log.debug('STDOUT: {stdout}'.format(stdout = stdout))
log.debug('STDERR: {stderr}'.format(stderr = stderr))
return stdout
def connect(self, instance, tag_ssh_user, tag_ssh_port, cmd):
"""
execute a command on instance with ssh and return if cmd param is not None
connect to ssh if cmd is None
:param instance:
:param tag_ssh_user:
:param tag_ssh_port:
:param cmd: execute this command if not None
:return:
"""
ssh_user = SergentSsh.get_ssh_user(instance, tag_ssh_user)
ssh_port = SergentSsh.get_ssh_port(instance, tag_ssh_port)
if self._using_vpn is True:
ssh_ip = instance.private_ip_address
else:
ssh_ip = instance.ip_address
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
logger.debug('connecting to %s with port %s and user %s', ssh_ip, ssh_port, ssh_user)
mykey = RSAKey.from_private_key(self._key_file)
client.connect(hostname=ssh_ip, port=ssh_port, username=ssh_user, pkey=mykey)
if cmd is None:
with NamedTemporaryFile(mode='w+') as tmp_key_file:
mykey.write_private_key(tmp_key_file, password=None)
tmp_key_file.flush()
cmd = 'ssh -i %s %s@%s -p %s' % (tmp_key_file.name, ssh_user, ssh_ip, ssh_port)
logger.debug(cmd)
os.system(cmd)
else:
stdin, stdout, stderr = client.exec_command(command=cmd)
out_str = stdout.read()
out_err = stderr.read().strip(' \t\n\r')
print(out_str)
if out_err != '':
print(out_err)
sys.exit(1)
#!/usr/bin/python
from task_constants import *
from paramiko.client import SSHClient
client = SSHClient()
client.load_system_host_keys()
client.connect(hostname = opt_server,
username = opt_username,
key_filename = opt_keyfile)
output = client.exec_command('ls')
print output
from scp import SCPClient
scp = SCPClient(client.get_transport())
scp.put("ssh.py", "ssh.py")
scp.put("scp.py", "scp.py")
print client.exec_command('md5sum ssh.py scp.py')
client.close()
"""
The UUID of a task will serve as the filename for all the files associated with the task.
As well as the handle for marking/handling the task.
A task has these states
- TODO (we should verify that the file has been generated, if not, alert)
copy the file on WEB01 to OPT01
mark the task as GOING_TO_RUN
submit the job as qsub (a shell script with param)
(qsub should be able to mark something as READY_TO_MAIL
from paramiko.client import SSHClient
from paramiko.client import AutoAddPolicy
client=SSHClient()
autoAddpolicy=AutoAddPolicy()
client.set_missing_host_key_policy(autoAddpolicy)
client.load_system_host_keys()
hosts=['192.168.100.5','192.168.100.2','192.168.100.3','192.168.100.4','192.168.100.6']
for host in hosts:
client.connect(host,port=22,username='******',password='******',look_for_keys=False, allow_agent=False)
stdin, stdout, stderr = client.exec_command('launcher stop')
#!/usr/bin/python
from paramiko.client import SSHClient
import paramiko
from datetime import datetime
hosts = ["192.168.1.10","192.168.1.106","192.168.1.100"]
ssh = SSHClient()
# ler as chaves
ssh.load_system_host_keys()
# se eh um server que nao conheco fazer add
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for h in hosts:
try:
print "Conectando no servidor %s na data %s"%(h,datetime.now())
ssh.connect(h)
stdin,stdout,stderr = ssh.exec_command('w')
if stderr.channel.recv_exit_status() != 0:
print stderr.read()
else:
print stdout.read()
print "Saindo do servidor %s na data %s"%(h,datetime.now())
except Exception as e:
print "Nao conseguiu conectar ao servidor: %s"%e
#!/usr/bin/python
from paramiko.client import SSHClient
import paramiko
ssh = SSHClient()
# ler as chaves
ssh.load_system_host_keys()
# se eh um server que nao conheco fazer add
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect("192.168.1.106")
stdin,stdout,stderr = ssh.exec_command('ls -la')
if stderr.channel.recv_exit_status() != 0:
print stderr.read()
else:
print stdout.read()
gen = generators[ext]
except KeyError:
_die("Generator for extension %s not found!" % ext)
with open(name, 'w') as f:
f.write(gen(conf))
sys.exit(0)
elif arg == "install":
from paramiko.client import SSHClient
assert len(sys.argv) != 4, "Invalid number of args!"
local, remote = sys.argv[2:3]
assert os.path.isfile(local), "%s must be readable file!" % local
client = SSHClient()
sftp = None
try:
client.connect(**ssh_conf)
client.exec_command(ACQUIRE_COMMAND)
sftp = client.open_sftp()
sftp.chdir(ROOT_DIR)
sftp.put(local, '.' + remote)
finally:
if sftp is not None:
sftp.close()
client.exec_command(RELEASE_COMMAND)
client.close()
else:
_die("Unknown command: %s" % arg)
def ssh(hostname, username, password, cmd):
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(hostname, username=username, password=password, timeout=3)
stdin, stdout, stderr = client.exec_command(cmd)
return stdin, stdout, stderr
from paramiko.client import SSHClient
from paramiko.client import AutoAddPolicy
client=SSHClient()
autoAddpolicy=AutoAddPolicy()
client.set_missing_host_key_policy(autoAddpolicy)
client.load_system_host_keys()
hosts=['192.168.100.2','192.168.100.3','192.168.100.4','192.168.100.6']
for host in hosts:
client.connect(host,port=22,username='******',password='******',look_for_keys=False, allow_agent=False)
stdin, stdout, stderr = client.exec_command('su cassandra -l -c "/opt/cassandra/bin/cassandra"')
# -*- coding:utf-8 -*-
# BEFORE START!!!!!!
# Create file named "config.py"
# set there the HOST_NAME, USER_NAME and PASSWORD variables
import config
from paramiko import AutoAddPolicy
from paramiko.client import SSHClient
client = SSHClient()
client.set_missing_host_key_policy(AutoAddPolicy())
client.connect(hostname=config.HOST_NAME, username=config.USER_NAME, password=config.PASSWORD)
# Передача файлов
sftp = client.open_sftp()
if sftp:
sftp.put('hw.txt', '~')
stdin, stdout, stderr = client.exec_command('pkill -u u48649 -f django-wrapper.fcgi')
for line in stdout:
print line.strip('\n')
client.close()
