public void GetMonitoringApi_ReturnsNonNullInstance()
{
MongoStorage storage = CreateStorage();
IMonitoringApi api = storage.GetMonitoringApi();
Assert.NotNull(api);
}
public void GetMonitoringApi_ReturnsNonNullInstance()
{
CosmosDbStorage storage = new(url, secret, database, container);
IMonitoringApi api = storage.GetMonitoringApi();
Assert.NotNull(api);
}
public void WithExistingCosmosClient_GetMonitoringApi_ReturnsNonNullInstance()
{
CosmosDbStorage storage = CreateSutWithCosmosClient();
IMonitoringApi api = storage.GetMonitoringApi();
Assert.NotNull(api);
}
public RedisTagsMonitoringApi(IMonitoringApi monitoringApi)
{
if (monitoringApi.GetType().Name != "RedisMonitoringApi")
{
throw new ArgumentException("The monitor API is not implemented using Redis", nameof(monitoringApi));
}
_monitoringApi = monitoringApi;
// Dirty, but lazy...we would like to execute these commands in the same transaction, so we're resorting to reflection for now
// Other transaction type, clear cached methods
if (_type != monitoringApi.GetType())
{
_useConnection = null;
_type = monitoringApi.GetType();
}
if (_useConnection == null)
{
_useConnection = monitoringApi.GetType().GetTypeInfo().GetMethod(nameof(UseConnection),
BindingFlags.NonPublic | BindingFlags.Instance);
}
if (_useConnection == null)
{
throw new ArgumentException("The function UseConnection cannot be found.");
}
}
public async Task <object> RetryParticipationSyncImmediately(
CrmData data,
Configurations requestWideSettings,
bool requestConsumerId = false)
{
var jobId = await Task.Run(() => BackgroundJob.Enqueue <ICrmConsumerProvider>(
iCrmProvider =>
iCrmProvider.CreateParticipationAsync(
data,
requestWideSettings,
requestConsumerId)));
var result = new object();
IMonitoringApi monitoringApi = JobStorage.Current.GetMonitoringApi();
JobDetailsDto jobDetails = monitoringApi.JobDetails(jobId);
SucceededJobDto jobDto = monitoringApi.SucceededJobs(0, int.MaxValue)
.First()
//.FirstOrDefault(job => job.Key == "Key")
.Value;
if (jobDto != null)
{
result = jobDto.Result;
return(JsonConvert.DeserializeObject <CrmResponse>(result.ToString()));
}
return(null);
}
private static int serverCountFromHangfire(IMonitoringApi monitor)
{
var runningServerCount = _retry.Execute(() => monitor.Servers().Count);
const int startingServer = 1;
return(runningServerCount + startingServer);
}
internal int DetermineWorkerCount(IMonitoringApi monitor,
StoredConfiguration configuration,
WorkerDeterminerOptions options)
{
var goal = configuration.GoalWorkerCount ?? options.DefaultGoalWorkerCount;
if (goal > options.MaximumGoalWorkerCount)
{
goal = options.MaximumGoalWorkerCount;
}
var serverCount = _serverCountDeterminer.DetermineServerCount(monitor, options);
var workerCount = Convert.ToInt32(Math.Ceiling(goal / (decimal)serverCount));
if (configuration.MaxWorkersPerServer.HasValue)
{
if (workerCount > configuration.MaxWorkersPerServer.Value)
{
workerCount = configuration.MaxWorkersPerServer.Value;
}
}
if (workerCount < options.MinimumWorkerCount)
{
workerCount = options.MinimumWorkerCount;
}
return(workerCount);
}
public void GetMonitoringApi_ReturnsNonNullInstance()
{
LiteDbStorage storage = ConnectionUtils.CreateStorage();
IMonitoringApi api = storage.GetMonitoringApi();
Assert.NotNull(api);
}
public MySqlTagsMonitoringApi(IMonitoringApi monitoringApi)
{
if (monitoringApi.GetType().Name != "MySqlMonitoringApi")
{
throw new ArgumentException("The monitor API is not implemented using MySql", nameof(monitoringApi));
}
_monitoringApi = monitoringApi;
// Other transaction type, clear cached methods
if (_type != monitoringApi.GetType())
{
_useConnection = null;
_type = monitoringApi.GetType();
}
if (_useConnection == null)
{
_useConnection = monitoringApi.GetType().GetTypeInfo().GetMethod(nameof(UseConnection),
BindingFlags.NonPublic | BindingFlags.Instance);
}
if (_useConnection == null)
{
throw new ArgumentException("The function UseConnection cannot be found.");
}
}
public SqliteMonitoringApiTests()
{
var storage = GetRequiredService <IDataStorage>();
_monitoring = storage.GetMonitoringApi();
Initialize(storage);
}
public AspNetCoreDashboardContext(
DashboardOptions options,
HttpContext httpContext,
IMonitoringApi storage)
: base(options, storage)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
HttpContext = httpContext;
Request = new AspNetCoreDashboardRequest(httpContext);
Response = new AspNetCoreDashboardResponse(httpContext);
if (!options.IgnoreAntiforgeryToken)
{
var antiforgery = HttpContext.RequestServices.GetService <IAntiforgery>();
var tokenSet = antiforgery?.GetAndStoreTokens(HttpContext);
if (tokenSet != null)
{
AntiforgeryHeader = tokenSet.HeaderName;
AntiforgeryToken = tokenSet.RequestToken;
}
}
}
public JobManager(JobStorage jobStorage, IBackgroundJobClient backgroundJobClient, IPerformingContextAccessor performingContextAccessor, ILogger <JobManager> logger)
{
this.monitoringApi = jobStorage.GetMonitoringApi();
this.performingContextAccessor = performingContextAccessor;
this.logger = logger;
this.backgroundJobClient = backgroundJobClient;
}
private static void AppStartBackGroundJob(IAdminSettingService adminservice, IMonitoringApi monitor)
{
PurgeJobs(monitor);
RecurringJob.AddOrUpdate("GetSpojInfo", () => adminservice.GetSpojInfo(), "*/1 * * * *");
RecurringJob.AddOrUpdate("DownloadSpojTestCases", () => adminservice.DownloadSpojTestCases(), "*/1 * * * *");
RecurringJob.AddOrUpdate("GetSubmissionInfo", () => adminservice.GetSubmissionInfo(), "*/1 * * * *");
}
/// <summary>
/// Clear previous jobs
/// </summary>
private void ClearRecurringJobs()
{
try
{
using IStorageConnection connection = JobStorage.Current.GetConnection();
foreach (RecurringJobDto recurringJob in connection.GetRecurringJobs())
{
if (recurringJob != null)
{
RecurringJob.RemoveIfExists(recurringJob.Id);
}
}
IMonitoringApi monitoringApi = JobStorage.Current.GetMonitoringApi();
while (monitoringApi.Servers().Count > 1)
{
var serverToRemove = monitoringApi.Servers().Last();
connection.RemoveServer(serverToRemove.Name);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <summary>
/// Constructor.
/// </summary>
public JobQueueClient(
IBackgroundJobClient backgroundJobClient,
JobStorage jobStorage)
{
_backgroundJobClient = backgroundJobClient;
_monitoringApi = jobStorage.GetMonitoringApi();
}
private async Task WaitUntilJobCompletedAsync(string jobId, int maxWaitInMilliseconds = 5000)
{
IMonitoringApi monitoringApi = JobStorage.Current.GetMonitoringApi();
var sw = Stopwatch.StartNew();
JobDetailsDto jobDetails = null;
while ((jobDetails == null || jobDetails.History.All(s => s.StateName != "Succeeded")) && (sw.Elapsed.TotalMilliseconds < maxWaitInMilliseconds || Debugger.IsAttached))
{
await Task.Delay(25);
jobDetails = monitoringApi.JobDetails(jobId);
if (monitoringApi.FailedCount() > 0)
{
break;
}
}
FailedJobDto failedJob = monitoringApi
.FailedJobs(0, int.MaxValue)
.Select(j => j.Value)
.FirstOrDefault();
if (failedJob != null)
{
throw new InvalidOperationException($"Job failed: {failedJob.ExceptionDetails}.");
}
_client.Delete(jobId);
}
/// <summary>
/// Ctor initializing HangFire monitoring API object
/// </summary>
public HangFireHealthCheck(ILogger <HangFireHealthCheck> logger, IHealthCheckHangFireService healthCheckHangFireService, AppSettingsConfig appSettingsConfig)
{
_logger = logger;
_hangFireMonitoringApi = healthCheckHangFireService.GetHangFireMonitoringApi();
_healthCheckHangFireService = healthCheckHangFireService;
_appSettingsConfig = appSettingsConfig;
}
public static void PurgeOrfanJobsExceptList(this IMonitoringApi monitor, List <string> exceptions)
{
var toDelete = new List <string>();
foreach (QueueWithTopEnqueuedJobsDto queue in monitor.Queues())
{
for (var i = 0; i < Math.Ceiling(queue.Length / 1000d); i++)
{
monitor.EnqueuedJobs(queue.Name, 1000 * i, 1000)
.ForEach(x =>
{
if (!exceptions.Contains(x.Key))
{
toDelete.Add(x.Key);
}
else
{
Console.WriteLine("x.Key " + x.Key + " remains.");
}
}
);
}
}
foreach (var jobId in toDelete)
{
BackgroundJob.Delete(jobId);
}
}
public RedisTagsMonitoringApi(IMonitoringApi monitoringApi, RedisStorageOptions options)
{
if (monitoringApi.GetType().Name != "RedisMonitoringApi")
{
throw new ArgumentException("The monitor API is not implemented using Redis", nameof(monitoringApi));
}
_monitoringApi = monitoringApi;
// Dirty, but lazy...we would like to execute these commands in the same transaction, so we're resorting to reflection for now
var databaseFactory = monitoringApi.GetType().GetTypeInfo().GetField("_databaseFactory",
BindingFlags.NonPublic | BindingFlags.Instance);
if (databaseFactory == null)
{
throw new ArgumentException("The field _databaseFactory cannot be found.");
}
var getJobsWithPropertiesMethod = monitoringApi.GetType()
.GetMethod("GetJobsWithProperties", BindingFlags.Instance | BindingFlags.NonPublic);
if (getJobsWithPropertiesMethod == null)
{
throw new ArgumentException("The method GetJobsWithPropertiesMethod cannot be found.");
}
_getJobsWithPropertiesMethod = getJobsWithPropertiesMethod.MakeGenericMethod(typeof(MatchingJobDto));
var factory = (Func <object>)databaseFactory.GetValue(monitoringApi);
var objFactory = factory.Invoke();
_wrapper = new DatabaseWrapper(objFactory, options);
}
public void GetMonitoringApi_ReturnsNonNullInstance()
{
UseStorage(storage =>
{
IMonitoringApi api = storage.GetMonitoringApi();
Assert.NotNull(api);
});
}
public IActionResult GetStorage(string jobId)
{
IMonitoringApi jobMonitoringApi = JobStorage.Current.GetMonitoringApi();
//var jobMonitoringApi = JobStorage.Current.GetConnection();
var job = jobMonitoringApi.FailedJobs(0, int.MaxValue);
return(Ok());
}
/// <summary>
/// Removes all recurring jobs from queue
/// </summary>
public static void DeleteAllEnqueuedJobs(IMonitoringApi monitoringApi, string queue = "default")
{
var enqueuedJobs = monitoringApi.EnqueuedJobs(queue, 0, Int32.MaxValue).ToList();
foreach (var enqueuedJob in enqueuedJobs)
{
BackgroundJob.Delete(enqueuedJob.Key);
}
}
protected DashboardContext(DashboardOptions options, IMonitoringApi storage)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
Options = options;
_isReadOnlyLazy = new Lazy <bool>(() => options.IsReadOnlyFunc(this));
Storage = storage;
}
public int GetTotal(IMonitoringApi api)
{
if (string.Equals(StatusName, Infrastructure.StatusName.Succeeded,
StringComparison.CurrentCultureIgnoreCase))
{
return(api.ReceivedSucceededCount());
}
return(api.ReceivedFailedCount());
}
public int GetTotal(IMonitoringApi api)
{
if (string.Equals(Name, nameof(Internal.StatusName.Succeeded),
StringComparison.CurrentCultureIgnoreCase))
{
return(api.PublishedSucceededCount());
}
return(api.PublishedFailedCount());
}
/// <summary>
/// Initializes a new instance of the <see cref="BuildsController"/> class.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <param name="monitoringApi">
/// The monitoring api.
/// </param>
/// <param name="service">
/// The service.
/// </param>
public BuildsController(
DeploymentServerContext context,
IMonitoringApi monitoringApi,
IMofBuilderService service)
{
this.Context = context;
this.MonitoringApi = monitoringApi;
this.BuildRepository = context.Set <Build>();
this.BuildTargetsRepository = context.Set <BuildTarget>();
this.MofBuilderService = service;
}
public static void CancelAllJobs()
{
IMonitoringApi mon = JobStorage.Current.GetMonitoringApi();
JobList <ProcessingJobDto> processingJobs = mon.ProcessingJobs(0, int.MaxValue);
foreach (KeyValuePair <string, ProcessingJobDto> job in processingJobs)
{
BackgroundJob.Delete(job.Key);
LogHelper.Logger.Info($"Deleted Job {job.Key}");
}
}
private int readServerCount(IMonitoringApi monitor, WorkerDeterminerOptions options)
{
if (options.UseServerCountSampling)
{
var serverCount = serverCountFromSamples();
if (serverCount.HasValue)
{
return(serverCount.Value);
}
}
return(serverCountFromHangfire(monitor));
}
public int DetermineServerCount(IMonitoringApi monitor, WorkerDeterminerOptions options)
{
var serverCount = readServerCount(monitor, options);
if (options.MinimumServerCount.HasValue)
{
if (serverCount < options.MinimumServerCount)
{
return(options.MinimumServerCount.Value);
}
}
return(serverCount);
}
/// <summary>
/// Returns the status of the job with the given ID.
/// </summary>
public static Task <JobStatus> GetJobStatusAsync(IMonitoringApi monitoringApi, string jobId)
{
// TODO: Make this actually asynchronous once HangFire supports it.
var jobDetails = monitoringApi.JobDetails(jobId)
.History
.OrderByDescending(h => h.CreatedAt)
.FirstOrDefault();
var jobState = GetJobState(jobDetails);
var enteredState = jobDetails?.CreatedAt ?? DateTime.MinValue;
return(Task.FromResult(new JobStatus(jobState, enteredState)));
}
