/// <summary>
/// Gets a migration source using the source ID.
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
public async Task <GetSourceResponse> GetSource(GetSourceRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called getSource");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/sources/{sourceId}".Trim('/')));
HttpMethod method = new HttpMethod("Get");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage);
}
return(Converter.FromHttpResponseMessage <GetSourceResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"GetSource failed with error: {e.Message}");
throw;
}
}
public ApiResult <string> LoadSource(GetSourceRequest request)
{
var cmd = new LoadSource(scriptProvider, request);
cmd.Execute();
return(cmd.Result);
}
public async Task <IActionResult> Produce(GetSourceRequest request)
{
var validatorActionResult = await _validationArrangement.Validate(request);
var actionResult = await _operationArrangement.Process(request, validatorActionResult);
return(actionResult);
}
public GetSourceQuery Map(GetSourceRequest request)
{
var id = new Guid(request.RouteId);
var result = new GetSourceQuery(id);
return(result);
}
public async Task <IActionResult> Get([FromRoute] GetSourceFromRoute route,
[FromQuery] GetSourceFromQuery query)
{
var request = new GetSourceRequest(route, query);
var result = await _apiResult.Produce(request);
return(result);
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetSourceRequest, GetSourceResponse> ForSource(GetSourceRequest request, WaiterConfiguration config, params SourceLifecycleStates[] targetStates)
{
var agent = new WaiterAgent <GetSourceRequest, GetSourceResponse>(
request,
request => client.GetSource(request),
response => targetStates.Contains(response.Source.LifecycleState.Value),
targetStates.Contains(SourceLifecycleStates.Deleted)
);
return(new Waiter <GetSourceRequest, GetSourceResponse>(config, agent));
}
public void LoadSource_DoesNotFindScriptSource()
{
reqDto = new GetSourceRequest
{
Script = toMatch,
SourceFileName = "nonexisting.js"
};
cmd = new LoadSource(scriptProvider, reqDto);
cmd.Execute();
var result = cmd.Result;
Assert.IsNotNull(result);
Assert.IsNotNull(result.Content);
Assert.IsFalse(result.Success);
Assert.AreEqual("empty", result.Content);
scriptProviderMock.Verify(s => s.Scripts, Times.Once);
}
public void LoadSource_FindsScript()
{
reqDto = new GetSourceRequest
{
Script = toMatch,
SourceFileName = "script.js"
};
cmd = new LoadSource(scriptProvider, reqDto);
cmd.Execute();
var result = cmd.Result;
Assert.IsNotNull(result);
Assert.IsNotNull(result.Content);
Assert.IsTrue(result.Success);
Assert.AreEqual(toMatch.SourceFiles.First().Contents, result.Content);
scriptProviderMock.Verify(s => s.Scripts, Times.Once);
}
private void HandleOutput(GetSourceRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForSource(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetSource(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.Source);
}
public async Task<IActionResult> Process(GetSourceRequest request, IValidatorActionResult validatorActionResult)
{
IActionResult actionResult;
if (validatorActionResult.Result == null)
{
var call = _cqsMapper.Map(request);
var result = await _mediator.Send(call);
actionResult = result.IsFailure ? _apiResponse.Fail(result)
: _apiResponse.Ok(((Result<SourceModel>)result).Value, ((Result<SourceModel>)result).Version.ToString());
}
else
{
actionResult = validatorActionResult.Result;
}
return actionResult;
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetSourceRequest request;
try
{
request = new GetSourceRequest
{
SourceId = SourceId,
OpcRequestId = OpcRequestId
};
HandleOutput(request);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetSourceRequest request;
try
{
request = new GetSourceRequest
{
SourceId = SourceId,
OpcRequestId = OpcRequestId
};
response = client.GetSource(request).GetAwaiter().GetResult();
WriteOutput(response, response.Source);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public LoadSource(IScriptProvider s, GetSourceRequest script)
{
scriptProvider = s;
request = script;
}
/// <summary>
/// Creates a waiter using default wait configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <GetSourceRequest, GetSourceResponse> ForSource(GetSourceRequest request, params SourceLifecycleStates[] targetStates)
{
return(this.ForSource(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates));
}