private Dictionary <DateTime, long> GetTimelineStats(StatelessSessionWrapper session,
IDictionary <string, DateTime> keyMaps)
{
var valuesMap = session.Query <_AggregatedCounter>()
.Where(i => keyMaps.Keys.Contains(i.Key))
.ToDictionary(x => x.Key, x => x.Value);
foreach (var key in keyMaps.Keys)
{
if (!valuesMap.ContainsKey(key))
{
valuesMap.Add(key, 0);
}
}
var result = new Dictionary <DateTime, long>();
for (var i = 0; i < keyMaps.Count; i++)
{
var value = valuesMap[keyMaps.ElementAt(i).Key];
result.Add(keyMaps.ElementAt(i).Value, value);
}
return(result);
}
private JobList <FetchedJobDto> FetchedJobs(
StatelessSessionWrapper session,
IEnumerable <long> jobIds)
{
var list = jobIds.ToList();
if (list.Any())
{
var result = new List <KeyValuePair <string, FetchedJobDto> >();
foreach (var job in session.Query <_Job>().Where(i => list.Contains(i.Id)))
{
result.Add(new KeyValuePair <string, FetchedJobDto>(
job.Id.ToString(),
new FetchedJobDto
{
Job = DeserializeJob(job.InvocationData, job.Arguments),
State = job.StateName
}));
}
return(new JobList <FetchedJobDto>(result));
}
return(new JobList <FetchedJobDto>(new List <KeyValuePair <string, FetchedJobDto> >()));
}
/// <summary>
/// This method is invoked to allow
/// the scope to create a properly configured session
/// </summary>
/// <param name="sessionFactory">From where to open the session</param>
/// <param name="interceptor">the NHibernate interceptor</param>
/// <returns>the newly created session</returns>
protected override ISession CreateSession(ISessionFactory sessionFactory, IInterceptor interceptor)
{
ISession session = new StatelessSessionWrapper(sessionFactory.OpenStatelessSession());
session.BeginTransaction();
return(session);
}
/// <summary>
/// This method is invoked to allow
/// the scope to create a properly configured session
/// </summary>
/// <param name="sessionFactory">From where to open the session</param>
/// <param name="interceptor">the NHibernate interceptor</param>
/// <returns>the newly created session</returns>
protected override ISession CreateSession(ISessionFactory sessionFactory, IInterceptor interceptor)
{
ISession session = new StatelessSessionWrapper(sessionFactory.OpenStatelessSession());
session.BeginTransaction();
return session;
}
private void Commit(
StatelessSessionWrapper connection,
Action <FluentNHibernateWriteOnlyTransaction> action)
{
using (var transaction = new FluentNHibernateWriteOnlyTransaction(connection.Storage))
{
action(transaction);
transaction.Commit();
}
}
private static long CreateExpirationEntry(StatelessSessionWrapper session, DateTime?expireAt)
{
session.DeleteAll <_AggregatedCounter>();
var a = new _AggregatedCounter {
Key = "key", Value = 1, ExpireAt = expireAt
};
session.Insert(a);
return(a.Id);
}
private long GetNumberOfJobsByStateName(StatelessSessionWrapper session, string stateName)
{
var count = session.Query <_Job>().Count(i => i.StateName == stateName);
var jobListLimit = _storage.Options.DashboardJobListLimit;
if (jobListLimit.HasValue)
{
return(Math.Min(count, jobListLimit.Value));
}
return(count);
}
public static _Job InsertNewJob(StatelessSessionWrapper session, Action <_Job> action = null)
{
var newJob = new _Job
{
InvocationData = string.Empty,
Arguments = string.Empty,
CreatedAt = session.Storage.UtcNow
};
action?.Invoke(newJob);
session.Insert(newJob);
return(newJob);
}
private JobList <TDto> GetJobs <TDto>(
StatelessSessionWrapper session,
int from,
int count,
string stateName,
Func <_Job, Job, Dictionary <string, string>, TDto> selector)
{
var jobs = session.Query <_Job>()
.OrderByDescending(i => i.Id)
.Where(i => i.StateName == stateName)
.Skip(from)
.Take(count)
.ToList();
return(DeserializeJobs(jobs, selector));
}
public void Enqueue(StatelessSessionWrapper session, string queue, string jobId)
{
var converter = StringToInt32Converter.Convert(jobId);
if (!converter.Valid)
{
return;
}
session.Insert(new _JobQueue
{
Job = session.Query <_Job>().SingleOrDefault(i => i.Id == converter.Value),
Queue = queue
});
Logger.DebugFormat("Enqueued JobId={0} Queue={1}", jobId, queue);
}
private Dictionary <DateTime, long> GetHourlyTimelineStats(
StatelessSessionWrapper session,
string type)
{
var endDate = session.Storage.UtcNow;
var dates = new List <DateTime>();
for (var i = 0; i < 24; i++)
{
dates.Add(endDate);
endDate = endDate.AddHours(-1);
}
var keyMaps = dates.ToDictionary(x => string.Format("stats:{0}:{1}", type, x.ToString("yyyy-MM-dd-HH")),
x => x);
return(GetTimelineStats(session, keyMaps));
}
private static InsertTwoJobsResult InsertTwoJobs(StatelessSessionWrapper session, Action <_Job> action = null)
{
var insertTwoJobsResult = new InsertTwoJobsResult();
for (var i = 0; i < 2; i++)
{
var newJob = InsertNewJob(session, action);
if (i == 0)
{
insertTwoJobsResult.JobId1 = newJob.Id.ToString();
}
else
{
insertTwoJobsResult.JobId2 = newJob.Id.ToString();
}
}
return(insertTwoJobsResult);
}
private JobList <EnqueuedJobDto> EnqueuedJobs(
StatelessSessionWrapper session,
IEnumerable <long> jobIds)
{
var list = jobIds.ToList();
if (list.Any())
{
var jobs = session.Query <_Job>().Where(i => list.Contains(i.Id)).ToList();
return(DeserializeJobs(
jobs,
(sqlJob, job, stateData) => new EnqueuedJobDto
{
Job = job,
State = sqlJob.StateName,
EnqueuedAt = sqlJob.StateName == EnqueuedState.StateName
? JobHelper.DeserializeNullableDateTime(stateData["EnqueuedAt"])
: null
}));
}
return(new JobList <EnqueuedJobDto>(new List <KeyValuePair <string, EnqueuedJobDto> >()));
}
private static _Job GetTestJob(StatelessSessionWrapper connection, string jobId)
{
return(connection.Query <_Job>().Single(i => i.Id == long.Parse(jobId)));
}
private static bool IsEntryExpired(StatelessSessionWrapper session, long entryId)
{
var count = session.Query <_AggregatedCounter>().Count(i => i.Id == entryId);
return(count == 0);
}
