private async Task <IActionResult> JsonCancelJobAsync <TId>() { var rawIds = Request.BodyAsJsonObject <TId[]>(); var ids = rawIds.ConvertAll(x => Convert.ToInt32(x)); if (ids != null) { int numDeleted = 0; foreach (var jobId in ids) { var job = await FindJobAsync(jobId); if (job.CanBeCancelled) { Backgrounder.ChangeState(jobId.ToString(), new CancelledState()); numDeleted++; } } if (numDeleted > 0) { return(NoContent()); } } return(NoContent()); }
/// <summary> /// Changes state of a job with the specified <paramref name="jobId"/> /// to the <see cref="EnqueuedState"/>. If <paramref name="fromState"/> value /// is not null, state change will be performed only if the current state name /// of a job equal to the given value. /// </summary> /// /// <param name="client">An instance of <see cref="IBackgroundJobClient"/> implementation.</param> /// <param name="jobId">Identifier of job, whose state is being changed.</param> /// <param name="fromState">Current state assertion, or null if unneeded.</param> /// <param name="queueName">The name of the queue to place the job in. This value overrides <see cref="QueueAttribute"/>.</param> /// <returns>True, if state change succeeded, otherwise false.</returns> public static bool Requeue( [NotNull] this IBackgroundJobClient client, [NotNull] string jobId, [CanBeNull] string fromState = null, [CanBeNull] string queueName = null) { if (client == null) { throw new ArgumentNullException(nameof(client)); } var state = new EnqueuedState(); if (queueName != null) { state.Queue = queueName; } else { var job = JobStorage.Current.GetConnection().GetJobData(jobId)?.Job; if (job != null) { state.Queue = job.QueueName; } } return(client.ChangeState(jobId, state, fromState)); }
public ActionResult SetFailed(string id) { var failedState = new FailedState(new Exception("Cambiando a fallida, provocado a proposito")); _backgroundJobClient.ChangeState(id, failedState); return(Ok()); }
/// <summary> /// Changes state of a job with the given <paramref name="jobId"/> to /// the specified one. /// </summary> /// /// <param name="client">An instance of <see cref="IBackgroundJobClient"/> implementation.</param> /// <param name="jobId">A job, whose state is being changed.</param> /// <param name="state">New state for a job.</param> /// <returns>True, if state change succeeded, otherwise false.</returns> public static bool ChangeState(this IBackgroundJobClient client, string jobId, IState state) { if (client == null) { throw new ArgumentNullException("client"); } return(client.ChangeState(jobId, state, null)); }
/// <summary> /// Changes state of a job with the given <paramref name="jobId"/> to /// the specified one. /// </summary> /// /// <param name="client">An instance of <see cref="IBackgroundJobClient"/> implementation.</param> /// <param name="jobId">A job, whose state is being changed.</param> /// <param name="state">New state for a job.</param> /// <returns>True, if state change succeeded, otherwise false.</returns> public static bool ChangeState( [NotNull] this IBackgroundJobClient client, [NotNull] string jobId, [NotNull] IState state) { if (client == null) { throw new ArgumentNullException(nameof(client)); } return(client.ChangeState(jobId, state, null)); }
/// <summary> /// Changes state of a job with the specified <paramref name="jobId"/> /// to the <see cref="EnqueuedState"/>. If <paramref name="fromState"/> value /// is not null, state change will be performed only if the current state name /// of a job equal to the given value. /// </summary> /// /// <param name="client">An instance of <see cref="IBackgroundJobClient"/> implementation.</param> /// <param name="jobId">Identifier of job, whose state is being changed.</param> /// <param name="fromState">Current state assertion, or null if unneeded.</param> /// <returns>True, if state change succeeded, otherwise false.</returns> public static bool Requeue(this IBackgroundJobClient client, string jobId, string fromState) { if (client == null) { throw new ArgumentNullException("client"); } var state = new EnqueuedState(); return(client.ChangeState(jobId, state, fromState)); }
public string Build() { try { // CREATING _buildAtom(this); // CREATED CreateAtomState(); // RUN _client.ChangeState(_atomId, _initialState); } catch { // FULL CLEANUP IN CASE OF FAIL foreach (var createdJobId in _createdSubAtoms) { _client.Delete(createdJobId.Key); } using (var connection = _jobStorage.GetJobStorageConnection()) { using var tr = connection.CreateJobStorageTransaction(); tr.RemoveSet(Atom.GenerateSubAtomKeys(_atomId)); var atomRemainingKeys = Atom.GenerateSubAtomRemainingKeys(_atomId); foreach (var activeSubatoms in _createdSubAtoms.Where(x => !x.Value.IsFinal)) { tr.RemoveFromSet(atomRemainingKeys, activeSubatoms.Key); } tr.Commit(); } _client.Delete(_atomId); throw; } return(_atomId); }
/// <summary> /// Changes state of a job with the specified <paramref name="jobId"/> /// to the <see cref="DeletedState"/>. If <paramref name="fromState"/> value /// is not null, state change will be performed only if the current state name /// of a job equal to the given value. /// </summary> /// /// <remarks> /// The job is not actually being deleted, this method changes only /// its state. /// /// This operation does not provides guarantee that the job will not be /// performed. If you deleting a job that is performing right now, it /// will be performed anyway, despite of this call. /// /// The method returns result of a state transition. It can be false /// if a job was expired, its method does not exist or there was an /// exception during the state change process. /// </remarks> /// /// <param name="client">An instance of <see cref="IBackgroundJobClient"/> implementation.</param> /// <param name="jobId">Identifier of job, whose state is being changed.</param> /// <param name="fromState">Current state assertion, or null if unneeded.</param> /// <returns>True, if state change succeeded, otherwise false.</returns> public static bool Delete( [NotNull] this IBackgroundJobClient client, [NotNull] string jobId, [CanBeNull] string fromState) { if (client == null) { throw new ArgumentNullException(nameof(client)); } var state = new DeletedState(); return(client.ChangeState(jobId, state, fromState)); }
public async Task <bool> RunNow(int userjobId) { bool ret = false; if (!await IsAlreadyRunning(userjobId)) { var record = await _dbService.GetBaseData(userjobId); if (record != null) { if (record.HfJobId != null) { if (record.IsRecurringJob()) { _logger.LogInformation("Manually triggering {t} userJobId {i}", record.JobType.ToString(), userjobId); _recClient.Trigger(record.HfJobId); ret = true; } else if (record.IsFireAndForgetOrScheduled()) { _logger.LogInformation("Manually triggering {t} userJobId {i}", record.JobType.ToString(), userjobId); _bgClient.ChangeState(record.HfJobId, new EnqueuedState()); ret = true; } else { throw new Exception($"Cannot manually run userJobId {userjobId}.Invalid JobType Detected."); } } else { _logger.LogWarning("Cannot manually run userJobId {i}. Because HfJobId is null.", userjobId); } } else { _logger.LogWarning("Cannot manually run userJobId {i}. Because user job is not found.", userjobId); } } else { _logger.LogWarning("Cannot manually run userJobId {i}. Because it is already running.", userjobId); } return(ret); }
private static void SetTriggerInternal( IBackgroundJobClient client, JobStorageConnection connection, string triggerName) { var triggerKey = GenerateTriggerKey(triggerName); var jobIds = connection.GetAllItemsFromList(triggerKey); try { using var _ = connection.AcquireDistributedLock(triggerKey, TimeSpan.Zero); foreach (var jobId in jobIds) { client.ChangeState(jobId, new EnqueuedState()); } } catch (DistributedLockTimeoutException) { // Assume already run } }
public string ResumeJob(IDSFDataObject dsfDataObject, string jobId, bool overrideVariables, string environment) { try { var monitoringApi = _jobStorage.GetMonitoringApi(); var jobDetails = monitoringApi.JobDetails(jobId); var currentState = jobDetails.History.OrderBy(s => s.CreatedAt).LastOrDefault(); if (currentState?.StateName != "Scheduled" && currentState?.StateName != "Failed") { return(GlobalConstants.Failed); } var values = jobDetails.Job.Args[0] as Dictionary <string, StringBuilder>; values.TryGetValue("environment", out StringBuilder persistedEnvironment); var decryptEnvironment = persistedEnvironment.ToString().CanBeDecrypted() ? DpapiWrapper.Decrypt(persistedEnvironment.ToString()) : persistedEnvironment.ToString(); if (overrideVariables) { if (values.ContainsKey("environment")) { values["environment"] = new StringBuilder(environment); } } else { values["environment"] = new StringBuilder(decryptEnvironment); } values.TryGetValue("currentuserprincipal", out StringBuilder currentUserPrincipal); var decryptCurrentUserPrincipal = currentUserPrincipal.ToString().CanBeDecrypted() ? DpapiWrapper.Decrypt(currentUserPrincipal.ToString()) : currentUserPrincipal.ToString(); if (values.ContainsKey("environment")) { values["currentuserprincipal"] = new StringBuilder(decryptCurrentUserPrincipal); } var workflowResume = new WorkflowResume(); var result = workflowResume.Execute(values, null); var serializer = new Dev2JsonSerializer(); var executeMessage = serializer.Deserialize <ExecuteMessage>(result); if (executeMessage.HasError) { var failedState = new FailedState(new Exception(executeMessage.Message?.ToString())); _client.ChangeState(jobId, failedState, ScheduledState.StateName); return(GlobalConstants.Failed); } values.TryGetValue("resourceID", out StringBuilder workflowId); values.TryGetValue("environment", out StringBuilder environments); values.TryGetValue("startActivityId", out StringBuilder startActivityId); values.TryGetValue("versionNumber", out StringBuilder versionNumber); values.TryGetValue("currentprincipal", out StringBuilder currentprincipal); _stateNotifier = dsfDataObject.StateNotifier; var audit = new Audit { WorkflowID = workflowId?.ToString(), Environment = environments?.ToString(), VersionNumber = versionNumber?.ToString(), NextActivityId = startActivityId?.ToString(), AuditDate = DateTime.Now, AuditType = "LogResumeExecutionState", LogLevel = LogLevel.Info, User = currentprincipal?.ToString() }; _stateNotifier?.LogAdditionalDetail(audit, nameof(ResumeJob)); var manuallyResumedState = new ManuallyResumedState(environments?.ToString()); _client.ChangeState(jobId, manuallyResumedState, currentState?.StateName); return(GlobalConstants.Success); } catch (Exception ex) { _stateNotifier?.LogExecuteException(ex, this); Dev2Logger.Error(nameof(ResumeJob), ex, GlobalConstants.WarewolfError); throw new Exception(ex.Message); } }
public bool ChangeState(string jobId, IState state, string expectedState) { return(_jobClient.ChangeState(jobId, state, expectedState)); }