Python exceptions.EndpointConnectionError方法代码示例

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def _make_api_call(operation_name, **operation_options):
    try:
        result = aws.make_api_call('codebuild', operation_name, **operation_options)
    except ServiceError as ex:
        if ex.code == 'AccessDeniedException':
            io.echo(
                "EB CLI does not have the right permissions to access CodeBuild.\n"
                "To learn more, see Docs: https://docs-aws.amazon.com/codebuild/"
                "latest/userguide/auth-and-access-control-permissions-reference.html"
            )
        raise ex
    except EndpointConnectionError:
        LOG.debug(
            "Caught endpoint timeout for CodeBuild."
            " We are assuming this is because they are not supported in that region yet."
        )
        raise ServiceError("Elastic Beanstalk does not support AWS CodeBuild in this region.")
    return result 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def find_usage(self):
        """
        Determine the current usage for each limit of this service,
        and update corresponding Limit via
        :py:meth:`~.AwsLimit._add_current_usage`.
        """
        logger.debug("Getting usage for Lambda metrics")
        try:
            self.connect()
            resp = self.conn.get_account_settings()
        except EndpointConnectionError as ex:
            logger.warn('Skipping Lambda: %s', str(ex))
            return
        self.limits['Function Count']._add_current_usage(
            resp['AccountUsage']['FunctionCount'])
        self.limits['Total Code Size (MiB)']._add_current_usage(
            int((resp['AccountUsage']['TotalCodeSize'])/1048576))
        self._have_usage = True 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def find_usage(self):
        """
        Determine the current usage for each limit of this service,
        and update corresponding Limit via
        :py:meth:`~.AwsLimit._add_current_usage`.
        """
        logger.debug("Checking usage for service %s", self.service_name)
        for lim in self.limits.values():
            lim._reset_usage()
        try:
            self.connect()
            resp = self.conn.get_send_quota()
        except EndpointConnectionError as ex:
            logger.warning('Skipping SES: %s', str(ex))
            return
        except ClientError as ex:
            if ex.response['Error']['Code'] in ['AccessDenied', '503']:
                logger.warning('Skipping SES: %s', ex)
                return
            raise
        self.limits['Daily sending quota']._add_current_usage(
            resp['SentLast24Hours']
        )
        self._have_usage = True
        logger.debug("Done checking usage.") 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def _update_limits_from_api(self):
        """
        Call the service's API action to retrieve limit/quota information, and
        update AwsLimit objects in ``self.limits`` with this information.
        """
        try:
            self.connect()
            resp = self.conn.get_send_quota()
        except EndpointConnectionError as ex:
            logger.warning('Skipping SES: %s', str(ex))
            return
        except ClientError as ex:
            if ex.response['Error']['Code'] in ['AccessDenied', '503']:
                logger.warning('Skipping SES: %s', ex)
                return
            raise
        self.limits['Daily sending quota']._set_api_limit(resp['Max24HourSend']) 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def find_usage(self):
        """
        Determine the current usage for each limit of this service,
        and update corresponding Limit via
        :py:meth:`~.AwsLimit._add_current_usage`.
        """
        logger.debug("Checking usage for service %s", self.service_name)
        self.connect()
        for lim in self.limits.values():
            lim._reset_usage()
        try:
            self._find_delivery_streams()
        except EndpointConnectionError as ex:
            logger.warning(
                'Caught exception when trying to use Firehose ('
                'perhaps the Firehose service is not available in this '
                'region?): %s', ex
            )

        self._have_usage = True
        logger.debug("Done checking usage.") 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def test_update_limits_from_api_invalid_region(self):
        def se_get():
            raise EndpointConnectionError(endpoint_url='myurl')

        mock_conn = Mock()
        mock_conn.get_send_quota.side_effect = se_get

        with patch('%s.connect' % pb) as mock_connect:
            with patch('%s.logger' % pbm) as mock_logger:
                cls = _SesService(21, 43, {}, None)
                cls.conn = mock_conn
                cls._update_limits_from_api()
        assert mock_connect.mock_calls == [call()]
        assert mock_conn.mock_calls == [call.get_send_quota()]
        assert mock_logger.mock_calls == [
            call.warning(
                'Skipping SES: %s',
                'Could not connect to the endpoint URL: "myurl"'
            )
        ]
        assert cls.limits['Daily sending quota'].api_limit is None 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def test_find_usage_connection_fail(self):
        def conn_err():
            raise EndpointConnectionError(endpoint_url='myurl')

        mock_conn = Mock()
        mock_conn.get_account_settings.side_effect = conn_err

        with patch('%s.connect' % pb) as mock_connect:
            with patch('%s.logger' % pbm) as mock_logger:
                cls = _LambdaService(21, 43, {}, None)
                cls.conn = mock_conn
                cls.find_usage()

        assert len(cls.limits) == 6
        assert mock_connect.mock_calls == [call()]
        assert mock_conn.mock_calls == [call.get_account_settings()]
        assert mock_logger.mock_calls == [
            call.debug('Getting limits for Lambda'),
            call.debug('Getting usage for Lambda metrics'),
            call.warn('Skipping Lambda: %s',
                      'Could not connect to the endpoint URL: "myurl"')
        ] 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def _validate_region(self, client, doc):
        try:
            response = client.describe_regions(RegionNames=[doc['regionName']])
            endpoint = parse('Regions[0].Endpoint').find(response)
            if endpoint:
                endpoint = endpoint[0].value
            else:
                raise ValidationException('Unable to extract region endpoint.')

            doc['regionHost'] = endpoint
        except ClientError as ce:
            code = parse('Error.Code').find(ce.response)
            if code:
                code = code[0].value
            else:
                raise

            if code == ClientErrorCode.InvalidParameterValue:
                raise ValidationException('Invalid region', 'regionName')
        except EndpointConnectionError as ece:
            raise ValidationException(ece.message) 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def _validate_zone(self, client, doc):
        try:
            client = get_ec2_client(doc)
            client.describe_availability_zones(
                ZoneNames=[doc['availabilityZone']])

        except ClientError as ce:
            code = parse('Error.Code').find(ce.response)
            if code:
                code = code[0].value
            else:
                raise

            if code == ClientErrorCode.InvalidParameterValue:
                raise ValidationException(
                    'Invalid zone', 'availabilityZone')
        except EndpointConnectionError as ece:
            raise ValidationException(ece.message) 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def async_resend_email_confirm(self, email):
        """Resend email confirmation."""

        try:
            async with self._request_lock:
                cognito = self._cognito(username=email)
                await self.cloud.run_executor(
                    partial(
                        cognito.client.resend_confirmation_code,
                        Username=email,
                        ClientId=cognito.client_id,
                    )
                )
        except ClientError as err:
            raise _map_aws_exception(err)
        except EndpointConnectionError:
            raise UnknownError() 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def async_login(self, email, password):
        """Log user in and fetch certificate."""

        try:
            async with self._request_lock:
                assert not self.cloud.is_logged_in, "Cannot login if already logged in."

                cognito = self._cognito(username=email)
                await self.cloud.run_executor(
                    partial(cognito.authenticate, password=password)
                )
                self.cloud.id_token = cognito.id_token
                self.cloud.access_token = cognito.access_token
                self.cloud.refresh_token = cognito.refresh_token
            await self.cloud.run_executor(self.cloud.write_user_info)

        except ForceChangePasswordException:
            raise PasswordChangeRequired()

        except ClientError as err:
            raise _map_aws_exception(err)

        except EndpointConnectionError:
            raise UnknownError() 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def _async_renew_access_token(self):
        """Renew access token internals.

        Does not consume lock.
        """
        cognito = self._authenticated_cognito

        try:
            await self.cloud.run_executor(cognito.renew_access_token)
            self.cloud.id_token = cognito.id_token
            self.cloud.access_token = cognito.access_token
            await self.cloud.run_executor(self.cloud.write_user_info)

        except ClientError as err:
            raise _map_aws_exception(err)

        except EndpointConnectionError:
            raise UnknownError() 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def s3errors(path):
    """Translate S3 errors to FSErrors."""
    try:
        yield
    except ClientError as error:
        _error = error.response.get("Error", {})
        error_code = _error.get("Code", None)
        response_meta = error.response.get("ResponseMetadata", {})
        http_status = response_meta.get("HTTPStatusCode", 200)
        error_msg = _error.get("Message", None)
        if error_code == "NoSuchBucket":
            raise errors.ResourceError(path, exc=error, msg=error_msg)
        if http_status == 404:
            raise errors.ResourceNotFound(path)
        elif http_status == 403:
            raise errors.PermissionDenied(path=path, msg=error_msg)
        else:
            raise errors.OperationFailed(path=path, exc=error)
    except SSLError as error:
        raise errors.OperationFailed(path, exc=error)
    except EndpointConnectionError as error:
        raise errors.RemoteConnectionError(path, exc=error, msg="{}".format(error)) 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def poll_status(session, _id):
    try:
        result = session.get_query_execution(
            QueryExecutionId=_id
        )
    except ClientError as e:
        if e.response['Error']['Code'] == 'InvalidRequestException':
            print("Please check your query_id. Error message:")
        else:
            print("ClientError. Error message:")
        print(e)
        return None
    except EndpointConnectionError as e:
        print('Please check your credentials including aws_region in config.ini file and Internet connection.',
              'Error message:')
        print(e)
        return None

    state = result['QueryExecution']['Status']['State']

    if state in ('SUCCEEDED', 'FAILED', 'CANCELLED'):
        return result
    else:
        print('Waiting for {} query to end'.format(_id))
        raise Exception 

# 需要导入模块: from botocore import exceptions [as 别名]
# 或者: from botocore.exceptions import EndpointConnectionError [as 别名]
def __call__(self, *args, **kwargs):
        self._tries = 2

        while self._tries > 0:
            try:
                return self.func(*args, **kwargs)
            except ClientError as ex:
                rex = ex.response['Error']['Code']

                if rex == 'OptInRequired':
                    self.log.info('Service not enabled for {} / {}'.format(
                        args[0].account.account_name,
                        self.func.__name__
                    ))
                    break
                else:
                    if not self.__backoff():
                        raise

            except OSError:
                self.log.exception('Retrying after OSError')
                if not self.__backoff():
                    raise

            except EndpointConnectionError as ex:
                self.log.error(ex)
                break