/// <summary>
/// Try Aquire the lock. If success it will return a successful <see cref="LockLeaseResult"/>.
/// If the lockmanger throws a <seealso cref="LockManagerLockException"/> it will catch that and return a failed <see cref="LockLeaseResult"/>.
/// In case of failure it will retry sometimes before calling it a day.
/// </summary>
/// <param name="manager"></param>
/// <param name="name"></param>
/// <param name="retryCount"></param>
/// <param name="retryAfter"></param>
/// <returns></returns>
public static async Task <LockLeaseResult> TryAquireLockWithRetryPolicy(this ILockManager manager, string name, int retryCount = 3, int retryAfter = 3)
{
var policy = Policy.HandleResult <LockLeaseResult>(lockLeaseResult => !lockLeaseResult.Ok)
.WaitAndRetryAsync(retryCount, retryAttempt => TimeSpan.FromSeconds(retryAfter));
return(await policy.ExecuteAsync(async() => await manager.TryAquireLock(name)));
}
/// <summary>
/// Adds a lock to be tracked by this cleanup task.
/// </summary>
/// <param name="lockManager">The lock manager that created this active lock.</param>
/// <param name="activeLock">The active lock to track</param>
public void Add(ILockManager lockManager, IActiveLock activeLock)
{
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace($"Adding lock {activeLock}");
}
// Don't track locks with infinite timeout
if (activeLock.Timeout == TimeoutHeader.Infinite)
{
return;
}
lock (_syncRoot)
{
var newLockItem = new ActiveLockItem(lockManager, activeLock);
_activeLocks.Add(activeLock.Expiration, newLockItem);
if (_mostRecentExpirationLockItem != null &&
newLockItem.Expiration >= _mostRecentExpirationLockItem.Expiration)
{
// New item is not the most recent to expire
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"New lock {activeLock.StateToken} item is not the most recent item");
}
return;
}
_mostRecentExpirationLockItem = newLockItem;
ConfigureTimer(newLockItem);
}
}
private async Task TestSingleLockAsync(ISet <string> releasedLocks, ILockManager lockManager, CancellationToken ct)
{
var l = new Lock(
"/",
"/",
false,
new XElement("test"),
LockAccessType.Write,
LockShareMode.Exclusive,
TimeSpan.FromMilliseconds(100));
var sem = new SemaphoreSlim(0, 1);
var evt = new EventHandler <LockEventArgs>((s, e) =>
{
Assert.True(releasedLocks.Add(e.Lock.StateToken));
sem.Release();
});
lockManager.LockReleased += evt;
try
{
var stopwatch = new Stopwatch();
stopwatch.Start();
await lockManager.LockAsync(l, ct);
Assert.True(await sem.WaitAsync(5000, ct));
stopwatch.Stop();
Assert.True(
stopwatch.ElapsedMilliseconds >= 90,
$"Duration should be at least 100ms, but was {stopwatch.ElapsedMilliseconds}");
}
finally
{
lockManager.LockReleased -= evt;
}
}
private JobberSupervisor()
{
if (JobberConfiguration.ProducerMode == ProducerMode.ActivePassive)
{
_lockManager = RedisLockManager.Instance.Initialize(JobberConfiguration.RedisEndPoints.ToArray(), JobberConfiguration.RedisPassword);
}
}
public ContextManagerNested(
ILockManager lockManager,
ContextControllerFactoryServiceContext factoryServiceContext)
{
_iLock = lockManager.CreateLock(GetType());
_contextName = factoryServiceContext.ContextName;
_servicesContext = factoryServiceContext.ServicesContext;
_contextPartitionIdManager = factoryServiceContext.AgentInstanceContextCreate.StatementContext.ContextControllerFactoryService.AllocatePartitionIdMgr(
_contextName, factoryServiceContext.AgentInstanceContextCreate.StatementContext.StatementId);
_nestedContextFactories = factoryServiceContext.AgentInstanceContextCreate.StatementContext.ContextControllerFactoryService.GetFactory(
factoryServiceContext);
StatementAIResourceRegistryFactory resourceRegistryFactory =
() => new StatementAIResourceRegistry(new AIRegistryAggregationMap(), new AIRegistryExprMap());
var contextProps = ContextPropertyEventType.GetNestedTypeBase();
foreach (var factory in _nestedContextFactories)
{
contextProps.Put(factory.FactoryContext.ContextName, factory.ContextBuiltinProps);
}
var contextPropsType = _servicesContext.EventAdapterService.CreateAnonymousMapType(
_contextName, contextProps, true);
var registry = new ContextPropertyRegistryImpl(
Collections.GetEmptyList <ContextDetailPartitionItem>(), contextPropsType);
_contextDescriptor = new ContextDescriptor(
_contextName, false, registry, resourceRegistryFactory, this, factoryServiceContext.Detail);
}
/// <summary>Ctor. </summary>
public ValueAddEventServiceImpl(ILockManager lockManager)
{
_lockManager = lockManager;
SpecificationsByRevisionName = new Dictionary <String, RevisionSpec>().WithNullSupport();
ProcessorsByNamedWindow = new Dictionary <String, ValueAddEventProcessor>().WithNullSupport();
VariantProcessors = new Dictionary <String, ValueAddEventProcessor>().WithNullSupport();
}
public EventBusSource(
ILockManager lockManager,
IThreadLocalManager threadLocalManager)
{
_iLock = lockManager.CreateLock(GetType());
_collectorDataTL = threadLocalManager.Create <EPDataFlowEventBeanCollectorContext>(() => null);
}
public EPDeploymentAdminImpl(
EPAdministratorSPI epService,
ILockManager lockManager,
IReaderWriterLock eventProcessingRWLock,
IResourceManager resourceManager,
DeploymentStateService deploymentStateService,
StatementEventTypeRef statementEventTypeRef,
EventAdapterService eventAdapterService,
StatementIsolationService statementIsolationService,
FilterService filterService,
TimeZoneInfo timeZone,
ConfigurationEngineDefaults.UndeployRethrowPolicy undeployRethrowPolicy)
{
_iLock = lockManager.CreateDefaultLock();
_epService = epService;
_resourceManager = resourceManager;
_eventProcessingRwLock = eventProcessingRWLock;
_deploymentStateService = deploymentStateService;
_statementEventTypeRef = statementEventTypeRef;
_eventAdapterService = eventAdapterService;
_statementIsolationService = statementIsolationService;
_filterService = filterService;
_timeZone = timeZone;
_undeployRethrowPolicy = undeployRethrowPolicy;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="lockManager">The lock manager.</param>
/// <param name="knownTypes">types known at cache construction type, may be an empty list for the ANY type variance.</param>
public VariantPropertyGetterCache(ILockManager lockManager, EventType[] knownTypes)
{
_iLock = lockManager.CreateLock(GetType());
_knownTypes = knownTypes;
_allGetters = new Dictionary <EventType, VariantPropertyGetterRow>();
_properties = new List <String>();
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="timeZone">The time zone.</param>
/// <param name="hasYear">if set to <c>true</c> [has year].</param>
/// <param name="hasMonth">if set to <c>true</c> [has month].</param>
/// <param name="hasWeek">if set to <c>true</c> [has week].</param>
/// <param name="hasDay">true if the expression has that part, false if not</param>
/// <param name="hasHour">true if the expression has that part, false if not</param>
/// <param name="hasMinute">true if the expression has that part, false if not</param>
/// <param name="hasSecond">true if the expression has that part, false if not</param>
/// <param name="hasMillisecond">true if the expression has that part, false if not</param>
/// <param name="hasMicrosecond">if set to <c>true</c> [has microsecond].</param>
/// <param name="timeAbacus">The time abacus.</param>
/// <param name="lockManager">The lock manager.</param>
public ExprTimePeriodImpl(
TimeZoneInfo timeZone,
bool hasYear,
bool hasMonth,
bool hasWeek,
bool hasDay,
bool hasHour,
bool hasMinute,
bool hasSecond,
bool hasMillisecond,
bool hasMicrosecond,
TimeAbacus timeAbacus,
ILockManager lockManager)
{
_lockManager = lockManager;
_timeZone = timeZone;
_hasYear = hasYear;
_hasMonth = hasMonth;
_hasWeek = hasWeek;
_hasDay = hasDay;
_hasHour = hasHour;
_hasMinute = hasMinute;
_hasSecond = hasSecond;
_hasMillisecond = hasMillisecond;
_hasMicrosecond = hasMicrosecond;
_timeAbacus = timeAbacus;
}
/// <summary>
/// Tries to acquire the lock indefinitely until the action succeeds.
/// </summary>
/// <param name="manager">The instance of <see cref="ILockManager"/>.</param>
/// <param name="name">Topic or name.</param>
/// <param name="retryAfter">Specifies the duration in seconds to wait for a particular retry attempt.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>The task that represents the asynchronous operation result for acquiring the lock.</returns>
public static async Task <LockLeaseResult> TryAcquireLockForeverPolicy(this ILockManager manager, string name, int retryAfter = 3, CancellationToken cancellationToken = default)
{
var policy = Policy.HandleResult <LockLeaseResult>(lockLeaseResult => !lockLeaseResult.Ok)
.WaitAndRetryForeverAsync(retryAttempt => TimeSpan.FromSeconds(retryAfter));
return(await policy.ExecuteAsync(token => manager.TryAcquireLock(name), cancellationToken));
}
static async void A2(ILockManager manager)
{
// wait one second
await Task.Delay(1000);
// check if it's locked
LockToken existingLock = await manager.QueryAsync("tandem://devices/Wow");
if (existingLock.IsValid)
{
Console.WriteLine($"It's locked by '{existingLock.Owner}'");
}
// now try and obtain a lock
await Task.Delay(2000);
using (var h = await manager.LockAsync("tandem://devices/wow")) {
if (h == null)
{
Console.WriteLine("Couldn't get a lock!");
}
else
{
Console.WriteLine("Got a lock!");
ProceedSemaphore.Release();
}
}
}
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (_lockManager == null)
{
//http://www.strathweb.com/2012/11/asp-net-web-api-and-dependencies-in-request-scope/
_lockManager = request.GetDependencyScope().GetService(typeof(ILockManager)) as ILockManager;
}
// Preconditions
HttpResponseMessage error;
if (!TryNoLockTokenMatchesRequestUri(request, out error))
{
return base.SendAsync(request, cancellationToken)
.ContinueWith<HttpResponseMessage>((responseToCompleteTask) => { return error; });
}
if (!TryNoLockTokenSubmitted(request, out error))
{
return base.SendAsync(request, cancellationToken)
.ContinueWith<HttpResponseMessage>((responseToCompleteTask) => { return error; });
}
if (!TryNoConflictingLock(request, out error))
{
return base.SendAsync(request, cancellationToken)
.ContinueWith<HttpResponseMessage>((responseToCompleteTask) => { return error; });
}
return base.SendAsync(request, cancellationToken);
}
/// <summary>
/// This is for internal use only.
/// Removes the lock context
/// </summary>
/// <param name="lockManager">Lock manager object which contains the lock to be removed</param>
/// <param name="lockOrKey">name of the lock</param>
/// <returns>LockContext object if found. null otherwise</returns>
public LockContext RemoveLockContext(ILockManager lockManager, object lockOrKey)
{
if (lockManager == null)
{
throw new ArgumentNullException(
string.Format(CultureInfo.CurrentCulture, SR.Error_NullArgument_Formatted, "lockManager"));
}
if (lockOrKey == null)
{
throw new ArgumentNullException(
string.Format(CultureInfo.CurrentCulture, SR.Error_NullArgument_Formatted, "lockOrKey"));
}
LockContext removedLockContext = null;
for (var i = 0; i < this.LockContexts.Count; i++)
{
var lockContext = this.LockContexts[i];
if (lockContext.IsEqual(lockManager, lockOrKey) == true)
{
this.LockContexts.RemoveAt(i);
removedLockContext = lockContext;
break;
}
}
return(removedLockContext);
}
public ScheduledJob(TaskHandlerActivator taskHandlerActivator, IScheduledTaskStore <TState> scheduledTaskStore, ILogger <ScheduledJob <TTaskHandler, TState> > logger, IConfiguration configuration, ILockManager lockManager)
{
_taskHandlerActivator = taskHandlerActivator ?? throw new ArgumentNullException(nameof(taskHandlerActivator));
_scheduledTaskStore = scheduledTaskStore ?? throw new ArgumentNullException(nameof(scheduledTaskStore));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_lockManager = lockManager ?? throw new ArgumentNullException(nameof(lockManager));
}
public EPStatementSource(
ILockManager lockManager,
IThreadLocalManager threadLocalManager)
{
_iLock = lockManager.CreateLock(MethodBase.GetCurrentMethod().DeclaringType);
_collectorDataTL = threadLocalManager.Create <EPDataFlowIRStreamCollectorContext>(() => null);
_lifeCycleEventHandler = Observe;
}
/// <summary>
/// Initializes a new instance of the <see cref="LockHandler"/> class.
/// </summary>
/// <param name="context">The WebDAV request context</param>
/// <param name="rootFileSystem">The root file system</param>
/// <param name="lockManager">The lock manager</param>
/// <param name="timeoutPolicy">The timeout policy for the selection of the <see cref="TimeoutHeader"/> value</param>
public LockHandler(IWebDavContext context, IFileSystem rootFileSystem, ILockManager lockManager = null, ITimeoutPolicy timeoutPolicy = null)
{
_context = context;
_rootFileSystem = rootFileSystem;
_lockManager = lockManager;
_timeoutPolicy = timeoutPolicy;
HttpMethods = _lockManager == null ? new string[0] : new[] { "LOCK" };
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="timeSourceService">time source provider</param>
/// <param name="lockManager">The lock manager.</param>
public SchedulingServiceImpl(TimeSourceService timeSourceService, ILockManager lockManager)
{
_uLock = lockManager.CreateLock(GetType());
_timeHandleMap = new SortedList <long, IDictionary <long, ScheduleHandle> >();
_handleSetMap = new Dictionary <ScheduleHandle, IDictionary <long, ScheduleHandle> >();
// initialize time to just before now as there is a check for duplicate external time events
_currentTime = timeSourceService.GetTimeMillis() - 1;
}
public SharedDataController(ISharedDataManager sharedDataManager, IAuditManager auditManager,
ILockManager lockManager, ITiersManager tiersManager)
{
_sharedDataManager = sharedDataManager;
_auditManager = auditManager;
_lockManager = lockManager;
_tiersManager = tiersManager;
}
public FilterServiceLockCoarse(
ILockManager lockManager,
IReaderWriterLockManager rwLockManager,
bool allowIsolation)
: base(lockManager, FilterServiceGranularLockFactoryNone.Instance, allowIsolation)
{
_iLock = rwLockManager.CreateLock(GetType());
}
/// <summary>
/// Initializes a new instance of the <see cref="HealthWorker"/> class.
/// </summary>
/// <param name="processor">The parent processor.</param>
/// <param name="name">The name of the worker.</param>
public HealthWorker(IMessageProcessor processor, string name)
: base(processor, name)
{
// create throttle lock to only allow one run per schedule
var lockCollection = Configuration.LockCollection ?? "ServiceLock";
var collection = Repository.Collection.Database.GetCollection<LockData>(lockCollection);
_lockManager = new ThrottleLock(collection, Configuration.HealthCheck);
}
public FilterServiceLockFine(
ILockManager lockManager,
IReaderWriterLockManager rwLockManager,
bool allowIsolation)
: base(lockManager, new FilterServiceGranularLockFactoryReentrant(rwLockManager), allowIsolation)
{
_iLock = rwLockManager.CreateLock(GetType());
}
/// <summary>
/// Constructor - takes the event type index to manipulate as its parameter.
/// </summary>
/// <param name="lockManager">The lock manager.</param>
/// <param name="eventTypeIndex">index to manipulate</param>
/// <param name="allowIsolation">if set to <c>true</c> [allow isolation].</param>
public EventTypeIndexBuilder(
ILockManager lockManager,
EventTypeIndex eventTypeIndex,
bool allowIsolation)
{
_eventTypeIndex = eventTypeIndex;
_callbacksLock = lockManager.CreateLock(GetType());
_isolatableCallbacks = allowIsolation ? new Dictionary <FilterHandle, EventTypeIndexBuilderValueIndexesPair>() : null;
}
/// <summary>
/// Gets a value that indicates whether the current lock manager instance is the same as the other lock manager.
/// </summary>
internal bool IsEqual(ILockManager inputLockManager, object stateOrKey)
{
if (this.lockManager == inputLockManager)
{
return(this.IsEqual(stateOrKey));
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="HealthWorker"/> class.
/// </summary>
/// <param name="processor">The parent processor.</param>
/// <param name="name">The name of the worker.</param>
public HealthWorker(IMessageProcessor processor, string name)
: base(processor, name)
{
// create throttle lock to only allow one run per schedule
var lockCollection = Configuration.LockCollection ?? "ServiceLock";
var collection = Repository.Collection.Database.GetCollection <LockData>(lockCollection);
_lockManager = new ThrottleLock(collection, Configuration.HealthCheck);
}
internal LockToken(byte lockLevel, T lockedObject, ILockManager <T> holder, LockRuleset matrix, int sharedLockCount)
{
LockLevel = lockLevel;
LockedObject = lockedObject;
_holder = holder;
_matrix = matrix;
_isReleased = 0;
SharedLockCount = sharedLockCount;
}
public LotManager(LMG_FABContext context, ILockManager lockManager, ReflmgContext refContext,
IDateFormater dateFormater, ILogger <LotManager> logger)
{
_fabContext = context;
_lockManager = lockManager;
_refContext = refContext;
_dateFormater = dateFormater;
_logger = logger;
}
public NamedWindowProcessor AddProcessor(
string name,
string contextName,
EventType eventType,
StatementResultService statementResultService,
ValueAddEventProcessor revisionProcessor,
string eplExpression,
string statementName,
bool isPrioritized,
bool isEnableSubqueryIndexShare,
bool isBatchingDataWindow,
bool isVirtualDataWindow,
ICollection <string> optionalUniqueKeyProps,
string eventTypeAsName,
StatementContext statementContextCreateWindow,
NamedWindowDispatchService namedWindowDispatchService,
ILockManager lockManager)
{
if (_processors.ContainsKey(name))
{
throw new ViewProcessingException("A named window by name '" + name + "' has already been created");
}
var processor = namedWindowDispatchService.CreateProcessor(
name, this,
namedWindowDispatchService,
contextName,
eventType,
statementResultService,
revisionProcessor,
eplExpression,
statementName,
isPrioritized,
isEnableSubqueryIndexShare,
_enableQueryPlanLog,
_metricReportingService,
isBatchingDataWindow,
isVirtualDataWindow,
optionalUniqueKeyProps,
eventTypeAsName,
statementContextCreateWindow,
lockManager);
_processors.Put(name, processor);
if (!_observers.IsEmpty())
{
var theEvent = new NamedWindowLifecycleEvent(name, processor, NamedWindowLifecycleEvent.LifecycleEventType.CREATE);
foreach (var observer in _observers)
{
observer.Observe(theEvent);
}
}
return(processor);
}
public ReadWriteRecordReader(IRecordReaderImp <TRecord> aRecordReaderImp
, ILockManager aLockManager
, long apTranId
, Dictionary <SqlTable, string> tableAndAliasNames)
{
_aRecordReaderImp = aRecordReaderImp;
_aLockManager = aLockManager;
_apTranId = apTranId;
_tableAndAliasNames = tableAndAliasNames;
}
public MyVirtualRootFileSystemFactory(
[NotNull] IServiceProvider serviceProvider,
[NotNull] IPathTraversalEngine pathTraversalEngine,
[NotNull] ISystemClock systemClock,
ILockManager lockManager = null,
IPropertyStoreFactory propertyStoreFactory = null)
: base(pathTraversalEngine, systemClock, lockManager, propertyStoreFactory)
{
_serviceProvider = serviceProvider;
}
/// <summary>
/// Try aquire the lock. If success it will return a successful <see cref="LockLeaseResult"/>.
/// If the <see cref="ILockManager"/> throws a <seealso cref="LockManagerException"/> it will catch that and return a failed <see cref="LockLeaseResult"/>.
/// </summary>
/// <param name="manager">The instance of <see cref="ILockManager"/>.</param>
/// <param name="name">Topic or name.</param>
/// <param name="duration">The duration the lease will be active. Defaults 30 seconds.</param>
/// <param name="cancellationToken">Propagates notification that operations should be canceled.</param>
/// <returns>The task the represent the asynchronous operation result for acquiring the lock.</returns>
public static async Task <LockLeaseResult> TryAcquireLock(this ILockManager manager, string name, TimeSpan?duration = null, CancellationToken cancellationToken = default)
{
try {
var @lock = await manager.AcquireLock(name, duration, cancellationToken);
return(LockLeaseResult.Success(@lock));
} catch (LockManagerException) {
return(LockLeaseResult.Fail());
}
}
/// <summary>
/// Try Aquire the lock. If success it will return a successful <see cref="LockLeaseResult"/>.
/// If the lockmanger throws a <seealso cref="LockManagerLockException"/> it will catch that and return a failed <see cref="LockLeaseResult"/>
/// </summary>
/// <param name="manager"></param>
/// <param name="name"></param>
/// <returns></returns>
public static async Task <LockLeaseResult> TryAquireLock(this ILockManager manager, string name)
{
try {
var @lock = await manager.AcquireLock(name);
return(LockLeaseResult.Success(@lock));
} catch (LockManagerLockException) {
return(LockLeaseResult.Fail());
}
}
public LockController(ILockManager lockManager)
{
_lockManager = lockManager;
}
public LockDelegatingHandler(ILockManager lockManager)
{
_lockManager = lockManager;
}
