def setUp(self, **kwargs):
version = (
file_client.HPE3ParFilePersonaClient.HPE3PAR_WS_MIN_BUILD_VERSION)
mock_version = mock.Mock()
mock_version.return_value = {'build': version}
with mock.patch('hpe3parclient.client.HPE3ParClient.getWsApiVersion',
mock_version):
self.cl = file_client.HPE3ParFilePersonaClient('anyurl')
self.cl.ssh = mock.Mock()
self.cl.http = mock.Mock()
self.cl.ssh.run = mock.Mock()
self.cl.ssh.run.return_value = 'anystring'
def setUp(self, withSSH=False, withFilePersona=False):
self.withSSH = withSSH
self.withFilePersona = withFilePersona
cwd = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
if self.unitTest:
self.printHeader('Using flask ' + self.flask_url)
parsed_url = urlparse(self.flask_url)
userArg = '-user=%s' % self.user
passwordArg = '-password=%s' % self.password
portArg = '-port=%s' % parsed_url.port
script = 'HPE3ParMockServer_flask.py'
path = "%s/%s" % (cwd, script)
try:
self.mockServer = subprocess.Popen(
[sys.executable, path, userArg, passwordArg, portArg],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE)
except Exception:
pass
time.sleep(1)
if self.withFilePersona:
self.cl = file_client.HPE3ParFilePersonaClient(self.flask_url)
else:
self.cl = client.HPE3ParClient(self.flask_url)
if self.withSSH:
self.printHeader('Using paramiko SSH server on port %s' %
self.ssh_port)
ssh_script = 'HPE3ParMockServer_ssh.py'
ssh_path = "%s/%s" % (cwd, ssh_script)
self.mockSshServer = subprocess.Popen(
[sys.executable, ssh_path,
str(self.ssh_port)],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE)
time.sleep(1)
else:
if withFilePersona:
self.printHeader('Using 3PAR %s with File Persona' %
self.url_3par)
self.cl = file_client.HPE3ParFilePersonaClient(self.url_3par)
else:
self.printHeader('Using 3PAR ' + self.url_3par)
self.cl = client.HPE3ParClient(self.url_3par)
if self.withSSH:
# This seems to slow down the test cases, so only use this when
# requested
if self.unitTest:
# The mock SSH server can be accessed at 0.0.0.0.
ip = '0.0.0.0'
else:
parsed_3par_url = urlparse(self.url_3par)
ip = parsed_3par_url.hostname.split(':').pop()
try:
# Now that we don't do keep-alive, the conn_timeout needs to
# be set high enough to avoid sometimes slow response in
# the File Persona tests.
self.cl.setSSHOptions(
ip,
self.user,
self.password,
port=self.ssh_port,
conn_timeout=500,
known_hosts_file=self.known_hosts_file,
missing_key_policy=self.missing_key_policy)
except Exception as ex:
print(ex)
self.fail("failed to start ssh client")
# Setup remote copy target
if self.run_remote_copy:
parsed_3par_url = urlparse(self.secondary_url_3par)
ip = parsed_3par_url.hostname.split(':').pop()
self.secondary_cl = client.HPE3ParClient(self.secondary_url_3par)
try:
self.secondary_cl.setSSHOptions(
ip,
self.secondary_user,
self.secondary_password,
port=self.ssh_port,
conn_timeout=500,
known_hosts_file=self.known_hosts_file,
missing_key_policy=self.missing_key_policy)
except Exception as ex:
print(ex)
self.fail("failed to start ssh client")
self.secondary_cl.login(self.secondary_user,
self.secondary_password)
if self.debug:
self.cl.debug_rest(True)
self.cl.login(self.user, self.password)
if not self.port:
ports = self.cl.getPorts()
ports = [
p for p in ports['members'] if p['linkState'] == 4 and # Ready
('device' not in p or not p['device']
) and p['mode'] == self.cl.PORT_MODE_TARGET
]
self.port = ports[0]['portPos']
and print the results.
"""
import os, sys, pprint
from hpe3parclient import file_client
cmd_folder = os.path.realpath(os.path.abspath(".."))
if cmd_folder not in sys.path:
sys.path.insert(0, cmd_folder)
username = '******'
password = '******'
ip = 'your-3PAR-ip-address'
cl = file_client.HPE3ParFilePersonaClient("https://%s:8080/api/v1" % ip)
cl.setSSHOptions(ip, username, password, port=22, conn_timeout=None)
cl.login(username, password)
# Test commands and pretty-print their output...
print("GETFS:")
pprint.pprint(cl.getfs())
print("GETVFS:")
pprint.pprint(cl.getvfs())
print("GETFPG:")
pprint.pprint(cl.getfpg())
cl.logout()
def do_setup(self):
if self.no_client():
msg = _('You must install hpe3parclient before using the 3PAR '
'driver.')
LOG.error(msg)
raise exception.HPE3ParInvalidClient(message=msg)
self.client_version = hpe3parclient.version_tuple
if self.client_version < MIN_CLIENT_VERSION:
msg = (
_('Invalid hpe3parclient version found (%(found)s). '
'Version %(minimum)s or greater required.') %
{
'found': '.'.join(map(six.text_type, self.client_version)),
'minimum': '.'.join(map(six.text_type, MIN_CLIENT_VERSION))
})
LOG.error(msg)
raise exception.HPE3ParInvalidClient(message=msg)
try:
self._client = file_client.HPE3ParFilePersonaClient(
self.hpe3par_api_url)
except Exception as e:
msg = (_('Failed to connect to HPE 3PAR File Persona Client: %s') %
six.text_type(e))
LOG.exception(msg)
raise exception.ShareBackendException(message=msg)
try:
ssh_kwargs = {}
if self.hpe3par_san_ssh_port:
ssh_kwargs['port'] = self.hpe3par_san_ssh_port
if self.ssh_conn_timeout:
ssh_kwargs['conn_timeout'] = self.ssh_conn_timeout
if self.hpe3par_san_private_key:
ssh_kwargs['privatekey'] = self.hpe3par_san_private_key
self._client.setSSHOptions(self.hpe3par_san_ip,
self.hpe3par_san_login,
self.hpe3par_san_password, **ssh_kwargs)
except Exception as e:
msg = (_('Failed to set SSH options for HPE 3PAR File Persona '
'Client: %s') % six.text_type(e))
LOG.exception(msg)
raise exception.ShareBackendException(message=msg)
LOG.info(
_LI("HPE3ParMediator %(version)s, "
"hpe3parclient %(client_version)s"), {
"version": self.VERSION,
"client_version": hpe3parclient.get_version_string()
})
try:
wsapi_version = self._client.getWsApiVersion()['build']
LOG.info(_LI("3PAR WSAPI %s"), wsapi_version)
except Exception as e:
msg = (_('Failed to get 3PAR WSAPI version: %s') %
six.text_type(e))
LOG.exception(msg)
raise exception.ShareBackendException(message=msg)
if self.hpe3par_debug:
self._client.debug_rest(True) # Includes SSH debug (setSSH above)