public ActionResult <UpdateSessionResponse> Update([FromBody] UpdateSessionRequest request)
{
request.CommanderID = User.GetUserId();
var result = _sessionService.Update(request);
return(result);
}
/// <summary>
/// Updates the session identified by the session ID. A bastion session lets authorized users connect to a target resource for a predetermined amount of time.
/// </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>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/bastion/UpdateSession.cs.html">here</a> to see an example of how to use UpdateSession API.</example>
public async Task <UpdateSessionResponse> UpdateSession(UpdateSessionRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called updateSession");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/sessions/{sessionId}".Trim('/')));
HttpMethod method = new HttpMethod("PUT");
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).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <UpdateSessionResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"UpdateSession failed with error: {e.Message}");
throw;
}
}
public async Task <UpdateSessionResponse> Update(UpdateSessionRequest request)
{
var source = new CancellationTokenSource();
var result = SessionRegistryResult.Ok;
source.CancelAfter(SessionLockTimeoutDuration);
var session = request.Session;
var @lock = await _locker.AcquireAsync(session.Account.ToString(), cancellationToken : source.Token);
if (@lock != null)
{
var timeout = DateTime.UtcNow.Add(SessionTimeoutDuration);
if (!await _sessionAccountCache.ExistsAsync(request.Session.Account.ToString()))
{
result = SessionRegistryResult.FailedNotStarted;
}
if (result == SessionRegistryResult.Ok)
{
if (request.Session.State == SessionState.Offline)
{
await _sessionAccountCache.RemoveAsync(session.Account.ToString());
if (session.Character.HasValue)
{
await _sessionCharacterCache.RemoveAsync(session.Character.ToString());
}
}
else
{
await _sessionAccountCache.SetAsync(session.Account.ToString(), session, timeout);
if (session.Character.HasValue)
{
await _sessionCharacterCache.SetAsync(session.Character.Value.ToString(), session, timeout);
}
}
}
await @lock.ReleaseAsync();
}
else
{
result = SessionRegistryResult.FailedTimeout;
}
return(new UpdateSessionResponse {
Result = result
});
}
public async Task <Session> UpdateSessionAsync(string id, string newName, bool?access, bool?notifications, string newOwnerEmail, string newStatus, DateTime?newEndDate)
{
var req = new UpdateSessionRequest
{
Name = newName,
Restricted = access,
Notification = notifications,
OwnerEmailOrId = newOwnerEmail,
SessionEndDate = newEndDate,
Status = newStatus
};
var response = await Put <UpdateSessionRequest, Session>($"sessions/{id}", req);
return(response);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
UpdateSessionRequest request;
try
{
request = new UpdateSessionRequest
{
SessionId = SessionId,
UpdateSessionDetails = UpdateSessionDetails,
IfMatch = IfMatch,
OpcRequestId = OpcRequestId
};
response = client.UpdateSession(request).GetAwaiter().GetResult();
WriteOutput(response, response.Session);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}