/// <summary>
/// Lists the assessment runs that correspond to the assessment templates that are specified
/// by the ARNs of the assessment templates.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the ListAssessmentRuns service method.</param>
///
/// <returns>The response from the ListAssessmentRuns service method, as returned by Inspector.</returns>
/// <exception cref="Amazon.Inspector.Model.AccessDeniedException">
/// You do not have required permissions to access the requested resource.
/// </exception>
/// <exception cref="Amazon.Inspector.Model.InternalException">
/// Internal server error.
/// </exception>
/// <exception cref="Amazon.Inspector.Model.InvalidInputException">
/// The request was rejected because an invalid or out-of-range value was supplied for
/// an input parameter.
/// </exception>
/// <exception cref="Amazon.Inspector.Model.NoSuchEntityException">
/// The request was rejected because it referenced an entity that does not exist. The
/// error code describes the entity.
/// </exception>
public ListAssessmentRunsResponse ListAssessmentRuns(ListAssessmentRunsRequest request)
{
var marshaller = new ListAssessmentRunsRequestMarshaller();
var unmarshaller = ListAssessmentRunsResponseUnmarshaller.Instance;
return Invoke<ListAssessmentRunsRequest,ListAssessmentRunsResponse>(request, marshaller, unmarshaller);
}
/// <summary>
/// Initiates the asynchronous execution of the ListAssessmentRuns operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListAssessmentRuns operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<ListAssessmentRunsResponse> ListAssessmentRunsAsync(ListAssessmentRunsRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new ListAssessmentRunsRequestMarshaller();
var unmarshaller = ListAssessmentRunsResponseUnmarshaller.Instance;
return InvokeAsync<ListAssessmentRunsRequest,ListAssessmentRunsResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Paginator for ListAssessmentRuns operation
///</summary>
public IListAssessmentRunsPaginator ListAssessmentRuns(ListAssessmentRunsRequest request)
{
return(new ListAssessmentRunsPaginator(this.client, request));
}
internal ListAssessmentRunsPaginator(IAmazonInspector client, ListAssessmentRunsRequest request)
{
this._client = client;
this._request = request;
}
/// <summary>
/// Initiates the asynchronous execution of the ListAssessmentRuns operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the ListAssessmentRuns operation on AmazonInspectorClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndListAssessmentRuns
/// operation.</returns>
public IAsyncResult BeginListAssessmentRuns(ListAssessmentRunsRequest request, AsyncCallback callback, object state)
{
var marshaller = new ListAssessmentRunsRequestMarshaller();
var unmarshaller = ListAssessmentRunsResponseUnmarshaller.Instance;
return BeginInvoke<ListAssessmentRunsRequest>(request, marshaller, unmarshaller,
callback, state);
}
private Amazon.Inspector.Model.ListAssessmentRunsResponse CallAWSServiceOperation(IAmazonInspector client, Amazon.Inspector.Model.ListAssessmentRunsRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Inspector", "ListAssessmentRuns");
try
{
#if DESKTOP
return(client.ListAssessmentRuns(request));
#elif CORECLR
return(client.ListAssessmentRunsAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
public object Execute(ExecutorContext context)
{
var cmdletContext = context as CmdletContext;
var useParameterSelect = this.Select.StartsWith("^") || this.PassThru.IsPresent;
// create request and set iteration invariants
var request = new Amazon.Inspector.Model.ListAssessmentRunsRequest();
if (cmdletContext.AssessmentTemplateArn != null)
{
request.AssessmentTemplateArns = cmdletContext.AssessmentTemplateArn;
}
// populate Filter
var requestFilterIsNull = true;
request.Filter = new Amazon.Inspector.Model.AssessmentRunFilter();
System.String requestFilter_filter_NamePattern = null;
if (cmdletContext.Filter_NamePattern != null)
{
requestFilter_filter_NamePattern = cmdletContext.Filter_NamePattern;
}
if (requestFilter_filter_NamePattern != null)
{
request.Filter.NamePattern = requestFilter_filter_NamePattern;
requestFilterIsNull = false;
}
List <System.String> requestFilter_filter_RulesPackageArn = null;
if (cmdletContext.Filter_RulesPackageArn != null)
{
requestFilter_filter_RulesPackageArn = cmdletContext.Filter_RulesPackageArn;
}
if (requestFilter_filter_RulesPackageArn != null)
{
request.Filter.RulesPackageArns = requestFilter_filter_RulesPackageArn;
requestFilterIsNull = false;
}
List <System.String> requestFilter_filter_State = null;
if (cmdletContext.Filter_State != null)
{
requestFilter_filter_State = cmdletContext.Filter_State;
}
if (requestFilter_filter_State != null)
{
request.Filter.States = requestFilter_filter_State;
requestFilterIsNull = false;
}
Amazon.Inspector.Model.TimestampRange requestFilter_filter_CompletionTimeRange = null;
// populate CompletionTimeRange
var requestFilter_filter_CompletionTimeRangeIsNull = true;
requestFilter_filter_CompletionTimeRange = new Amazon.Inspector.Model.TimestampRange();
System.DateTime?requestFilter_filter_CompletionTimeRange_completionTimeRange_BeginDate = null;
if (cmdletContext.CompletionTimeRange_BeginDate != null)
{
requestFilter_filter_CompletionTimeRange_completionTimeRange_BeginDate = cmdletContext.CompletionTimeRange_BeginDate.Value;
}
if (requestFilter_filter_CompletionTimeRange_completionTimeRange_BeginDate != null)
{
requestFilter_filter_CompletionTimeRange.BeginDate = requestFilter_filter_CompletionTimeRange_completionTimeRange_BeginDate.Value;
requestFilter_filter_CompletionTimeRangeIsNull = false;
}
System.DateTime?requestFilter_filter_CompletionTimeRange_completionTimeRange_EndDate = null;
if (cmdletContext.CompletionTimeRange_EndDate != null)
{
requestFilter_filter_CompletionTimeRange_completionTimeRange_EndDate = cmdletContext.CompletionTimeRange_EndDate.Value;
}
if (requestFilter_filter_CompletionTimeRange_completionTimeRange_EndDate != null)
{
requestFilter_filter_CompletionTimeRange.EndDate = requestFilter_filter_CompletionTimeRange_completionTimeRange_EndDate.Value;
requestFilter_filter_CompletionTimeRangeIsNull = false;
}
// determine if requestFilter_filter_CompletionTimeRange should be set to null
if (requestFilter_filter_CompletionTimeRangeIsNull)
{
requestFilter_filter_CompletionTimeRange = null;
}
if (requestFilter_filter_CompletionTimeRange != null)
{
request.Filter.CompletionTimeRange = requestFilter_filter_CompletionTimeRange;
requestFilterIsNull = false;
}
Amazon.Inspector.Model.DurationRange requestFilter_filter_DurationRange = null;
// populate DurationRange
var requestFilter_filter_DurationRangeIsNull = true;
requestFilter_filter_DurationRange = new Amazon.Inspector.Model.DurationRange();
System.Int32?requestFilter_filter_DurationRange_durationRange_MaxSecond = null;
if (cmdletContext.DurationRange_MaxSecond != null)
{
requestFilter_filter_DurationRange_durationRange_MaxSecond = cmdletContext.DurationRange_MaxSecond.Value;
}
if (requestFilter_filter_DurationRange_durationRange_MaxSecond != null)
{
requestFilter_filter_DurationRange.MaxSeconds = requestFilter_filter_DurationRange_durationRange_MaxSecond.Value;
requestFilter_filter_DurationRangeIsNull = false;
}
System.Int32?requestFilter_filter_DurationRange_durationRange_MinSecond = null;
if (cmdletContext.DurationRange_MinSecond != null)
{
requestFilter_filter_DurationRange_durationRange_MinSecond = cmdletContext.DurationRange_MinSecond.Value;
}
if (requestFilter_filter_DurationRange_durationRange_MinSecond != null)
{
requestFilter_filter_DurationRange.MinSeconds = requestFilter_filter_DurationRange_durationRange_MinSecond.Value;
requestFilter_filter_DurationRangeIsNull = false;
}
// determine if requestFilter_filter_DurationRange should be set to null
if (requestFilter_filter_DurationRangeIsNull)
{
requestFilter_filter_DurationRange = null;
}
if (requestFilter_filter_DurationRange != null)
{
request.Filter.DurationRange = requestFilter_filter_DurationRange;
requestFilterIsNull = false;
}
Amazon.Inspector.Model.TimestampRange requestFilter_filter_StartTimeRange = null;
// populate StartTimeRange
var requestFilter_filter_StartTimeRangeIsNull = true;
requestFilter_filter_StartTimeRange = new Amazon.Inspector.Model.TimestampRange();
System.DateTime?requestFilter_filter_StartTimeRange_startTimeRange_BeginDate = null;
if (cmdletContext.StartTimeRange_BeginDate != null)
{
requestFilter_filter_StartTimeRange_startTimeRange_BeginDate = cmdletContext.StartTimeRange_BeginDate.Value;
}
if (requestFilter_filter_StartTimeRange_startTimeRange_BeginDate != null)
{
requestFilter_filter_StartTimeRange.BeginDate = requestFilter_filter_StartTimeRange_startTimeRange_BeginDate.Value;
requestFilter_filter_StartTimeRangeIsNull = false;
}
System.DateTime?requestFilter_filter_StartTimeRange_startTimeRange_EndDate = null;
if (cmdletContext.StartTimeRange_EndDate != null)
{
requestFilter_filter_StartTimeRange_startTimeRange_EndDate = cmdletContext.StartTimeRange_EndDate.Value;
}
if (requestFilter_filter_StartTimeRange_startTimeRange_EndDate != null)
{
requestFilter_filter_StartTimeRange.EndDate = requestFilter_filter_StartTimeRange_startTimeRange_EndDate.Value;
requestFilter_filter_StartTimeRangeIsNull = false;
}
// determine if requestFilter_filter_StartTimeRange should be set to null
if (requestFilter_filter_StartTimeRangeIsNull)
{
requestFilter_filter_StartTimeRange = null;
}
if (requestFilter_filter_StartTimeRange != null)
{
request.Filter.StartTimeRange = requestFilter_filter_StartTimeRange;
requestFilterIsNull = false;
}
Amazon.Inspector.Model.TimestampRange requestFilter_filter_StateChangeTimeRange = null;
// populate StateChangeTimeRange
var requestFilter_filter_StateChangeTimeRangeIsNull = true;
requestFilter_filter_StateChangeTimeRange = new Amazon.Inspector.Model.TimestampRange();
System.DateTime?requestFilter_filter_StateChangeTimeRange_stateChangeTimeRange_BeginDate = null;
if (cmdletContext.StateChangeTimeRange_BeginDate != null)
{
requestFilter_filter_StateChangeTimeRange_stateChangeTimeRange_BeginDate = cmdletContext.StateChangeTimeRange_BeginDate.Value;
}
if (requestFilter_filter_StateChangeTimeRange_stateChangeTimeRange_BeginDate != null)
{
requestFilter_filter_StateChangeTimeRange.BeginDate = requestFilter_filter_StateChangeTimeRange_stateChangeTimeRange_BeginDate.Value;
requestFilter_filter_StateChangeTimeRangeIsNull = false;
}
System.DateTime?requestFilter_filter_StateChangeTimeRange_stateChangeTimeRange_EndDate = null;
if (cmdletContext.StateChangeTimeRange_EndDate != null)
{
requestFilter_filter_StateChangeTimeRange_stateChangeTimeRange_EndDate = cmdletContext.StateChangeTimeRange_EndDate.Value;
}
if (requestFilter_filter_StateChangeTimeRange_stateChangeTimeRange_EndDate != null)
{
requestFilter_filter_StateChangeTimeRange.EndDate = requestFilter_filter_StateChangeTimeRange_stateChangeTimeRange_EndDate.Value;
requestFilter_filter_StateChangeTimeRangeIsNull = false;
}
// determine if requestFilter_filter_StateChangeTimeRange should be set to null
if (requestFilter_filter_StateChangeTimeRangeIsNull)
{
requestFilter_filter_StateChangeTimeRange = null;
}
if (requestFilter_filter_StateChangeTimeRange != null)
{
request.Filter.StateChangeTimeRange = requestFilter_filter_StateChangeTimeRange;
requestFilterIsNull = false;
}
// determine if request.Filter should be set to null
if (requestFilterIsNull)
{
request.Filter = null;
}
// Initialize loop variants and commence piping
System.String _nextToken = null;
int? _emitLimit = null;
int _retrievedSoFar = 0;
if (AutoIterationHelpers.HasValue(cmdletContext.NextToken))
{
_nextToken = cmdletContext.NextToken;
}
if (AutoIterationHelpers.HasValue(cmdletContext.MaxResult))
{
_emitLimit = cmdletContext.MaxResult;
}
var _userControllingPaging = this.NoAutoIteration.IsPresent || ParameterWasBound(nameof(this.NextToken));
var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint);
do
{
request.NextToken = _nextToken;
if (_emitLimit.HasValue)
{
request.MaxResults = AutoIterationHelpers.ConvertEmitLimitToInt32(_emitLimit.Value);
}
CmdletOutput output;
try
{
var response = CallAWSServiceOperation(client, request);
object pipelineOutput = null;
if (!useParameterSelect)
{
pipelineOutput = cmdletContext.Select(response, this);
}
output = new CmdletOutput
{
PipelineOutput = pipelineOutput,
ServiceResponse = response
};
int _receivedThisCall = response.AssessmentRunArns.Count;
_nextToken = response.NextToken;
_retrievedSoFar += _receivedThisCall;
if (_emitLimit.HasValue)
{
_emitLimit -= _receivedThisCall;
}
}
catch (Exception e)
{
if (_retrievedSoFar == 0 || !_emitLimit.HasValue)
{
output = new CmdletOutput {
ErrorResponse = e
};
}
else
{
break;
}
}
ProcessOutput(output);
} while (!_userControllingPaging && AutoIterationHelpers.HasValue(_nextToken) && (!_emitLimit.HasValue || _emitLimit.Value >= 1));
if (useParameterSelect)
{
WriteObject(cmdletContext.Select(null, this));
}
return(null);
}