public BankAccountManager(int idleTimeInSeconds = 0, string managerName = null, IOperationLogger logger = null, System.Data.IsolationLevel isolationLevel = System.Data.IsolationLevel.ReadCommitted) { _idleTimeInSeconds = idleTimeInSeconds; _managerName = managerName; _logger = logger; _isolationLevel = isolationLevel; }
// Constructors private OperationCapturer(Session session, IOperationLogger operations) : base(session) { ArgumentValidator.EnsureArgumentNotNull(operations, "operations"); Operations = operations; AttachEventHandlers(); }
public override void Execute(IOperation operation, IOperationLogger logger) { logger.Debug($"[Operation: {operation.ComplexOperationId}, note: {NoteId}] Sending notifications for users").Wait(); var note = noteFolderStore.GetNoteById(operation, NoteId).Result; var(_, users) = userDataStore.GetUsers(operation, new UserPagingRequest { PageNo = 0, PageSize = UserIds.Count(), Filter = new UserPagingFilter { Ids = UserIds } }).Result; foreach (var user in users) { var message = $"[Operation: {operation.ComplexOperationId}, note: {NoteId}] Note \"{note.FolderName}\" -> \"{note.Title}\":"; message += $"\n- The following user: {user.FirstName}{(!string.IsNullOrWhiteSpace(user.LastName) ? $" {user.LastName}" : "")} <{user.Email}>"; message += $"\n- The text:\n{note.Text}"; logger.Info(message).Wait(); } logger.Debug($"[Operation: {operation.ComplexOperationId}, note: {NoteId}] Sent notifications for users").Wait(); }
/// <nodoc /> public MetricsAdapter(IStructuredLogger logger, IOperationLogger operations) { Contract.RequiresNotNull(logger); Contract.RequiresNotNull(operations); Contract.Requires(logger != operations); _logger = logger; _operations = operations; }
/// <nodoc /> public MetricsAdapter(IStructuredLogger logger, IOperationLogger operationsLogger) { Contract.Requires(logger != null); Contract.Requires(operationsLogger != null); Contract.Requires(logger != operationsLogger); _logger = logger; _operationsLogger = operationsLogger; }
/// <summary> /// Initializes a new instance of the <see cref="RecurrentActivityManager"/> class. /// </summary> /// <param name="operationLogger">The operation logger.</param> /// <param name="monotonicTimer">Instance of <see cref="IMonotonicTimer"/> to aid in testability of the class.</param> public RecurrentActivityManager( IOperationLogger <RecurrentActivityManager> operationLogger, IMonotonicTimer monotonicTimer) { Contracts.CheckValue(operationLogger, nameof(operationLogger)); Contracts.CheckValue(monotonicTimer, nameof(monotonicTimer)); _operationLogger = operationLogger; _monotonicTimer = monotonicTimer; }
public LoadBalancingMiddleware( RequestDelegate next, ILogger <LoadBalancingMiddleware> logger, IOperationLogger <LoadBalancingMiddleware> operationLogger, ILoadBalancer loadBalancer) { _next = next ?? throw new ArgumentNullException(nameof(next)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _operationLogger = operationLogger ?? throw new ArgumentNullException(nameof(operationLogger)); _loadBalancer = loadBalancer ?? throw new ArgumentNullException(nameof(loadBalancer)); }
public AffinitizeRequestMiddleware( RequestDelegate next, IEnumerable <ISessionAffinityProvider> sessionAffinityProviders, IOperationLogger <AffinitizeRequestMiddleware> operationLogger, ILogger <AffinitizeRequestMiddleware> logger) { _next = next ?? throw new ArgumentNullException(nameof(next)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _sessionAffinityProviders = sessionAffinityProviders.ToProviderDictionary(); _operationLogger = operationLogger ?? throw new ArgumentNullException(nameof(operationLogger)); }
public override void Execute(IOperation operation, IOperationLogger logger) { try { ExecuteWithFallback(operation, logger); } catch (Exception e) { throw new CamundaWorkerBpmnError(e.Message, ErrorCode); } }
public ProxyInvokerMiddleware( RequestDelegate next, ILogger <ProxyInvokerMiddleware> logger, IOperationLogger <ProxyInvokerMiddleware> operationLogger, IHttpProxy httpProxy) { _next = next ?? throw new ArgumentNullException(nameof(next)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _operationLogger = operationLogger ?? throw new ArgumentNullException(nameof(operationLogger)); _httpProxy = httpProxy ?? throw new ArgumentNullException(nameof(httpProxy)); }
public AffinitizedDestinationLookupMiddleware( RequestDelegate next, IEnumerable <ISessionAffinityProvider> sessionAffinityProviders, IEnumerable <IAffinityFailurePolicy> affinityFailurePolicies, IOperationLogger <AffinitizedDestinationLookupMiddleware> operationLogger, ILogger <AffinitizedDestinationLookupMiddleware> logger) { _next = next ?? throw new ArgumentNullException(nameof(next)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _operationLogger = operationLogger ?? throw new ArgumentNullException(nameof(logger)); _sessionAffinityProviders = sessionAffinityProviders.ToProviderDictionary(); _affinityFailurePolicies = affinityFailurePolicies?.ToPolicyDictionary() ?? throw new ArgumentNullException(nameof(affinityFailurePolicies)); }
/// <summary> /// Initializes a new instance of the <see cref="BackendProberFactory"/> class. /// </summary> public BackendProberFactory(IMonotonicTimer timer, ILoggerFactory loggerFactory, IOperationLogger operationLogger, IHealthProbeHttpClientFactory httpClientFactory) { Contracts.CheckValue(timer, nameof(timer)); Contracts.CheckValue(loggerFactory, nameof(loggerFactory)); Contracts.CheckValue(operationLogger, nameof(operationLogger)); Contracts.CheckValue(httpClientFactory, nameof(httpClientFactory)); _timer = timer; _loggerFactory = loggerFactory; _httpClientFactory = httpClientFactory; _randomFactory = new RandomFactory(); _operationLogger = operationLogger; }
public override void Execute(IOperation operation, IOperationLogger logger) { if (!moduleStore.IsModuleExists(operation, ModuleId).Result) { throw CommonExceptions.ModuleWasNotFound(operation, ModuleId); } logger.Debug($"[Operation: {operation.ComplexOperationId}, module: {ModuleId}] Setting module status to \"{ModuleStatus.GetDescription()}\"").Wait(); moduleStore.ChangeStatus(operation, ModuleId, ModuleStatus).Wait(); logger.Debug($"[Operation: {operation.ComplexOperationId}, module: {ModuleId}] Module status was updated").Wait(); }
/// <summary> /// Initializes a new instance of the <see cref="ClusterProberFactory"/> class. /// </summary> public ClusterProberFactory( IMonotonicTimer timer, ILogger <ClusterProber> logger, IOperationLogger <ClusterProber> operationLogger, IHealthProbeHttpClientFactory httpClientFactory, IRandomFactory randomFactory) { _timer = timer ?? throw new ArgumentNullException(nameof(timer)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory)); _randomFactory = randomFactory ?? throw new ArgumentNullException(nameof(randomFactory)); _operationLogger = operationLogger ?? throw new ArgumentNullException(nameof(operationLogger)); }
public override void Execute(IOperation operation, IOperationLogger logger) { if (!moduleStore.IsModuleExists(operation, ModuleId).Result) { throw CommonExceptions.ModuleWasNotFound(operation, ModuleId); } logger.Debug($"[Operation: {operation.ComplexOperationId}, module: {ModuleId}] Removing module").Wait(); moduleStore.DeleteModule(operation, ModuleId).Wait(); logger.Debug($"[Operation: {operation.ComplexOperationId}, module: {ModuleId}] Module status was updated").Wait(); }
public override void Execute(IOperation operation, IOperationLogger logger) { if (!moduleStore.IsModuleExists(operation, ModuleId).Result) { throw CommonExceptions.ModuleWasNotFound(operation, ModuleId); } logger.Debug($"[Operation: {operation.ComplexOperationId}, module: {ModuleId}] Module update didn't complete successfully, setting status to \"{ModuleStatus.GetDescription()}\"").Wait(); moduleStore.ChangeStatus(operation, ModuleId, ModuleStatus).Wait(); moduleStore.AddModuleHistoryRecord(operation, ModuleId, ErrorMessage).Wait(); logger.Debug($"[Operation: {operation.ComplexOperationId}, module: {ModuleId}] Module status was updated").Wait(); }
/// <summary> /// Initializes a new instance of the <see cref="ClusterProber"/> class. /// HealthProber is the unit that checks the health state for all destinations(replica) of a cluster(service) /// HealthProbe would query the health controller of the destination and update the health state for every destination /// periodically base on the time interval user specified in cluster. /// </summary> public ClusterProber(string clusterId, ClusterConfig config, IDestinationManager destinationManager, IMonotonicTimer timer, ILogger <ClusterProber> logger, IOperationLogger <ClusterProber> operationLogger, HttpClient httpClient, IRandomFactory randomFactory) { ClusterId = clusterId ?? throw new ArgumentNullException(nameof(clusterId)); Config = config ?? throw new ArgumentNullException(nameof(config)); _destinationManager = destinationManager ?? throw new ArgumentNullException(nameof(destinationManager)); _timer = timer ?? throw new ArgumentNullException(nameof(timer)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _operationLogger = operationLogger ?? throw new ArgumentNullException(nameof(operationLogger)); _randomFactory = randomFactory ?? throw new ArgumentNullException(nameof(randomFactory)); _clusterProbeHttpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient)); _healthControllerUrl = new Uri(Config.HealthCheckOptions.Path, UriKind.Relative); _healthCheckInterval = Config.HealthCheckOptions.Interval; }
public override void Execute(IOperation operation, IOperationLogger logger) { Index++; if (ModuleIdsAndStatuses.Count > Index) { ModuleId = ModuleIdsAndStatuses.Keys.ToList()[Index]; ComponentsStopRequired = ModuleIdsAndStatuses.Values.ToList()[Index] == ModuleStatus.Run; } else { ModuleId = null; ComponentsStopRequired = null; } }
public ProxyInvoker( ILogger <ProxyInvoker> logger, IOperationLogger operationLogger, ILoadBalancer loadBalancer, IHttpProxy httpProxy) { Contracts.CheckValue(logger, nameof(logger)); Contracts.CheckValue(operationLogger, nameof(operationLogger)); Contracts.CheckValue(loadBalancer, nameof(loadBalancer)); Contracts.CheckValue(httpProxy, nameof(httpProxy)); _logger = logger; _operationLogger = operationLogger; _loadBalancer = loadBalancer; _httpProxy = httpProxy; }
protected override void ExecuteWithFallback(IOperation operation, IOperationLogger logger) { if (!moduleStore.IsModuleExists(operation, ModuleId).Result) { throw CommonExceptions.ModuleWasNotFound(operation, ModuleId); } logger.Debug($"[Operation: {operation.ComplexOperationId}, module: {ModuleId}] Starting to download module file configuration").Wait(); var module = moduleStore.GetModule(operation, ModuleId).Result; var fileId = (Regression ? Action switch { ActionType.Upgrade => module.PreviousConfiguration, ActionType.Downgrade => module.NextConfiguration, ActionType.NoChanges => module.CurrentConfiguration, _ => throw CommonExceptions.ModuleConfigurationWasNotFound(operation) } : module.CurrentConfiguration).FileId;
private async Task DeleteDeployment(IOperation operation, IOperationLogger logger, DeploymentListItem deployment) { var response = await new Deployment.DeleteRequest(deployment.Id) { Cascade = true }.SendRequest(operation, camundaClient); if (response.IsWithoutErrors()) { await logger.Info($"Camunda deployment was deleted:\n{JsonConvert.SerializeObject(deployment, Formatting.Indented)}"); } else { await logger.Error($"Camunda deployments wasn't deleted:\n{JsonConvert.SerializeObject(response.Errors, Formatting.Indented)}"); throw CommonExceptions.FailedToDeleteCamundaDeployment(operation); } }
internal Operation( OperationData operationData, string dataCenterName, IOperationLogger operationLogger) { this.operationData = operationData; this.startTime = DateTime.UtcNow; this.propertyBag = new Dictionary <string, object>(); this.operationLogger = operationLogger; this.errorLevel = ErrorLevel.None; this.dataCenter = dataCenterName; // Until explicitly marked as Failure, the operation result is always a Success this.operationResult = OperationResult.Success; // Only failure will have exception this.exception = string.Empty; }
public override void Execute(IOperation operation, IOperationLogger logger) { var moduleIdsAndStatuses = new Dictionary <int, ModuleStatus>(); foreach (var(id, instanceId) in ModuleProcessInstanceIds) { new ProcessInstance.DeleteRequest(instanceId) { FailIfNotExists = false }.SendRequest(operation, camundaClient, true).Wait(); moduleStore.ChangeStatus(operation, id, ModuleStatus.UpdatedToUninstall).Wait(); moduleIdsAndStatuses.Add(id, ModuleIdsAndStatuses[id]); } ModuleIdsAndStatuses = moduleIdsAndStatuses; var(moduleId, status) = moduleIdsAndStatuses.FirstOrDefault(); ModuleId = moduleId; ComponentsStopRequired = status == ModuleStatus.Run; }
public override void Execute(IOperation operation, IOperationLogger logger) { ModuleIdsAndStatuses = moduleStore.GetHostModuleIds(operation, HostId).Result; foreach (var(moduleId, _) in ModuleIdsAndStatuses) { var response = new ProcessInstance.GetListRequest { BusinessKey = moduleId.ToString(), ProcessDefinitionKeyIn = new[] { CamundaWorkerKey.ModuleInstallationProcess, CamundaWorkerKey.ModuleUpgradeProcess, CamundaWorkerKey.ModuleRollbackProcess } }.SendRequest(operation, camundaClient, true).Result; foreach (var item in response.Response) { ModuleProcessInstanceIds.Add(int.Parse(item.BusinessKey), item.Id); } } }
private async Task ExtendLock(IOperation operation, IOperationLogger logger, LockedExternalTaskListItem item, CancellationToken token) { while (true) { try { while (true) { await logger.Debug($"[Operation: {operation.ComplexOperationId}] Extending lock"); var response = await new ExternalTask.ExtendLockRequest(item.Id) { WorkerId = item.WorkerId, NewDuration = Properties.LockDuration }.SendRequest(operation, CamundaClient); if (!response.IsWithoutErrors()) { var retryAfter = TimeSpan.FromSeconds(5); await logger.Error($"[Operation: {operation.ComplexOperationId}] Couldn't extend lock for task, retry after {retryAfter}", response.ToLog()); await Task.Delay(retryAfter, token); } else { await logger.Debug($"[Operation: {operation.ComplexOperationId}] Extend lock process is successful"); await Task.Delay(TimeSpan.FromMilliseconds(Properties.LockDuration).Divide(2), token); break; } } } catch { break; } } }
/// <summary> /// Start the execution of a work item. /// </summary> /// <param name="operationLogger">Instance of <see cref="IOperationLogger"/>.</param> /// <param name="monotonicTimer">Instance of <see cref="IMonotonicTimer"/>.</param> internal async void Start(IOperationLogger <RecurrentActivityManager> operationLogger, IMonotonicTimer monotonicTimer) { Contracts.Check(_isExecuting == false, "Expected work item was not executing"); _isExecuting = true; LastExecution = monotonicTimer.CurrentTime; try { await operationLogger.ExecuteAsync( OperationName, async() => { await Func(_cts.Token); }); } catch (Exception e) when(!e.IsFatal()) { // Exceptions are not expected, but are already logged above and service must remain executing. } finally { _isExecuting = false; } }
/// <summary> /// Initializes a new instance of the <see cref="BackendProber"/> class. /// HealthProber is the unit that checks the health state for all destinations(replica) of a backend(service) /// HealthProbe would query the health controller of the destination and update the health state for every destination /// periodically base on the time interval user specified in backend. /// </summary> public BackendProber(string backendId, BackendConfig config, IDestinationManager destinationManager, IMonotonicTimer timer, ILogger <BackendProber> logger, IOperationLogger <BackendProber> operationLogger, HttpClient httpClient, IRandomFactory randomFactory) { Contracts.CheckValue(backendId, nameof(backendId)); Contracts.CheckValue(config, nameof(config)); Contracts.CheckValue(destinationManager, nameof(destinationManager)); Contracts.CheckValue(timer, nameof(timer)); Contracts.CheckValue(logger, nameof(logger)); Contracts.CheckValue(operationLogger, nameof(operationLogger)); Contracts.CheckValue(httpClient, nameof(httpClient)); Contracts.CheckValue(randomFactory, nameof(randomFactory)); BackendId = backendId; Config = config; _destinationManager = destinationManager; _timer = timer; _logger = logger; _operationLogger = operationLogger; _randomFactory = randomFactory; _healthControllerUrl = new Uri(Config.HealthCheckOptions.Path, UriKind.Relative); _healthCheckInterval = Config.HealthCheckOptions.Interval; _backendProbeHttpClient = httpClient; }
protected abstract void ExecuteWithFileConfiguration(IOperation operation, IOperationLogger logger, OperatingSystemInstructions instructions, IRemoteHostClientService client);
protected override void ExecuteWithFileConfiguration(IOperation operation, IOperationLogger logger, OperatingSystemInstructions instructions, IRemoteHostClientService client) { SendCommands(operation, logger, client, instructions.Camunda?.Workers?.Stop); }
public HomeController(IOperationStorage operationService, IResultStorage storage, IOperationLogger logger) { _operationService = operationService; _storage = storage; _logger = logger; }