def login(self):
"""Login dell_emc unity storage array."""
try:
with self.session_lock:
data = {}
if self.session is None:
self.init_http_head()
self.session.headers.update({"X-EMC-REST-CLIENT": "true"})
self.session.auth = requests.auth.HTTPBasicAuth(
self.rest_username, cryptor.decode(self.rest_password))
res = self.call_with_token(RestHandler.REST_AUTH_URL, data,
'GET')
if res.status_code == 200:
self.session.headers[RestHandler.AUTH_KEY] = \
cryptor.encode(res.headers[RestHandler.AUTH_KEY])
else:
LOG.error("Login error.URL: %s,Reason: %s.",
RestHandler.REST_AUTH_URL, res.text)
if 'Unauthorized' in res.text:
raise exception.InvalidUsernameOrPassword()
elif 'Forbidden' in res.text:
raise exception.InvalidIpOrPort()
else:
raise exception.BadResponse(res.text)
except Exception as e:
LOG.error("Login error: %s", six.text_type(e))
raise e
def get_rest_info(self, url, data=None, method='GET'):
if 'login' == data:
self.session.auth = requests.auth.HTTPBasicAuth(
self.rest_username, cryptor.decode(self.rest_password))
else:
self.login()
self.session.auth = requests.auth.HTTPBasicAuth(
self.rest_username, self.rest_auth_token)
res = self.do_call(url, data, method)
try:
if res.status_code == 200:
result_json = json.loads(res.text)
elif res.status_code == 500:
LOG.error('Connect Timeout error')
raise exception.ConnectTimeout()
elif res.status_code == 401:
LOG.error('User authentication failed')
raise exception.InvalidUsernameOrPassword
else:
raise exception.BadResponse()
except Exception as err:
LOG.exception(
'Get RestHandler.call failed: %(url)s.'
' Error: %(err)s', {
'url': url,
'err': err
})
raise exception.InvalidResults(err)
return result_json
def do_call(self, url, data, method,
calltimeout=consts.SOCKET_TIMEOUT):
"""Send requests to Hpe3par storage server.
"""
if 'http' not in url:
if self.san_address:
url = self.san_address + url
kwargs = {'timeout': calltimeout}
if data:
kwargs['data'] = json.dumps(data)
if method in ('POST', 'PUT', 'GET', 'DELETE'):
func = getattr(self.session, method.lower())
else:
msg = _("Request method %s is invalid.") % method
LOG.error(msg)
raise exception.StorageBackendException(reason=msg)
res = None
try:
res = func(url, **kwargs)
except requests.exceptions.ConnectTimeout as ct:
LOG.error('ConnectTimeout err: {}'.format(ct))
raise exception.ConnectTimeout()
except Exception as err:
LOG.exception('Bad response from server: %(url)s.'
' Error: %(err)s', {'url': url, 'err': err})
if 'WSAETIMEDOUT' in str(err):
raise exception.ConnectTimeout()
else:
raise exception.BadResponse()
return res
def login(self):
try:
access_session = self.rest_auth_token
if self.rest_auth_token is None:
url = RestHandler.REST_AUTH_URL
data = {}
self.init_rest_client()
res = self. \
do_call(url, data, 'GET',
calltimeout=consts.SOCKET_TIMEOUT)
if res.status_code == 200:
access_session = res.headers['EMC-CSRF-TOKEN']
self.rest_auth_token = access_session
self.session.headers[
RestHandler.REST_AUTH_KEY] = access_session
else:
LOG.error(
"Login error. URL: %(url)s\n"
"Reason: %(reason)s.", {
"url": url,
"reason": res.text
})
if 'invalid username or password' in res.text:
raise exception.InvalidUsernameOrPassword()
else:
raise exception.BadResponse(res.text)
else:
LOG.error('Login Parameter error')
return access_session
except Exception as e:
LOG.error("Login error: %s", six.text_type(e))
raise e
def login(self):
"""Login Hpe3par storage array."""
try:
access_session = self.rest_client.rest_auth_token
if self.rest_client.san_address:
url = RestHandler.REST_AUTH_URL
data = {
"user": self.rest_client.rest_username,
"password": cryptor.decode(self.rest_client.rest_password)
}
self.session_lock.acquire()
if self.rest_client.rest_auth_token is not None:
return self.rest_client.rest_auth_token
self.rest_client.init_http_head()
res = self.rest_client. \
do_call(url, data, 'POST',
calltimeout=consts.SOCKET_TIMEOUT)
if res is None:
LOG.error('Login res is None')
raise exception.InvalidResults('res is None')
if res.status_code == consts. \
LOGIN_SUCCESS_STATUS_CODES:
result = res.json()
access_session = result.get('key')
self.rest_client.rest_auth_token = access_session
self.rest_client.session.headers[
RestHandler.REST_AUTH_KEY] = access_session
else:
LOG.error(
"Login error. URL: %(url)s\n"
"Reason: %(reason)s.", {
"url": url,
"reason": res.text
})
if 'invalid username or password' in res.text:
raise exception.InvalidUsernameOrPassword()
else:
raise exception.BadResponse(res.text)
else:
LOG.error('Login Parameter error')
return access_session
except Exception as e:
LOG.error("Login error: %s", six.text_type(e))
raise e
finally:
self.session_lock.release()
def do_call(self, url, data, method, calltimeout=SOCKET_TIMEOUT):
if 'http' not in url:
if self.san_address:
url = '%s%s' % (self.san_address, url)
kwargs = {'timeout': calltimeout}
if data:
kwargs['data'] = json.dumps(data)
if method in ('POST', 'PUT', 'GET', 'DELETE'):
func = getattr(self.session, method.lower())
else:
msg = _("Request method %s is invalid.") % method
LOG.error(msg)
raise exception.StorageBackendException(msg)
res = None
try:
res = func(url, **kwargs)
except requests.exceptions.ConnectTimeout as ct:
LOG.error('Connect Timeout err: {}'.format(ct))
raise exception.InvalidIpOrPort()
except requests.exceptions.ReadTimeout as rt:
LOG.error('Read timed out err: {}'.format(rt))
raise exception.StorageBackendException(six.text_type(rt))
except requests.exceptions.SSLError as e:
LOG.error('SSLError for %s %s' % (method, url))
err_str = six.text_type(e)
if 'certificate verify failed' in err_str:
raise exception.SSLCertificateFailed()
else:
raise exception.SSLHandshakeFailed()
except Exception as err:
LOG.exception(
'Bad response from server: %(url)s.'
' Error: %(err)s', {
'url': url,
'err': err
})
if 'WSAETIMEDOUT' in str(err):
raise exception.ConnectTimeout()
elif 'Failed to establish a new connection' in str(err):
LOG.error('Failed to establish: {}'.format(err))
raise exception.InvalidIpOrPort()
elif 'Read timed out' in str(err):
raise exception.StorageBackendException(six.text_type(err))
else:
raise exception.BadResponse()
return res
def get_token(self):
try:
succeed = False
if self.san_address:
url = '%s/%s/sessions' % \
(RestHandler.COMM_URL,
self.storage_device_id)
data = {}
with self.session_lock:
if self.session is None:
self.init_http_head()
self.session.auth = \
requests.auth.HTTPBasicAuth(
self.rest_username,
cryptor.decode(self.rest_password))
res = self.call_with_token(url, data, 'POST', 30)
if res.status_code == 200:
succeed = True
result = res.json()
self.session_id = cryptor.encode(
result.get('sessionId'))
access_session = 'Session %s' % result.get('token')
self.session.headers[
RestHandler.AUTH_KEY] = cryptor.encode(
access_session)
else:
LOG.error(
"Login error. URL: %(url)s\n"
"Reason: %(reason)s.", {
"url": url,
"reason": res.text
})
if 'authentication failed' in res.text:
raise exception.InvalidUsernameOrPassword()
elif 'KART30005-E' in res.text:
raise exception.StorageBackendException(
six.text_type(res.text))
else:
raise exception.BadResponse(res.text)
else:
LOG.error('Token Parameter error')
return succeed
except Exception as e:
LOG.error("Get token error: %s", six.text_type(e))
raise e
def login(self):
try:
data = {}
self.init_http_head()
self.session.headers.update({
"username":
self.rest_username,
"password":
cryptor.decode(self.rest_password)
})
res = self.do_call(consts.REST_AUTH_URL, data, 'GET')
if res.status_code != 200:
LOG.error("Login error. URL: %(url)s\n"
"Reason: %(reason)s.", {
"url": consts.REST_AUTH_URL,
"reason": res.text
})
if 'User authentication failed' in res.text:
raise exception.InvalidUsernameOrPassword()
else:
raise exception.BadResponse(res.text)
except Exception as e:
LOG.error("Login error: %s", six.text_type(e))
raise e