/// <inheritdoc />
public IOperation <TOperationState> CreateOperation(OperationId operationId, [DisallowNull] TOperationState state, IPropertyContainer?metadata = null)
{
var operation = Operation.CreateNotStarted(id: operationId, state: state, metadata: metadata);
_operations[operationId] = operation;
return(operation);
}
/// <summary>
/// Initializes a new instance of the <see cref="OperationManager{TSessionState, TOperationState}"/> class.
/// </summary>
/// <param name="sessionId">Session id.</param>
/// <param name="sessionState">Initial session state.</param>
/// <param name="sessionManager">Owner session manager.</param>
/// <param name="executionOptions">Optional execution options. Also can be provided in Start method.</param>
/// <param name="logger">Logger.</param>
/// <param name="metadata">Optional metadata.</param>
public OperationManager(
OperationId sessionId,
[DisallowNull] TSessionState sessionState,
ISessionManager <TSessionState, TOperationState> sessionManager,
IExecutionOptions <TSessionState, TOperationState>?executionOptions = null,
ILogger?logger = null,
IPropertyContainer?metadata = null)
{
sessionState.AssertArgumentNotNull(nameof(sessionState));
sessionManager.AssertArgumentNotNull(nameof(sessionManager));
_sessionManager = sessionManager;
_logger = logger ?? GetLoggerFactory().CreateLogger(sessionId.Value);
_operations = new ConcurrentDictionary <OperationId, IOperation <TOperationState> >();
_session = Operation
.CreateNotStarted(sessionId, sessionState, metadata)
.ToSession(getOperations: GetOperations);
if (executionOptions != null)
{
_session = _session.With(executionOptions: executionOptions);
}
ILoggerFactory GetLoggerFactory() =>
(ILoggerFactory?)_sessionManager.Services.GetService(typeof(ILoggerFactory)) ?? NullLoggerFactory.Instance;
}
/// <summary>
/// Initializes a new instance of the <see cref="Operation{TOperationState}"/> class.
/// </summary>
/// <param name="id">Operation id.</param>
/// <param name="state">Operation state.</param>
/// <param name="status">Operation status.</param>
/// <param name="startedAt">Date and time of start.</param>
/// <param name="finishedAt">Date and time of finish.</param>
/// <param name="exception">Exception occured on task execution.</param>
/// <param name="metadata">Optional metadata.</param>
public Operation(
OperationId id,
[DisallowNull] TOperationState state,
OperationStatus status,
LocalDateTime?startedAt,
LocalDateTime?finishedAt,
Exception?exception,
IPropertyContainer?metadata)
{
state.AssertArgumentNotNull(nameof(state));
Id = id;
State = state;
Status = status;
StartedAt = startedAt;
FinishedAt = finishedAt;
Exception = exception;
if (metadata == null)
{
// If state is metadata provider itself then use it as operation metadata.
if (state is IMetadataProvider stateMetadataProvider &&
stateMetadataProvider.GetMetadataContainer(autoCreate: false) is { } stateMetadata)
{
Metadata = stateMetadata.ToReadOnly();
}
else
{
Metadata = PropertyContainer.Empty;
}
}
/// <inheritdoc />
public IOperation <TOperationState> UpdateOperation(OperationId operationId, [DisallowNull] Action <OperationUpdateContext <TOperationState> > updateAction)
{
updateAction.AssertArgumentNotNull(nameof(updateAction));
IOperation <TOperationState> operation = GetOperationOrThrow(operationId);
IOperation <TOperationState> updatedOperation = operation;
var updateContext = new OperationUpdateContext <TOperationState>(operation);
updateAction(updateContext);
if (updateContext.NewState.IsNotNull() && !ReferenceEquals(updateContext.Operation.State, updateContext.NewState))
{
updatedOperation = operation.WithState(state: updateContext.NewState);
_operations.TryUpdate(operationId, updatedOperation, operation);
}
return(updatedOperation);
}
/// <inheritdoc />
public IOperation <TOperationState> UpdateOperation(OperationId operationId, [DisallowNull] IOperation <TOperationState> updatedOperation)
{
updatedOperation.AssertArgumentNotNull(nameof(updatedOperation));
IOperation <TOperationState> operation = GetOperationOrThrow(operationId);
if (!updatedOperation.Id.Equals(operationId))
{
throw new OperationManagerException(Errors.OperationIdDoesNotMatch(
providedOperationId: updatedOperation.Id,
existingOperationId: operationId));
}
if (!ReferenceEquals(updatedOperation, operation))
{
_operations.TryUpdate(operationId, updatedOperation, operation);
}
return(updatedOperation);
}
public IOperationManager <TSessionState, TOperationState> CreateOperationManager(
OperationId sessionId,
TSessionState sessionState,
IPropertyContainer?operationManagerMetadata = null)
{
ISessionManager <TSessionState, TOperationState> sessionManager = BuildSessionManager();
IOperationManager <TSessionState, TOperationState> operationManager = new OperationManager <TSessionState, TOperationState>(
sessionId: sessionId,
sessionState: sessionState,
sessionManager: sessionManager,
executionOptions: _executionOptions,
logger: null,
metadata: operationManagerMetadata);
sessionManager.AddOperationManager(operationManager);
return(operationManager);
}
/// <summary>
/// Error: Provided OperationId does not match existing OperationId.
/// </summary>
/// <param name="providedOperationId">Provided operation identifier.</param>
/// <param name="existingOperationId">Existing operation identifier.</param>
/// <returns>Error instance.</returns>
public static Error <ErrorCode> OperationIdDoesNotMatch(OperationId providedOperationId, OperationId existingOperationId) => Error.CreateError(
errorCode: ErrorCode.OperationIdDoesNotMatch,
messageTemplate: "Provided OperationId does not match existing OperationId. ProvidedOperationId: {providedOperationId}, ExistingOperationId: {existingOperationId}.",
args: new object[] { providedOperationId, existingOperationId });
/// <summary>
/// Error: Operation does not exists. OperationId: {operationId}.
/// </summary>
/// <param name="operationId">Operation identifier.</param>
/// <returns>Error instance.</returns>
public static Error <ErrorCode> OperationDoesNotExists(OperationId operationId) => Error.CreateError(
errorCode: ErrorCode.OperationDoesNotExists,
messageTemplate: "Operation does not exists. OperationId: {operationId}.",
args: operationId);
/// <summary>
/// Error: Session update is prohibited.
/// </summary>
/// <param name="sessionId">Session identifier.</param>
/// <param name="sessionStatus">Current session status.</param>
/// <returns>Error instance.</returns>
public static Error <ErrorCode> SessionUpdateIsProhibited(OperationId sessionId, string sessionStatus) => Error.CreateError(
errorCode: ErrorCode.SessionUpdateIsProhibited,
messageTemplate: "Session update is prohibited. You can change session only in NotStarted status. SessionId: {sessionId}, SessionStatus: {sessionStatus}.",
args: new object[] { sessionId, sessionStatus });
/// <summary>
/// Error: Session is already started. SessionId: {sessionId}.
/// </summary>
/// <param name="sessionId">Session identifier.</param>
/// <returns>Error instance.</returns>
public static Error <ErrorCode> SessionIsAlreadyStarted(OperationId sessionId) => Error.CreateError(
errorCode: ErrorCode.SessionIsAlreadyStarted,
messageTemplate: "Session is already started. SessionId: {sessionId}.",
args: sessionId);
/// <summary>
/// Error: Session does not exists. SessionId: {sessionId}.
/// </summary>
/// <param name="sessionId">Session identifier.</param>
/// <returns>Error instance.</returns>
public static Error <ErrorCode> SessionDoesNotExists(OperationId sessionId) => Error.CreateError(
errorCode: ErrorCode.SessionDoesNotExists,
messageTemplate: "Session does not exists. SessionId: {sessionId}.",
args: sessionId);
/// <inheritdoc />
public IOperation <TOperationState>?DeleteOperation(OperationId operationId)
{
_operations.TryRemove(operationId, out var deleted);
return(deleted);
}
/// <inheritdoc />
public IOperation <TOperationState>?GetOperation(OperationId operationId)
{
_operations.TryGetValue(operationId, out IOperation <TOperationState> operation);
return(operation);
}