def test_check_ssh_injection(self):
cmd_list = ['ssh', '-D', 'my_name@name_of_remote_computer']
self.assertIsNone(utils.check_ssh_injection(cmd_list))
cmd_list = ['echo', '"quoted arg with space"']
self.assertIsNone(utils.check_ssh_injection(cmd_list))
cmd_list = ['echo', "'quoted arg with space'"]
self.assertIsNone(utils.check_ssh_injection(cmd_list))
def _run_ssh(self, cmd_list, check_exit=True, attempts=1):
utils.check_ssh_injection(cmd_list)
command = ' '. join(cmd_list)
if not self.sshpool:
self.sshpool = utils.SSHPool(self.config.san_ip,
self.config.san_ssh_port,
self.config.ssh_conn_timeout,
self.config.san_login,
password=self.config.san_password,
privatekey=
self.config.san_private_key,
min_size=
self.config.ssh_min_pool_conn,
max_size=
self.config.ssh_max_pool_conn)
try:
total_attempts = attempts
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
return self._ssh_execute(ssh, command,
check_exit_code=check_exit)
except Exception as e:
LOG.error(e)
greenthread.sleep(randint(20, 500) / 100.0)
msg = (_("SSH Command failed after '%(total_attempts)r' "
"attempts : '%(command)s'") %
{'total_attempts': total_attempts, 'command': command})
raise paramiko.SSHException(msg)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error(_("Error running ssh command: %s") % command)
def test_check_ssh_injection(self):
cmd_list = ['ssh', '-D', 'my_name@name_of_remote_computer']
self.assertIsNone(utils.check_ssh_injection(cmd_list))
cmd_list = ['echo', '"quoted arg with space"']
self.assertIsNone(utils.check_ssh_injection(cmd_list))
cmd_list = ['echo', "'quoted arg with space'"]
self.assertIsNone(utils.check_ssh_injection(cmd_list))
def test_check_ssh_injection(self):
cmd_list = ["ssh", "-D", "my_name@name_of_remote_computer"]
self.assertIsNone(utils.check_ssh_injection(cmd_list))
cmd_list = ["echo", '"quoted arg with space"']
self.assertIsNone(utils.check_ssh_injection(cmd_list))
cmd_list = ["echo", "'quoted arg with space'"]
self.assertIsNone(utils.check_ssh_injection(cmd_list))
def _run_ssh(self, cmd_list, check_exit=True, attempts=1):
utils.check_ssh_injection(cmd_list)
command = ' '.join(cmd_list)
if not self.sshpool:
self.sshpool = utils.SSHPool(
self.config.san_ip,
self.config.san_ssh_port,
self.config.ssh_conn_timeout,
self.config.san_login,
password=self.config.san_password,
privatekey=self.config.san_private_key,
min_size=self.config.ssh_min_pool_conn,
max_size=self.config.ssh_max_pool_conn)
try:
total_attempts = attempts
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
return self._ssh_execute(ssh,
command,
check_exit_code=check_exit)
except Exception as e:
LOG.error(e)
greenthread.sleep(randint(20, 500) / 100.0)
msg = (_("SSH Command failed after '%(total_attempts)r' "
"attempts : '%(command)s'") % {
'total_attempts': total_attempts,
'command': command
})
raise paramiko.SSHException(msg)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error(_("Error running ssh command: %s") % command)
def _execute_shell_cmd(self, cmd):
"""Run command over shell for older firmware versions.
Invokes shell and issue the command and return the output.
This is primarily used for issuing read commands when we are not sure
if the firmware supports exec_command.
"""
utils.check_ssh_injection(cmd)
command = " ".join(cmd)
stdout, stderr = None, None
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(
self.switch_ip,
self.switch_port,
None,
self.switch_user,
self.switch_pwd,
self.switch_key,
min_size=1,
max_size=5,
)
with self.sshpool.item() as ssh:
LOG.debug("Running cmd (SSH): %s", command)
channel = ssh.invoke_shell()
stdin_stream = channel.makefile("wb")
stdout_stream = channel.makefile("rb")
stderr_stream = channel.makefile("rb")
stdin_stream.write(
"""%s
exit
"""
% command
)
stdin_stream.flush()
stdout = stdout_stream.readlines()
stderr = stderr_stream.readlines()
stdin_stream.close()
stdout_stream.close()
stderr_stream.close()
exit_status = channel.recv_exit_status()
# exit_status == -1 if no exit code was returned
if exit_status != -1:
LOG.debug("Result was %s", exit_status)
if exit_status != 0:
LOG.debug("command %s failed", command)
raise processutils.ProcessExecutionError(
exit_code=exit_status, stdout=stdout, stderr=stderr, cmd=command
)
try:
channel.close()
except Exception:
LOG.exception(_LE("Error closing channel."))
LOG.debug("_execute_cmd: stdout to return: %s", stdout)
LOG.debug("_execute_cmd: stderr to return: %s", stderr)
return (stdout, stderr)
def _run_ssh(self, cmd_list, check_exit_code=True):
cinder_utils.check_ssh_injection(cmd_list)
command = ' '.join(cmd_list)
if not self.sshpool:
try:
self.sshpool = self._set_up_sshpool(self.configuration.san_ip)
except paramiko.SSHException as e:
raise exception.VolumeDriverException(message=e)
ssh_execute = self._ssh_execute(self.sshpool, command, check_exit_code)
return ssh_execute
def run_cmd(self, cmd, ip0, user, pw, *args, **kwargs):
"""Run a command on SMU or using SSH
:param cmd: the command that will be run on SMU
:param ip0: string IP address of controller
:param user: string user authentication for array
:param pw: string password authentication for array
:returns: formated string with version information
"""
LOG.debug('Enable ssh: %s',
six.text_type(self.drv_configs['ssh_enabled']))
if self.drv_configs['ssh_enabled'] != 'True':
# Direct connection via ssc
args = (cmd, '-u', user, '-p', pw, ip0) + args
out, err = utils.execute(*args, **kwargs)
LOG.debug("command %(cmd)s result: out = %(out)s - err = "
"%(err)s", {'cmd': cmd, 'out': out, 'err': err})
return out, err
else:
if self.drv_configs['cluster_admin_ip0'] is None:
# Connect to SMU through SSH and run ssc locally
args = (cmd, 'localhost') + args
else:
args = (cmd, '--smuauth',
self.drv_configs['cluster_admin_ip0']) + args
utils.check_ssh_injection(args)
command = ' '.join(args)
command = command.replace('"', '\\"')
if not self.sshpool:
server = self.drv_configs['mgmt_ip0']
port = int(self.drv_configs['ssh_port'])
username = self.drv_configs['username']
# We only accept private/public key auth
password = ""
privatekey = self.drv_configs['ssh_private_key']
self.sshpool = ssh_utils.SSHPool(server,
port,
None,
username,
password=password,
privatekey=privatekey)
with self.sshpool.item() as ssh:
try:
out, err = processutils.ssh_execute(ssh, command,
check_exit_code=True)
LOG.debug("command %(cmd)s result: out = %(out)s - err = "
"%(err)s", {'cmd': cmd, 'out': out, 'err': err})
return out, err
except processutils.ProcessExecutionError:
LOG.error(_LE("Error running SSH command."))
raise
def run_cmd(self, cmd, ip0, user, pw, *args, **kwargs):
"""Run a command on SMU or using SSH
:param cmd: the command that will be run on SMU
:param ip0: string IP address of controller
:param user: string user authentication for array
:param pw: string password authentication for array
:returns: formated string with version information
"""
LOG.debug('Enable ssh: %s',
six.text_type(self.drv_configs['ssh_enabled']))
if self.drv_configs['ssh_enabled'] != 'True':
# Direct connection via ssc
args = (cmd, '-u', user, '-p', pw, ip0) + args
out, err = utils.execute(*args, **kwargs)
LOG.debug("command %(cmd)s result: out = %(out)s - err = "
"%(err)s", {'cmd': cmd, 'out': out, 'err': err})
return out, err
else:
if self.drv_configs['cluster_admin_ip0'] is None:
# Connect to SMU through SSH and run ssc locally
args = (cmd, 'localhost') + args
else:
args = (cmd, '--smuauth',
self.drv_configs['cluster_admin_ip0']) + args
utils.check_ssh_injection(args)
command = ' '.join(args)
command = command.replace('"', '\\"')
if not self.sshpool:
server = self.drv_configs['mgmt_ip0']
port = int(self.drv_configs['ssh_port'])
username = self.drv_configs['username']
# We only accept private/public key auth
password = ""
privatekey = self.drv_configs['ssh_private_key']
self.sshpool = ssh_utils.SSHPool(server,
port,
None,
username,
password=password,
privatekey=privatekey)
with self.sshpool.item() as ssh:
try:
out, err = processutils.ssh_execute(ssh, command,
check_exit_code=True)
LOG.debug("command %(cmd)s result: out = %(out)s - err = "
"%(err)s", {'cmd': cmd, 'out': out, 'err': err})
return out, err
except processutils.ProcessExecutionError:
LOG.error(_LE("Error running SSH command."))
raise
def _execute_shell_cmd(self, cmd):
"""Run command over shell for older firmware versions.
Invokes shell and issue the command and return the output.
This is primarily used for issuing read commands when we are not sure
if the firmware supports exec_command.
"""
utils.check_ssh_injection(cmd)
command = ' '.join(cmd)
stdout, stderr = None, None
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(self.switch_ip,
self.switch_port,
None,
self.switch_user,
self.switch_pwd,
self.switch_key,
min_size=1,
max_size=5)
with self.sshpool.item() as ssh:
LOG.debug('Running cmd (SSH): %s', command)
channel = ssh.invoke_shell()
stdin_stream = channel.makefile('wb')
stdout_stream = channel.makefile('rb')
stderr_stream = channel.makefile('rb')
stdin_stream.write('''%s
exit
''' % command)
stdin_stream.flush()
stdout = stdout_stream.readlines()
stderr = stderr_stream.readlines()
stdin_stream.close()
stdout_stream.close()
stderr_stream.close()
exit_status = channel.recv_exit_status()
# exit_status == -1 if no exit code was returned
if exit_status != -1:
LOG.debug('Result was %s', exit_status)
if exit_status != 0:
LOG.debug("command %s failed", command)
raise processutils.ProcessExecutionError(
exit_code=exit_status,
stdout=stdout,
stderr=stderr,
cmd=command)
try:
channel.close()
except Exception:
LOG.exception('Error closing channel.')
LOG.debug("_execute_cmd: stdout to return: %s", stdout)
LOG.debug("_execute_cmd: stderr to return: %s", stderr)
return (stdout, stderr)
def _get_switch_data(self, ssh_pool, cmd):
utils.check_ssh_injection([cmd])
with ssh_pool.item() as ssh:
try:
switch_data, err = processutils.ssh_execute(ssh, cmd)
except processutils.ProcessExecutionError as e:
msg = (_("SSH Command failed with error: '%(err)s', Command: "
"'%(command)s'") % {'err': six.text_type(e),
'command': cmd})
LOG.error(msg)
raise exception.FCSanLookupServiceException(message=msg)
return switch_data
def _ssh(self, cmd, check_exit_code=True):
try:
LOG.debug('Run CLI command: %s' % cmd)
utils.check_ssh_injection(cmd)
ret = self.fake_storage.execute_command(cmd, check_exit_code)
(stdout, stderr) = ret
LOG.debug('CLI output:\n stdout: %(stdout)s\n stderr: '
'%(stderr)s' % {'stdout': stdout, 'stderr': stderr})
except processutils.ProcessExecutionError as e:
with excutils.save_and_reraise_exception():
LOG.debug('CLI Exception output:\n stdout: %(out)s\n '
'stderr: %(err)s' % {'out': e.stdout,
'err': e.stderr})
return ret
def _ssh(self, cmd, check_exit_code=True):
try:
LOG.debug('Run CLI command: %s' % cmd)
utils.check_ssh_injection(cmd)
ret = self.fake_storage.execute_command(cmd, check_exit_code)
(stdout, stderr) = ret
LOG.debug('CLI output:\n stdout: %(stdout)s\n stderr: '
'%(stderr)s' % {'stdout': stdout, 'stderr': stderr})
except processutils.ProcessExecutionError as e:
with excutils.save_and_reraise_exception():
LOG.debug('CLI Exception output:\n stdout: %(out)s\n '
'stderr: %(err)s' % {'out': e.stdout,
'err': e.stderr})
return ret
def _run_ssh(self, cmd_list, check_exit_code=True, attempts=1):
utils.check_ssh_injection(cmd_list)
command = ' '. join(cmd_list)
if not self.sshpool:
password = self.configuration.san_password
privatekey = self.configuration.san_private_key
min_size = self.configuration.ssh_min_pool_conn
max_size = self.configuration.ssh_max_pool_conn
self.sshpool = ssh_utils.SSHPool(
self.configuration.san_ip,
self.configuration.san_ssh_port,
self.configuration.ssh_conn_timeout,
self.configuration.san_login,
password=password,
privatekey=privatekey,
min_size=min_size,
max_size=max_size)
last_exception = None
try:
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
return processutils.ssh_execute(
ssh,
command,
check_exit_code=check_exit_code)
except Exception as e:
LOG.error(e)
last_exception = e
greenthread.sleep(random.randint(20, 500) / 100.0)
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1,
stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error("Error running SSH command: %s", command)
def _run_ssh(self, cmd_list, check_exit_code=True, attempts=1):
utils.check_ssh_injection(cmd_list)
command = ' '. join(cmd_list)
if not self.sshpool:
password = self.configuration.san_password
privatekey = self.configuration.san_private_key
min_size = self.configuration.ssh_min_pool_conn
max_size = self.configuration.ssh_max_pool_conn
self.sshpool = ssh_utils.SSHPool(
self.configuration.san_ip,
self.configuration.san_ssh_port,
self.configuration.ssh_conn_timeout,
self.configuration.san_login,
password=password,
privatekey=privatekey,
min_size=min_size,
max_size=max_size)
last_exception = None
try:
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
return processutils.ssh_execute(
ssh,
command,
check_exit_code=check_exit_code)
except Exception as e:
LOG.error(e)
last_exception = e
greenthread.sleep(random.randint(20, 500) / 100.0)
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1,
stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error("Error running SSH command: %s", command)
def _get_switch_data(self, ssh_pool, cmd):
utils.check_ssh_injection([cmd])
with ssh_pool.item() as ssh:
try:
switch_data, err = processutils.ssh_execute(ssh, cmd)
except processutils.ProcessExecutionError as e:
msg = (_("SSH Command failed with error: '%(err)s', Command: "
"'%(command)s'") % {
'err': six.text_type(e),
'command': cmd
})
LOG.error(msg)
raise exception.FCSanLookupServiceException(message=msg)
return switch_data
def _run_cmd(self, *args, **kwargs):
"""Runs a command on SMU using SSH.
:returns: stdout and stderr of the command
"""
if self.cluster_admin_ip0 is None:
# Connect to SMU through SSH and run ssc locally
args = (self.hnas_cmd, 'localhost') + args
else:
args = (self.hnas_cmd, '--smuauth', self.cluster_admin_ip0) + args
utils.check_ssh_injection(args)
command = ' '.join(args)
command = command.replace('"', '\\"')
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(ip=self.mgmt_ip0,
port=int(self.ssh_port),
conn_timeout=None,
login=self.ssh_username,
password=self.ssh_pwd,
privatekey=self.ssh_private_key)
with self.sshpool.item() as ssh:
try:
out, err = putils.ssh_execute(ssh,
command,
check_exit_code=True)
LOG.debug(
"command %(cmd)s result: out = "
"%(out)s - err = %(err)s", {
'cmd': self.hnas_cmd,
'out': out,
'err': err
})
return out, err
except putils.ProcessExecutionError as e:
if 'Failed to establish SSC connection' in e.stderr:
msg = _("Failed to establish SSC connection!")
LOG.exception(msg)
raise exception.HNASConnError(msg)
elif 'Connection reset' in e.stderr:
msg = _("HNAS connection reset!")
LOG.exception(msg)
raise exception.HNASConnError(msg)
else:
raise
def _run_ssh(self, cmd_list, check_exit_code=True, attempts=1):
utils.check_ssh_injection(cmd_list)
# TODO(vhou): We'll have a common method in ssh_utils to take
# care of this _run_ssh method.
command = ' '.join(cmd_list)
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(
self.target.get('san_ip'),
self.target.get('san_ssh_port', 22),
self.target.get('ssh_conn_timeout', 30),
self.target.get('san_login'),
password=self.target.get('san_password'),
privatekey=self.target.get('san_private_key', ''),
min_size=self.target.get('ssh_min_pool_conn', 1),
max_size=self.target.get('ssh_max_pool_conn', 5),
)
last_exception = None
try:
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
return processutils.ssh_execute(
ssh, command, check_exit_code=check_exit_code)
except Exception as e:
LOG.error(six.text_type(e))
last_exception = e
greenthread.sleep(random.randint(20, 500) / 100.0)
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1,
stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error(_LE("Error running SSH command: %s"), command)
def _run_ssh(self, cmd_list, attempts=1):
utils.check_ssh_injection(cmd_list)
command = ' '.join(cmd_list)
if not self.sshpool:
password = self.configuration.san_password
privatekey = self.configuration.san_private_key
min_size = self.configuration.ssh_min_pool_conn
max_size = self.configuration.ssh_max_pool_conn
self.sshpool = ssh_utils.SSHPool(
self.configuration.san_ip,
self.configuration.san_ssh_port,
self.configuration.ssh_conn_timeout,
self.configuration.san_login,
password=password,
privatekey=privatekey,
min_size=min_size,
max_size=max_size)
try:
total_attempts = attempts
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
LOG.info(_('EQL-driver: executing "%s"') % command)
return self._ssh_execute(
ssh,
command,
timeout=self.configuration.eqlx_cli_timeout)
except processutils.ProcessExecutionError:
raise
except Exception as e:
LOG.exception(e)
greenthread.sleep(random.randint(20, 500) / 100.0)
msg = (_("SSH Command failed after '%(total_attempts)r' "
"attempts : '%(command)s'") % {
'total_attempts': total_attempts,
'command': command
})
raise exception.VolumeBackendAPIException(data=msg)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error(_("Error running SSH command: %s") % command)
def _get_switch_data(self, cmd):
stdin, stdout, stderr = None, None, None
utils.check_ssh_injection([cmd])
try:
stdin, stdout, stderr = self.client.exec_command(cmd)
switch_data = stdout.readlines()
except paramiko.SSHException as e:
msg = _("SSH Command failed with error '%(err)s' " "'%(command)s'") % {"err": e, "command": cmd}
LOG.error(msg)
raise exception.FCSanLookupServiceException(message=msg)
finally:
if stdin:
stdin.flush()
stdin.close()
if stdout:
stdout.close()
if stderr:
stderr.close()
return switch_data
def _run_ssh(self, cmd_list, check_exit_code=True, attempts=1):
utils.check_ssh_injection(cmd_list)
# TODO(vhou): We'll have a common method in ssh_utils to take
# care of this _run_ssh method.
command = ' '. join(cmd_list)
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(
self.target.get('san_ip'),
self.target.get('san_ssh_port', 22),
self.target.get('ssh_conn_timeout', 30),
self.target.get('san_login'),
password=self.target.get('san_password'),
privatekey=self.target.get('san_private_key', ''),
min_size=self.target.get('ssh_min_pool_conn', 1),
max_size=self.target.get('ssh_max_pool_conn', 5),)
last_exception = None
try:
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
return processutils.ssh_execute(
ssh, command, check_exit_code=check_exit_code)
except Exception as e:
LOG.error(six.text_type(e))
last_exception = e
greenthread.sleep(random.randint(20, 500) / 100.0)
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1, stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error(_LE("Error running SSH command: %s"), command)
def _run_ssh(self, cmd_list, attempts=1):
utils.check_ssh_injection(cmd_list)
command = ' '. join(cmd_list)
if not self.sshpool:
password = self.configuration.san_password
privatekey = self.configuration.san_private_key
min_size = self.configuration.ssh_min_pool_conn
max_size = self.configuration.ssh_max_pool_conn
self.sshpool = ssh_utils.SSHPool(
self.configuration.san_ip,
self.configuration.san_ssh_port,
self.configuration.ssh_conn_timeout,
self.configuration.san_login,
password=password,
privatekey=privatekey,
min_size=min_size,
max_size=max_size)
try:
total_attempts = attempts
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
LOG.info(_LI('EQL-driver: executing "%s".'), command)
return self._ssh_execute(
ssh, command,
timeout=self.configuration.eqlx_cli_timeout)
except processutils.ProcessExecutionError:
raise
except Exception as e:
LOG.exception(e)
greenthread.sleep(random.randint(20, 500) / 100.0)
msg = (_("SSH Command failed after '%(total_attempts)r' "
"attempts : '%(command)s'") %
{'total_attempts': total_attempts - attempts,
'command': command})
raise exception.VolumeBackendAPIException(data=msg)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error(_LE('Error running SSH command: "%s".'), command)
def _run_cmd(self, *args, **kwargs):
"""Runs a command on SMU using SSH.
:returns: stdout and stderr of the command
"""
if self.cluster_admin_ip0 is None:
# Connect to SMU through SSH and run ssc locally
args = (self.hnas_cmd, 'localhost') + args
else:
args = (self.hnas_cmd, '--smuauth', self.cluster_admin_ip0) + args
utils.check_ssh_injection(args)
command = ' '.join(args)
command = command.replace('"', '\\"')
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(ip=self.mgmt_ip0,
port=int(self.ssh_port),
conn_timeout=None,
login=self.ssh_username,
password=self.ssh_pwd,
privatekey=self.ssh_private_key)
with self.sshpool.item() as ssh:
try:
out, err = putils.ssh_execute(ssh, command,
check_exit_code=True)
LOG.debug("command %(cmd)s result: out = "
"%(out)s - err = %(err)s",
{'cmd': self.hnas_cmd, 'out': out, 'err': err})
return out, err
except putils.ProcessExecutionError as e:
if 'Failed to establish SSC connection' in e.stderr:
LOG.debug("SSC connection error!")
msg = _("Failed to establish SSC connection.")
raise exception.HNASConnError(msg)
elif 'Connection reset' in e.stderr:
LOG.debug("HNAS connection reset!")
msg = _("HNAS has disconnected SSC")
raise exception.HNASConnError(msg)
else:
raise
def _get_switch_data(self, cmd):
stdin, stdout, stderr = None, None, None
utils.check_ssh_injection([cmd])
try:
stdin, stdout, stderr = self.client.exec_command(cmd)
switch_data = stdout.readlines()
except paramiko.SSHException as e:
msg = (_("SSH Command failed with error '%(err)r' "
"'%(command)s'") % {'err': str(e), 'command': cmd})
LOG.error(msg)
raise exception.FCSanLookupServiceException(message=msg)
finally:
if (stdin):
stdin.flush()
stdin.close()
if (stdout):
stdout.close()
if (stderr):
stderr.close()
return switch_data
raise
=======
out, err = utils.execute(*args, **kwargs)
LOG.debug("command %(cmd)s result: out = %(out)s - err = "
"%(err)s", {'cmd': cmd, 'out': out, 'err': err})
return out, err
>>>>>>> refs/remotes/openstack/stable/kilo:cinder/volume/drivers/hds/hnas_backend.py
else:
if self.drv_configs['cluster_admin_ip0'] is None:
# Connect to SMU through SSH and run ssc locally
args = (cmd, 'localhost') + args
else:
args = (cmd, '--smuauth',
self.drv_configs['cluster_admin_ip0']) + args
utils.check_ssh_injection(args)
command = ' '.join(args)
command = command.replace('"', '\\"')
if not self.sshpool:
server = self.drv_configs['mgmt_ip0']
port = int(self.drv_configs['ssh_port'])
username = self.drv_configs['username']
# We only accept private/public key auth
password = ""
privatekey = self.drv_configs['ssh_private_key']
self.sshpool = ssh_utils.SSHPool(server,
port,
None,
username,
password=password,
def _run_ssh(self, cmd_list, check_exit_code=True, attempts=1):
"""
override _run_ssh() method from san.SanDriver.
It is important to set connection timeout to None
if development_ssh_san_conn is enabled to close ssh
connection per get(). Otherwise, keepalive without
timeout on the ssh transport will cause the service
greenthread to be stuck on the join during close()
when put() is invoked.
"""
if CONF.development_ssh_san_conn:
LOG.debug("PowerVCSSHPool: close ssh connection after _run_ssh")
timeout = None
# periodic task and volume driver ssh execution may
# be launched at the same time which could cause paramiko
# authentication error due to the attempt to create
# multiple paramiko ssh connection at the sametime.
attempts = attempts if attempts > 3 else 3
else:
timeout = self.configuration.ssh_conn_timeout
if not self.sshpool:
password = self.configuration.san_password
privatekey = self.configuration.san_private_key
min_size = self.configuration.ssh_min_pool_conn
max_size = self.configuration.ssh_max_pool_conn
self.sshpool = PowerVCSSHPool(self.configuration.san_ip,
self.configuration.san_ssh_port,
timeout,
self.configuration.san_login,
password=password,
privatekey=privatekey,
min_size=min_size,
max_size=max_size)
utils.check_ssh_injection(cmd_list)
command = ' '.join(cmd_list)
last_exception = None
pauses_between_attempts = 0
try:
while attempts > 0:
attempts -= 1
try:
with self.sshpool.item() as ssh:
# Record the command that we are about to execute,
# along with start time (in seconds)
self.pending_ssh[id(ssh)] = {'command': command,
'time': time.time()}
(out, err) = \
processutils.ssh_execute(ssh,
command,
check_exit_code=
check_exit_code)
# Remove the command from the list of commands we're
# executing.
del self.pending_ssh[id(ssh)]
return (out, err)
except Exception as e:
LOG.info(e)
last_exception = e
if attempts > 0:
sleep_time = (random.randint(CONF.san_retry_min_delay,
CONF.san_retry_max_delay)
+ (pauses_between_attempts *
CONF.san_retry_max_delay))
LOG.info(_("Waiting %(seconds)d seconds before next "
"attempt...")
% {'seconds': sleep_time})
greenthread.sleep(sleep_time)
pauses_between_attempts += 1
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1,
stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception:
with excutils.save_and_reraise_exception():
LOG.error(_("Error running SSH command: %s") % command)
def _ssh_execute(self, cmd_list, check_exit_code=True, attempts=1):
"""Execute cli with status update.
Executes CLI commands such as cfgsave where status return is expected.
"""
utils.check_ssh_injection(cmd_list)
command = ' '. join(cmd_list)
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(self.switch_ip,
self.switch_port,
None,
self.switch_user,
self.switch_pwd,
min_size=1,
max_size=5)
stdin, stdout, stderr = None, None, None
LOG.debug("Executing command via ssh: %s", command)
last_exception = None
try:
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
stdin, stdout, stderr = ssh.exec_command(command)
stdin.write("%s\n" % ZoneConstant.YES)
channel = stdout.channel
exit_status = channel.recv_exit_status()
LOG.debug("Exit Status from ssh: %s", exit_status)
# exit_status == -1 if no exit code was returned
if exit_status != -1:
LOG.debug('Result was %s', exit_status)
if check_exit_code and exit_status != 0:
raise processutils.ProcessExecutionError(
exit_code=exit_status,
stdout=stdout,
stderr=stderr,
cmd=command)
else:
return True
else:
return True
except Exception as e:
LOG.exception(_LE('Error executing SSH command.'))
last_exception = e
greenthread.sleep(random.randint(20, 500) / 100.0)
LOG.debug("Handling error case after "
"SSH: %s", last_exception)
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1,
stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception as e:
with excutils.save_and_reraise_exception():
LOG.error(_LE("Error executing command via ssh: %s"), e)
finally:
if stdin:
stdin.flush()
stdin.close()
if stdout:
stdout.close()
if stderr:
stderr.close()
def _ssh_execute(self, cmd_list, check_exit_code=True, attempts=1):
"""Execute cli with status update.
Executes CLI commands where status return is expected.
cmd_list is a list of commands, where each command is itself
a list of parameters. We use utils.check_ssh_injection to check each
command, but then join then with " ; " to form a single command.
"""
# Check that each command is secure
for cmd in cmd_list:
utils.check_ssh_injection(cmd)
# Combine into a single command.
command = ' ; '.join(map(lambda x: ' '.join(x), cmd_list))
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(self.switch_ip,
self.switch_port,
None,
self.switch_user,
self.switch_pwd,
min_size=1,
max_size=5)
stdin, stdout, stderr = None, None, None
LOG.debug("Executing command via ssh: %s", command)
last_exception = None
try:
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
stdin, stdout, stderr = ssh.exec_command(command)
greenthread.sleep(random.randint(20, 500) / 100.0)
channel = stdout.channel
exit_status = channel.recv_exit_status()
LOG.debug("Exit Status from ssh:%s", exit_status)
# exit_status == -1 if no exit code was returned
if exit_status != -1:
LOG.debug('Result was %s', exit_status)
if check_exit_code and exit_status != 0:
raise processutils.ProcessExecutionError(
exit_code=exit_status,
stdout=stdout,
stderr=stderr,
cmd=command)
else:
return True
else:
return True
except Exception as e:
msg = _("Exception: %s") % six.text_type(e)
LOG.error(msg)
last_exception = e
greenthread.sleep(random.randint(20, 500) / 100.0)
LOG.debug("Handling error case after SSH:%s", last_exception)
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1,
stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception as e:
with excutils.save_and_reraise_exception():
msg = (_("Error executing command via ssh: %s") %
six.text_type(e))
LOG.error(msg)
finally:
if stdin:
stdin.flush()
stdin.close()
if stdout:
stdout.close()
if stderr:
stderr.close()
def test_check_ssh_injection(self):
cmd_list = ['ssh', '-D', 'my_name@name_of_remote_computer']
self.assertEqual(utils.check_ssh_injection(cmd_list), None)
def _ssh_execute(self, cmd_list, check_exit_code=True, attempts=1):
"""Execute cli with status update.
Executes CLI commands such as cfgsave where status return is expected.
"""
utils.check_ssh_injection(cmd_list)
command = ' '.join(cmd_list)
if not self.sshpool:
self.sshpool = ssh_utils.SSHPool(self.switch_ip,
self.switch_port,
None,
self.switch_user,
self.switch_pwd,
self.switch_key,
min_size=1,
max_size=5)
stdin, stdout, stderr = None, None, None
LOG.debug("Executing command via ssh: %s", command)
last_exception = None
try:
with self.sshpool.item() as ssh:
while attempts > 0:
attempts -= 1
try:
stdin, stdout, stderr = ssh.exec_command(command)
stdin.write("%s\n" % zone_constant.YES)
channel = stdout.channel
exit_status = channel.recv_exit_status()
LOG.debug("Exit Status from ssh: %s", exit_status)
# exit_status == -1 if no exit code was returned
if exit_status != -1:
LOG.debug('Result was %s', exit_status)
if check_exit_code and exit_status != 0:
raise processutils.ProcessExecutionError(
exit_code=exit_status,
stdout=stdout,
stderr=stderr,
cmd=command)
else:
return True
else:
return True
except Exception as e:
LOG.exception('Error executing SSH command.')
last_exception = e
greenthread.sleep(random.randint(20, 500) / 100.0)
LOG.debug("Handling error case after "
"SSH: %s", last_exception)
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1,
stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception as e:
with excutils.save_and_reraise_exception():
LOG.error("Error executing command via ssh: %s", e)
finally:
if stdin:
stdin.flush()
stdin.close()
if stdout:
stdout.close()
if stderr:
stderr.close()
def test_check_ssh_injection(self):
cmd_list = ['ssh', '-D', 'my_name@name_of_remote_computer']
self.assertIsNone(utils.check_ssh_injection(cmd_list))
def _run_ssh_aux(cmd, check_exit_code=True, attempts=1):
utils.check_ssh_injection(cmd)
if len(cmd) > 2 and cmd[1] == 'lssystem':
cmd[1] = 'lssystem_aux'
ret = self.sim.execute_command(cmd, check_exit_code)
return ret
def _run_ssh_aux(cmd, check_exit_code=True, attempts=1):
utils.check_ssh_injection(cmd)
if len(cmd) > 2 and cmd[1] == 'lssystem':
cmd[1] = 'lssystem_aux'
ret = self.sim.execute_command(cmd, check_exit_code)
return ret
def _ssh(self, cmd, check_exit_code=True):
utils.check_ssh_injection(cmd)
ret = self.fake_storage.execute_command(cmd, check_exit_code)
return ret
def _ssh_execute(self, cmd_list, check_exit_code=True, attempts=1):
"""Execute cli with status update.
Executes CLI commands where status return is expected.
cmd_list is a list of commands, where each command is itself
a list of parameters. We use utils.check_ssh_injection to check each
command, but then join then with " ; " to form a single command.
"""
# Check that each command is secure
for cmd in cmd_list:
utils.check_ssh_injection(cmd)
# Combine into a single command.
command = ' ; '.join(map(lambda x: ' '.join(x), cmd_list))
if self.sshpool.get(self.switch_ip) is None:
self.sshpool[self.switch_ip] = ssh_utils.SSHPool(self.switch_ip,
self.switch_port,
None,
self.switch_user,
self.switch_pwd,
min_size=1,
max_size=5)
stdin, stdout, stderr = None, None, None
LOG.debug("Executing command via ssh: %s", command)
last_exception = None
try:
with self.sshpool.get(self.switch_ip).item() as ssh:
while attempts > 0:
attempts -= 1
try:
stdin, stdout, stderr = ssh.exec_command(command)
greenthread.sleep(random.randint(20, 500) / 100.0)
channel = stdout.channel
exit_status = channel.recv_exit_status()
LOG.debug("Exit Status from ssh:%s", exit_status)
# exit_status == -1 if no exit code was returned
if exit_status != -1:
LOG.debug('Result was %s', exit_status)
if check_exit_code and exit_status != 0:
raise processutils.ProcessExecutionError(
exit_code=exit_status,
stdout=stdout,
stderr=stderr,
cmd=command)
else:
return True
else:
return True
except Exception as e:
msg = _("Exception: %s") % six.text_type(e)
LOG.error(msg)
last_exception = e
greenthread.sleep(random.randint(20, 500) / 100.0)
LOG.debug("Handling error case after SSH:%s", last_exception)
try:
raise processutils.ProcessExecutionError(
exit_code=last_exception.exit_code,
stdout=last_exception.stdout,
stderr=last_exception.stderr,
cmd=last_exception.cmd)
except AttributeError:
raise processutils.ProcessExecutionError(
exit_code=-1,
stdout="",
stderr="Error running SSH command",
cmd=command)
except Exception as e:
with excutils.save_and_reraise_exception():
msg = (_("Error executing command via ssh: %s") %
six.text_type(e))
LOG.error(msg)
finally:
if stdin:
stdin.flush()
stdin.close()
if stdout:
stdout.close()
if stderr:
stderr.close()
def run_cmd(self, cmd, ip0, user, pw, *args, **kwargs):
"""Run a command on SMU or using SSH
:param cmd: the command that will be run on SMU
:param ip0: string IP address of controller
:param user: string user authentication for array
:param pw: string password authentication for array
:returns: formated string with version information
"""
LOG.debug("Enable ssh: %s", six.text_type(self.drv_configs["ssh_enabled"]))
if self.drv_configs["ssh_enabled"] != "True":
# Direct connection via ssc
args = (cmd, "-u", user, "-p", pw, ip0) + args
try:
out, err = utils.execute(*args, **kwargs)
LOG.debug(
"command %(cmd)s result: out = %(out)s - err = " "%(err)s", {"cmd": cmd, "out": out, "err": err}
)
return out, err
except putils.ProcessExecutionError as e:
if "Failed to establish SSC connection" in e.stderr:
LOG.debug("SSC connection error!")
msg = _("Failed to establish SSC connection.")
raise exception.HNASConnError(msg)
else:
raise putils.ProcessExecutionError
else:
if self.drv_configs["cluster_admin_ip0"] is None:
# Connect to SMU through SSH and run ssc locally
args = (cmd, "localhost") + args
else:
args = (cmd, "--smuauth", self.drv_configs["cluster_admin_ip0"]) + args
utils.check_ssh_injection(args)
command = " ".join(args)
command = command.replace('"', '\\"')
if not self.sshpool:
server = self.drv_configs["mgmt_ip0"]
port = int(self.drv_configs["ssh_port"])
username = self.drv_configs["username"]
# We only accept private/public key auth
password = ""
privatekey = self.drv_configs["ssh_private_key"]
self.sshpool = ssh_utils.SSHPool(server, port, None, username, password=password, privatekey=privatekey)
with self.sshpool.item() as ssh:
try:
out, err = putils.ssh_execute(ssh, command, check_exit_code=True)
LOG.debug(
"command %(cmd)s result: out = " "%(out)s - err = %(err)s", {"cmd": cmd, "out": out, "err": err}
)
return out, err
except putils.ProcessExecutionError as e:
if "Failed to establish SSC connection" in e.stderr:
LOG.debug("SSC connection error!")
msg = _("Failed to establish SSC connection.")
raise exception.HNASConnError(msg)
else:
raise putils.ProcessExecutionError
def _ssh(self, cmd, check_exit_code=True):
utils.check_ssh_injection(cmd)
ret = self.fake_storage.execute_command(cmd, check_exit_code)
return ret
