list_signing_jobs async ¶

async def list_signing_jobs(
    self,
    *,
    config_overrides: Optional[AsyncsignerClientConfig] = None,
    status: Optional["capo_signer.types.signing_status.SigningStatus"] = None,
    platform_id: Optional["capo_signer.types.platform_id.PlatformId"] = None,
    requested_by: Optional["capo_signer.types.requested_by.RequestedBy"] = None,
    max_results: Optional["capo_signer.types.max_results.MaxResults"] = None,
    next_token: Optional["capo_signer.types.next_token.NextToken"] = None,
    is_revoked: Optional["capo_signer.types.bool.bool"] = None,
    signature_expires_before: Optional[
        "capo_signer.types.timestamp.Timestamp"
    ] = None,
    signature_expires_after: Optional[
        "capo_signer.types.timestamp.Timestamp"
    ] = None,
    job_invoker: Optional["capo_signer.types.account_id.AccountId"] = None,
) -> "capo_signer.types.list_signing_jobs_response.ListSigningJobsResponse":
    """<p>Lists all your signing jobs. You can use the <code>maxResults</code> parameter to limit the number of signing jobs that are returned in the response. If additional jobs remain to be listed, AWS Signer returns a <code>nextToken</code> value. Use this value in subsequent calls to <code>ListSigningJobs</code> to fetch the remaining values. You can continue calling <code>ListSigningJobs</code> with your <code>maxResults</code> parameter and with new values that Signer returns in the <code>nextToken</code> parameter until all of your signing jobs have been returned. </p>

    Args:
        status: <p>A status value with which to filter your results.</p>
        platform_id: <p>The ID of microcontroller platform that you specified for the distribution of your code image.</p>
        requested_by: <p>The IAM principal that requested the signing job.</p>
        max_results: <p>Specifies the maximum number of items to return in the response. Use this parameter when paginating results. If additional items exist beyond the number you specify, the <code>nextToken</code> element is set in the response. Use the <code>nextToken</code> value in a subsequent request to retrieve additional items. </p>
        next_token: <p>String for specifying the next set of paginated results to return. After you receive a response with truncated results, use this parameter in a subsequent request. Set it to the value of <code>nextToken</code> from the response that you just received.</p>
        is_revoked: <p>Filters results to return only signing jobs with revoked signatures.</p>
        signature_expires_before: <p>Filters results to return only signing jobs with signatures expiring before a specified timestamp.</p>
        signature_expires_after: <p>Filters results to return only signing jobs with signatures expiring after a specified timestamp.</p>
        job_invoker: <p>Filters results to return only signing jobs initiated by a specified IAM entity.</p>

    Raises:
        capo_signer.errors.access_denied_exception.AccessDeniedException: <p>You do not have sufficient access to perform this action.</p>
        capo_signer.errors.internal_service_error_exception.InternalServiceErrorException: <p>An internal error occurred.</p>
        capo_signer.errors.too_many_requests_exception.TooManyRequestsException: <p>The allowed number of job-signing requests has been exceeded.</p> <p>This error supersedes the error <code>ThrottlingException</code>.</p>
        capo_signer.errors.validation_exception.ValidationException: <p>You signing certificate could not be validated.</p>
        capo_signer.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_signer.types.list_signing_jobs_request.ListSigningJobsRequest]",
    ) -> AsyncOperationResponse[
        "capo_signer.types.list_signing_jobs_response.ListSigningJobsResponse"
    ]:
        import capo_signer._operations.wallaby_service.list_signing_jobs

        (
            output,
            http_response,
        ) = await capo_signer._operations.wallaby_service.list_signing_jobs.async_list_signing_jobs(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("ListSigningJobs")
    )
    input_: capo_signer.types.list_signing_jobs_request.ListSigningJobsRequest = {}
    if status is not None:
        input_["status"] = status
    if platform_id is not None:
        input_["platform_id"] = platform_id
    if requested_by is not None:
        input_["requested_by"] = requested_by
    if max_results is not None:
        input_["max_results"] = max_results
    if next_token is not None:
        input_["next_token"] = next_token
    if is_revoked is not None:
        input_["is_revoked"] = is_revoked
    if signature_expires_before is not None:
        input_["signature_expires_before"] = signature_expires_before
    if signature_expires_after is not None:
        input_["signature_expires_after"] = signature_expires_after
    if job_invoker is not None:
        input_["job_invoker"] = job_invoker

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output