private static JobQueue CreateJobQueue(RavenStorage storage, string queue, bool isFetched)
{
var jobId = Guid.NewGuid().ToString();
var job = new RavenJob
{
Id = storage.Repository.GetId(typeof(RavenJob), jobId),
CreatedAt = DateTime.UtcNow,
StateData = new StateData()
};
var jobQueue = new JobQueue
{
Id = storage.Repository.GetId(typeof(JobQueue), queue, jobId),
Queue = queue,
JobId = jobId
};
if (isFetched)
{
jobQueue.FetchedAt = DateTime.UtcNow.AddDays(-1);
}
using (var session = storage.Repository.OpenSession())
{
session.Store(job);
session.Store(jobQueue);
session.SaveChanges();
}
return(jobQueue);
}
public RavenDistributedLock([NotNull] RavenStorage storage, [NotNull] string resource, TimeSpan timeout, RavenStorageOptions options)
{
storage.ThrowIfNull("storage");
resource.ThrowIfNull("resource");
if ((timeout.TotalSeconds + CommandTimeoutAdditionSeconds) > int.MaxValue)
{
throw new ArgumentException(string.Format("The timeout specified is too large. Please supply a timeout equal to or less than {0} seconds",
int.MaxValue - CommandTimeoutAdditionSeconds),
"timeout");
}
_storage = storage;
_resource = resource;
_options = options;
if (!AcquiredLocks.Value.ContainsKey(_resource))
{
Acquire(_resource, timeout);
AcquiredLocks.Value[_resource] = 1;
}
else
{
AcquiredLocks.Value[_resource]++;
}
}
public RavenConnection(RavenStorage ravenStorage)
{
ravenStorage.ThrowIfNull("RavenStorage");
_storage = ravenStorage;
_options = new RavenStorageOptions();
}
public RavenDistributedLock(RavenStorage storage, string resource, TimeSpan timeout, RavenStorageOptions options)
{
storage.ThrowIfNull("storage");
if (string.IsNullOrEmpty(resource))
{
throw new ArgumentNullException(nameof(resource));
}
if (timeout.TotalSeconds > int.MaxValue)
{
throw new ArgumentException($"The timeout specified is too large. Please supply a timeout equal to or less than {int.MaxValue} seconds", nameof(timeout));
}
options.ThrowIfNull("options");
_storage = storage;
_resource = resource;
_options = options;
if (!AcquiredLocks.Value.ContainsKey(_resource) || AcquiredLocks.Value[_resource] == 0)
{
Acquire(timeout);
AcquiredLocks.Value[_resource] = 1;
StartHeartBeat();
}
else
{
AcquiredLocks.Value[_resource]++;
}
}
public RavenConnection(RavenStorage ravenStorage, RavenStorageOptions options)
: this(ravenStorage)
{
options.ThrowIfNull("options");
_storage = ravenStorage;
_options = options;
}
public RavenJobQueue([NotNull] RavenStorage storage, RavenStorageOptions options)
{
storage.ThrowIfNull("storage");
options.ThrowIfNull("options");
_storage = storage;
_options = options;
}
public RavenJobQueueProvider([NotNull] RavenStorage storage, [NotNull] RavenStorageOptions options)
{
storage.ThrowIfNull("storage");
options.ThrowIfNull("options");
_jobQueue = new RavenJobQueue(storage, options);
_monitoringApi = new RavenJobQueueMonitoringApi(storage);
}
private static void UseStorage(Action <RavenStorage> action)
{
using (var repository = new TestRepository())
{
var storage = new RavenStorage(repository);
action(storage);
}
}
public RavenWriteOnlyTransaction([NotNull] RavenStorage storage)
{
storage.ThrowIfNull("storage");
_storage = storage;
_patchRequests = new List <KeyValuePair <string, PatchRequest> >();
_session = _storage.Repository.OpenSession();
_session.Advanced.UseOptimisticConcurrency = true;
}
public static IGlobalConfiguration <RavenStorage> UseEmbeddedRavenStorage(this IGlobalConfiguration configuration)
{
configuration.ThrowIfNull("configuration");
Repository.Embedded = true;
var storage = new RavenStorage();
return(configuration.UseStorage(storage));
}
public static IGlobalConfiguration <RavenStorage> UseRavenStorage(this IGlobalConfiguration configuration, string connectionString)
{
configuration.ThrowIfNull("configuration");
connectionString.ThrowIfNull("connectionString");
Repository.ConnectionString = connectionString;
var storage = new RavenStorage();
return(configuration.UseStorage(storage));
}
public RavenFetchedJob(
[NotNull] RavenStorage storage,
JobQueue jobQueue)
{
storage.ThrowIfNull("storage");
jobQueue.ThrowIfNull("jobQueue");
_storage = storage;
JobId = jobQueue.JobId;
Queue = jobQueue.Queue;
Id = jobQueue.Id;
}
public RavenDistributedLock([NotNull] RavenStorage storage, [NotNull] string resource, TimeSpan timeout)
{
storage.ThrowIfNull("storage");
resource.ThrowIfNull("resource");
_timeout = timeout;
_storage = storage;
_resource = resource;
// -- Skip some locks
if (!_skipLocks.Any(a => _resource.StartsWith(a)))
{
Lock();
}
}
public static IGlobalConfiguration <RavenStorage> UseRavenStorage(this IGlobalConfiguration configuration, string connectionUrl, string database)
{
configuration.ThrowIfNull("configuration");
connectionUrl.ThrowIfNull("connectionUrl");
database.ThrowIfNull("database");
if (!connectionUrl.StartsWith("http"))
{
throw new ArgumentException("Connection Url must begin with http or https!");
}
Repository.ConnectionUrl = connectionUrl;
Repository.DefaultDatabase = database;
var storage = new RavenStorage();
return(configuration.UseStorage(storage));
}
private static string CreateJobQueueRecord(RavenStorage storage, string jobId, string queue)
{
var jobQueue = new JobQueue
{
Id = storage.Repository.GetId(typeof(JobQueue), queue, jobId),
JobId = jobId,
Queue = queue,
FetchedAt = DateTime.UtcNow
};
using (var session = storage.Repository.OpenSession())
{
session.Store(jobQueue);
session.SaveChanges();
}
return(jobQueue.Id);
}
private static RavenJobQueueMonitoringApi CreateRavenJobQueueMonitoringApi(RavenStorage storage)
{
return(new RavenJobQueueMonitoringApi(storage));
}
public RavenConnection(RavenStorage storage)
{
storage.ThrowIfNull("storage");
_storage = storage;
}
public RavenJobQueue([NotNull] RavenStorage storage, RavenStorageOptions options)
{
storage.ThrowIfNull("storage");
options.ThrowIfNull("options");
_storage = storage;
_options = options;
_queue = new Dictionary <string, BlockingCollection <JobQueue> >();
using (var session = _storage.Repository.OpenSession())
{
// -- Queue listening
if (options.QueueNames == null)
{
throw new ArgumentNullException("options.QueueNames", "You should define a set of QueueNames.");
}
var config = session.Load <RavenJobQueueConfig>("Config/RavenJobQueue")
?? new RavenJobQueueConfig();
foreach (var queue in options.QueueNames)
{
Console.WriteLine($"Starting on queue: {queue}");
// Creating queue
_queue.Add(queue, new BlockingCollection <JobQueue>());
// Create subscription (if not already exist)
if (!config.Subscriptions.ContainsKey(queue))
{
config.Subscriptions[queue] = _storage.Repository
.Subscriptions()
.Create <JobQueue>(new SubscriptionCriteria <JobQueue>()
{
KeyStartsWith = $"{Repository.GetId(typeof(JobQueue), queue)}/",
PropertiesMatch = new Dictionary <Expression <Func <JobQueue, object> >, RavenJToken>()
{
{ x => x.FetchedAt, RavenJToken.FromObject(null) }
}
});
}
// Open subscription
var subscription = _storage.Repository.Subscriptions().Open <JobQueue>(
config.Subscriptions[queue],
new SubscriptionConnectionOptions()
{
IgnoreSubscribersErrors = false,
Strategy = SubscriptionOpeningStrategy.ForceAndKeep
});
// Subscribe to it
subscription.Subscribe(new RepositoryObserver <JobQueue>(a =>
{
Console.WriteLine(a.Id);
_queue[queue].Add(a);
}));
}
session.Store(config);
session.SaveChanges();
}
}
public RavenWriteOnlyTransaction([NotNull] RavenStorage storage)
{
storage.ThrowIfNull("storage");
_storage = storage;
}
public RavenJobQueueMonitoringApi([NotNull] RavenStorage storage)
{
storage.ThrowIfNull("storage");
_storage = storage;
}
private static RavenJobQueue CreateJobQueue(RavenStorage storage)
{
return(new RavenJobQueue(storage, new RavenStorageOptions()));
}
public RavenConnection(RavenStorage ravenStorage)
{
ravenStorage.ThrowIfNull("RavenStorage");
_storage = ravenStorage;
}
