def parse_error(self): if self.status in [httplib.UNAUTHORIZED, httplib.FORBIDDEN]: raise InvalidCredsError(self.body) elif self.status == httplib.MOVED_PERMANENTLY: raise LibcloudError('This bucket is located in a different ' + 'region. Please use the correct driver.', driver=S3StorageDriver) raise LibcloudError('Unknown error. Status code: %d' % (self.status), driver=S3StorageDriver)
def parse_error(self): if self.status == 403: raise InvalidCredsError(self.body) elif self.status == 301: raise LibcloudError('This bucket is located in a different ' + 'region. Please use the correct driver.', driver=S3StorageDriver) raise LibcloudError('Unknown error. Status code: %d' % (self.status), driver=S3StorageDriver)
def parse_error(self): response = super(OvhResponse, self).parse_body() response = response or {} if response.get('errorCode', None) == 'INVALID_SIGNATURE': raise InvalidCredsError('Signature validation failed, probably ' 'using invalid credentials') return self.body
def _api_parse_error(self, response): if 'data' in response: if response['data'] == 'invalid_api_key': raise InvalidCredsError( "Oops! You've entered an invalid API key") else: raise DreamhostAPIException(response['data']) else: raise DreamhostAPIException("Unknown problem: %s" % (self.body))
def test_unauthorized_response(self): http_response = MockResponse(httplib.UNAUTHORIZED, OpenNebula_ResponseTests.XML, headers={'content-type': 'application/xml'}) try: OpenNebulaResponse(http_response, None).parse_body() except InvalidCredsError: exceptionType = sys.exc_info()[0] self.assertEqual(exceptionType, type(InvalidCredsError()))
def parse_error(self): if self.status == httplib.OK: body = self.parse_body() return body elif self.status == httplib.FORBIDDEN: raise InvalidCredsError(self.body) elif self.status == httplib.SERVICE_UNAVAILABLE: raise ServiceUnavailableError(self.body) else: raise LibcloudError(self.body)
def parse_error(self): body = self.parse_body() if self.status == httplib.UNAUTHORIZED: raise InvalidCredsError(body['detail']) else: # We are taking the first issue here. There might be multiple ones, # but that doesn't really matter. It's nicer if the error is just # one error (because it's a Python API and there's only one # exception. return next(iter(body.values()))
def _make_excp(self, error): """Convert an API error to a LinodeException instance @keyword error: JSON object containing C{ERRORCODE} and C{ERRORMESSAGE} @type error: dict""" if "ERRORCODE" not in error or "ERRORMESSAGE" not in error: return None if error["ERRORCODE"] == 4: return InvalidCredsError(error["ERRORMESSAGE"]) return LinodeException(error["ERRORCODE"], error["ERRORMESSAGE"])
def parse_error(self): response = super(OvhResponse, self).parse_body() response = response or {} if response.get("errorCode", None) == "INVALID_SIGNATURE": raise InvalidCredsError( "Signature validation failed, probably " "using invalid credentials" ) return self.body
def __init__( self, key, secret, secure=True, host="localhost", port=4243, key_file="", cert_file="", **kwargs, ): super(DockertlsConnection, self).__init__( key_file=key_file, cert_file=cert_file, secure=secure, host=host, port=port, url=None, proxy_url=None, timeout=None, backoff=None, retry_delay=None, ) if key_file: keypath = os.path.expanduser(key_file) is_file_path = os.path.exists(keypath) and os.path.isfile(keypath) if not is_file_path: raise InvalidCredsError( "You need an key PEM file to authenticate with " "Docker tls. This can be found in the server." ) self.key_file = key_file certpath = os.path.expanduser(cert_file) is_file_path = os.path.exists(certpath) and os.path.isfile(certpath) if not is_file_path: raise InvalidCredsError( "You need an certificate PEM file to authenticate with " "Docker tls. This can be found in the server." ) self.cert_file = cert_file
def parse_error(self): if self.status == httplib.UNAUTHORIZED: body = self.parse_body() raise InvalidCredsError(body["message"]) else: body = self.parse_body() if "message" in body: error = "%s (code: %s)" % (body["message"], self.status) else: error = body return error
def __new__(cls, key, secret=None, api_version="v2", **kwargs): if cls is DigitalOceanNodeDriver: if api_version == "v1" or secret is not None: if secret is not None and api_version == "v2": raise InvalidCredsError("secret not accepted for v2 authentication") raise DigitalOcean_v1_Error() elif api_version == "v2": cls = DigitalOcean_v2_NodeDriver else: raise NotImplementedError("Unsupported API version: %s" % (api_version)) return super(DigitalOceanNodeDriver, cls).__new__(cls, **kwargs)
def parse_error(self): body = super().parse_error() # INFO: пример ответа: {"code":401,"message":"Unauthorized","details":"..."} code = body["code"] if code == 401: raise InvalidCredsError(value=body["details"]) # TODO: ServiceUnavailableError и RateLimitReachedError return body
def parse_error(self): if self.status == httplib.UNAUTHORIZED: body = self.parse_body() raise InvalidCredsError(body['message']) else: body = self.parse_body() if 'message' in body: error = '%s (code: %s)' % (body['message'], self.status) else: error = body return error
def request(self, method, *args, **kwargs): sl = self.proxyCls(user=self.user, key=self.key, secure=self.secure, host=self.host, port=self.port, driver=self.driver) try: return getattr(sl, method)(*args) except xmlrpclib.Fault: e = sys.exc_info()[1] if e.faultCode == 'VCL_Account': raise InvalidCredsError(e.faultString) raise LibcloudError(e, driver=self.driver)
def parse_error(self): """ Check if response contains any errors. @raise: :class:`InvalidCredsError` :rtype: :class:`ElementTree` :return: Contents of HTTP response body. """ if int(self.status) == httplib.UNAUTHORIZED: raise InvalidCredsError(self.body) return self.body
def parse_error(self): if self.status in [httplib.UNAUTHORIZED, httplib.FORBIDDEN]: raise InvalidCredsError(self.body) elif self.status == httplib.MOVED_PERMANENTLY: raise LibcloudError('This bucket is located in a different ' + 'region. Please use the correct driver.', driver=OSSStorageDriver) elif self.status == httplib.METHOD_NOT_ALLOWED: raise LibcloudError('The method is not allowed. Status code: %d, ' 'headers: %s' % (self.status, self.headers)) raise LibcloudError('Unknown error. Status code: %d, body: %s' % (self.status, self.body), driver=OSSStorageDriver)
def parse_error(self): if self.status in [httplib.UNAUTHORIZED, httplib.FORBIDDEN]: raise InvalidCredsError(self.body) elif self.status == httplib.MOVED_PERMANENTLY: bucket_region = self.headers.get('x-amz-bucket-region', None) used_region = self.connection.driver.region raise LibcloudError('This bucket is located in a different ' 'region. Please use the correct driver. ' 'Bucket region "%s", used region "%s".' % (bucket_region, used_region), driver=S3StorageDriver) raise LibcloudError('Unknown error. Status code: %d' % (self.status), driver=S3StorageDriver)
def parse_error(self): body = super().parse_error() # error codes https://ruvds.com/en-usd/use_api # sign-insection reject_reason = body["rejectReason"] if reject_reason in (1, 2, 3, 6, 7): raise InvalidCredsError(value=body["errMessage"]) elif reject_reason == 5: raise ServiceUnavailableError() elif reject_reason == 8: raise RateLimitReachedError() return body
def parse_error(self): if self.status == 401: raise InvalidCredsError(self.body) if self.status == 403: raise InvalidCredsError(self.body) try: body = ET.XML(self.body) except: raise MalformedResponseError("Failed to parse XML", body=self.body, driver=OpsourceNodeDriver) if self.status == 400: code = findtext(body, 'resultCode', SERVER_NS) message = findtext(body, 'resultDetail', SERVER_NS) raise OpsourceAPIException(code, message, driver=OpsourceNodeDriver) return self.body
def _auth(self): """ OpenStack needs first to get an authentication token """ self.connection.request(method='GET', url=self.api_version, headers={ 'X-Auth-User': self.user_id, 'X-Auth-Key': self.key }) resp = self.connection.getresponse() if resp.status != httplib.NO_CONTENT: raise InvalidCredsError() headers = dict(resp.getheaders()) try: self.server_url = headers['x-server-management-url'] self.auth_token = headers['x-auth-token'] except KeyError: raise InvalidCredsError()
def parse_error(self) -> str: http_code = int(self.status) if http_code == httplib.FORBIDDEN: raise InvalidCredsError("Invalid credentials") body = super().parse_error() if http_code == httplib.INTERNAL_SERVER_ERROR: return body["error"]["message"] if http_code in (httplib.CONFLICT, httplib.NOT_FOUND): raise ProviderError(value=body["error"], http_code=http_code) return body["error"]
def __init__(self, host, username, password, verify_ssl=True): context = ssl.create_default_context() if not verify_ssl: context.check_hostname = False context.verify_mode = ssl.CERT_NONE try: self.conn = connect.SmartConnect(host=host, user=username, pwd=password, sslContext=context) except Exception as e: if isinstance(e, vim.fault.InvalidLogin): raise InvalidCredsError("username/password not acepted") raise LibcloudError(str(e), driver=self)
def parse_error(self): if self.status == httplib.UNAUTHORIZED: raise InvalidCredsError(self.body) elif self.status == httplib.FORBIDDEN: raise InvalidCredsError(self.body) body = self.parse_body() if self.status == httplib.BAD_REQUEST: code = findtext(body, 'responseCode', SERVER_NS) if code is None: code = findtext(body, 'responseCode', TYPES_URN) message = findtext(body, 'message', SERVER_NS) if message is None: message = findtext(body, 'message', TYPES_URN) raise DimensionDataAPIException(code=code, msg=message, driver=self.connection.driver) if self.status is not httplib.OK: raise DimensionDataAPIException(code=self.status, msg=body, driver=self.connection.driver) return self.body
def request(self, service, method, *args, **kwargs): sl = self.proxyCls(service, self._user_agent()) headers = {} headers.update(self._get_auth_headers()) headers.update(self._get_init_params(service, kwargs.get('id'))) headers.update( self._get_object_mask(service, kwargs.get('object_mask'))) params = [{'headers': headers}] + list(args) try: return getattr(sl, method)(*params) except xmlrpclib.Fault, e: if e.faultCode == "SoftLayer_Account": raise InvalidCredsError(e.faultString) raise SoftLayerException(e)
def parse_error(self): err_list = [] if not self.body: return None if self.parsed is None: self.parsed = super(VoxelResponse, self).parse_body() for err in self.parsed.findall("err"): code = err.get("code") err_list.append("(%s) %s" % (code, err.get("msg"))) # From voxel docs: # 1: Invalid login or password # 9: Permission denied: user lacks access rights for this method if code == "1" or code == "9": # sucks, but only way to detect # bad authentication tokens so far raise InvalidCredsError(err_list[-1]) return "\n".join(err_list)
def parse_error(self): """ Parse the error messages. Response body can easily be handled by this class parent :class:`XmlResponse`, but there are use cases which Abiquo API does not respond an XML but an HTML. So we need to handle these special cases. """ if self.status == httplib.UNAUTHORIZED: raise InvalidCredsError(driver=self.connection.driver) elif self.status == httplib.FORBIDDEN: raise ForbiddenError(self.connection.driver) else: errors = self.parse_body().findall('error') # Most of the exceptions only have one error raise LibcloudError(errors[0].findtext('message'))
def parse_error(self): err_list = [] if not self.body: return None if not self.parsed: self.parsed = ET.XML(self.body) for err in self.parsed.findall('err'): code = err.get('code') err_list.append("(%s) %s" % (code, err.get('msg'))) # From voxel docs: # 1: Invalid login or password # 9: Permission denied: user lacks access rights for this method if code == "1" or code == "9": # sucks, but only way to detect # bad authentication tokens so far raise InvalidCredsError(err_list[-1]) return "\n".join(err_list)
def get_esh_instance(request, provider_id, identity_id, instance_id): esh_driver = prepare_driver(request, provider_id, identity_id) if not esh_driver: raise InvalidCredsError("Provider_id && identity_id " "did not produce a valid combination") esh_instance = esh_driver.get_instance(instance_id) if not esh_instance: try: core_inst = CoreInstance.objects.get( provider_alias=instance_id, provider_machine__provider__id=provider_id, created_by_identity__id=identity_id) core_inst.end_date_all() except CoreInstance.DoesNotExist: pass return esh_instance return esh_instance
def _get_auth_token(self): if not self.token: conn = self.conn_classes[self.secure](self.host, self.port) conn.request(method='POST', url='/api/v0.8/login', headers=self._get_auth_headers()) resp = conn.getresponse() headers = dict(resp.getheaders()) body = ET.XML(resp.read()) try: self.token = headers['set-cookie'] except KeyError: raise InvalidCredsError() self.driver.org = get_url_path( body.find(fixxpath(body, 'Org')).get('href'))