public InstanceHandle CreateInstanceHandle(InstanceOwner owner, Guid instanceId)
{
if (instanceId == Guid.Empty)
{
throw Fx.Exception.Argument("instanceId", SRCore.CannotCreateContextWithNullId);
}
return PrepareInstanceHandle(new InstanceHandle(this, owner, instanceId));
}
internal InstanceView(InstanceOwner owner, Guid instanceId)
: this()
{
Fx.Assert(instanceId != Guid.Empty, "Null instanceId passed to InstanceView ctor.");
InstanceOwner = owner;
InstanceId = instanceId;
IsBoundToInstance = true;
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner)
{
this.thisLock = new object();
this.Version = -1L;
this.Store = store;
this.Owner = owner;
this.View = new InstanceView(owner);
this.IsValid = true;
}
internal InstancePersistenceEvent AddHandleToEvent(InstanceHandle handle, InstancePersistenceEvent persistenceEvent, InstanceOwner owner)
{
lock (this.ThisLock)
{
InstanceNormalEvent ownerEventHelper = this.GetOwnerEventHelper(persistenceEvent, owner);
ownerEventHelper.BoundHandles.Add(handle);
ownerEventHelper.PendingHandles.Remove(handle);
return (ownerEventHelper.IsSignaled ? ownerEventHelper : null);
}
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner)
{
Fx.Assert(store != null, "Shouldn't be possible.");
Version = -1;
Store = store;
Owner = owner;
View = new InstanceView(owner);
IsValid = true;
}
internal PersistenceProviderDirectory(InstanceStore store, InstanceOwner owner, IDictionary<XName, InstanceValue> instanceMetadataChanges, WorkflowDefinitionProvider workflowDefinitionProvider, WorkflowServiceHost serviceHost,
DurableConsistencyScope consistencyScope, int maxInstances)
: this(workflowDefinitionProvider, serviceHost, consistencyScope, maxInstances)
{
Fx.Assert(store != null, "InstanceStore must be specified on PPD.");
Fx.Assert(owner != null, "InstanceOwner must be specified on PPD.");
this.store = store;
this.owner = owner;
this.InstanceMetadataChanges = instanceMetadataChanges;
}
internal InstanceHandle(InstanceStore store, InstanceOwner owner, Guid instanceId)
{
Fx.Assert(store != null, "Shouldn't be possible here either.");
Fx.Assert(instanceId != Guid.Empty, "Should be validating this.");
Version = -1;
Store = store;
Owner = owner;
Id = instanceId;
View = new InstanceView(owner, instanceId);
IsValid = true;
if (Fx.Trace.IsEtwProviderEnabled)
{
eventTraceActivity = new EventTraceActivity(instanceId);
}
}
internal InstancePersistenceEvent FindEvent(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner)
{
return this.FindEventHelper(eventType, out instanceOwner, false);
}
protected void SignalEvent(InstancePersistenceEvent persistenceEvent, InstanceOwner owner)
{
if (persistenceEvent == null)
{
throw Fx.Exception.ArgumentNull("persistenceEvent");
}
if (owner == null)
{
throw Fx.Exception.ArgumentNull("owner");
}
InstanceNormalEvent normal;
InstanceHandle[] handlesToNotify = null;
lock (ThisLock)
{
WeakReference ownerReference;
if (!this.owners.TryGetValue(owner.InstanceOwnerId, out ownerReference) || !object.ReferenceEquals(ownerReference.Target, owner))
{
throw Fx.Exception.Argument("owner", SRCore.OwnerBelongsToWrongStore);
}
normal = GetOwnerEventHelper(persistenceEvent, owner);
if (!normal.IsSignaled)
{
normal.IsSignaled = true;
if (normal.BoundHandles.Count > 0)
{
handlesToNotify = normal.BoundHandles.ToArray();
}
}
}
if (handlesToNotify != null)
{
foreach (InstanceHandle handle in handlesToNotify)
{
handle.EventReady(normal);
}
}
}
internal InstanceView(InstanceOwner owner)
: this()
{
InstanceOwner = owner;
}
internal void BindOwner(InstanceOwner owner)
{
Fx.AssertAndThrow(!IsViewFrozen, "BindOwner called on read-only InstanceView.");
Fx.Assert(owner != null, "Null owner passed to BindOwner.");
if (IsBoundToInstanceOwner)
{
throw Fx.Exception.AsError(new InvalidOperationException(SRCore.ContextAlreadyBoundToOwner));
}
InstanceOwner = owner;
}
internal InstanceOwner GetOrCreateOwner(Guid instanceOwnerId, Guid lockToken)
{
lock (ThisLock)
{
WeakReference ownerRef;
InstanceOwner owner;
if (this.owners.TryGetValue(instanceOwnerId, out ownerRef))
{
owner = (InstanceOwner)ownerRef.Target;
if (owner == null)
{
owner = new InstanceOwner(instanceOwnerId, lockToken);
ownerRef.Target = owner;
}
else if (owner.OwnerToken != lockToken)
{
throw Fx.Exception.AsError(new InvalidOperationException(SRCore.StoreReportedConflictingLockTokens));
}
}
else
{
owner = new InstanceOwner(instanceOwnerId, lockToken);
this.owners.Add(instanceOwnerId, new WeakReference(owner));
}
while (true)
{
if (this.ownerKeysToScan.Length == this.ownerKeysIndexToScan)
{
this.ownerKeysToScan = new Guid[this.owners.Count];
this.owners.Keys.CopyTo(this.ownerKeysToScan, 0);
this.ownerKeysIndexToScan = 0;
break;
}
Guid current = this.ownerKeysToScan[this.ownerKeysIndexToScan++];
if (this.owners.TryGetValue(current, out ownerRef))
{
if (ownerRef.Target == null)
{
this.owners.Remove(current);
}
else
{
break;
}
}
}
return owner;
}
}
internal void BindOwner(InstanceOwner owner)
{
lock (this.ThisLock)
{
this.Owner = owner;
}
}
private InstancePersistenceEvent FindEventHelper(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner, bool withReset)
{
instanceOwner = null;
InstanceOwner[] instanceOwners = base.GetInstanceOwners();
if (instanceOwners.Length > 0)
{
foreach (InstanceOwner owner in instanceOwners)
{
if (owner.InstanceOwnerId == this.storeLock.LockOwnerId)
{
instanceOwner = owner;
break;
}
}
if (instanceOwner != null)
{
if (withReset)
{
base.ResetEvent(eventType, instanceOwner);
}
foreach (InstancePersistenceEvent event2 in base.GetEvents(instanceOwner))
{
if (event2 == eventType)
{
return event2;
}
}
}
}
return null;
}
internal void BindOwner(InstanceOwner owner)
{
Fx.Assert(owner != null, "Null owner passed to BindOwner.");
lock (ThisLock)
{
Fx.Assert(this.inProgressBind == null, "How did we get a bind in progress without an owner?");
Fx.Assert(Owner == null, "BindOwner called when we already have an owner.");
Owner = owner;
}
}
public InstanceHandle CreateInstanceHandle(InstanceOwner owner)
{
return PrepareInstanceHandle(new InstanceHandle(this, owner));
}
protected void ResetEvent(InstancePersistenceEvent persistenceEvent, InstanceOwner owner)
{
if (persistenceEvent == null)
{
throw Fx.Exception.ArgumentNull("persistenceEvent");
}
if (owner == null)
{
throw Fx.Exception.ArgumentNull("owner");
}
InstanceNormalEvent normal;
lock (ThisLock)
{
WeakReference ownerReference;
if (!this.owners.TryGetValue(owner.InstanceOwnerId, out ownerReference) || !object.ReferenceEquals(ownerReference.Target, owner))
{
throw Fx.Exception.Argument("owner", SRCore.OwnerBelongsToWrongStore);
}
if (!owner.Events.TryGetValue(persistenceEvent.Name, out normal))
{
return;
}
if (normal.IsSignaled)
{
normal.IsSignaled = false;
if (normal.BoundHandles.Count == 0 && normal.PendingHandles.Count == 0)
{
owner.Events.Remove(persistenceEvent.Name);
}
}
}
}
// Must be called under ThisLock. Doesn't validate the InstanceOwner.
InstanceNormalEvent GetOwnerEventHelper(InstancePersistenceEvent persistenceEvent, InstanceOwner owner)
{
InstanceNormalEvent normal;
if (!owner.Events.TryGetValue(persistenceEvent.Name, out normal))
{
normal = new InstanceNormalEvent(persistenceEvent);
owner.Events.Add(persistenceEvent.Name, normal);
}
return normal;
}
internal void RemoveHandleFromEvents(InstanceHandle handle, IEnumerable<XName> eventNames, InstanceOwner owner)
{
lock (ThisLock)
{
Fx.Assert(this.owners.ContainsKey(owner.InstanceOwnerId), "InstanceHandle called RemoveHandleFromEvents on wrong InstanceStore!!");
Fx.Assert(object.ReferenceEquals(this.owners[owner.InstanceOwnerId].Target, owner), "How did multiple instances of the same owner become simultaneously active in RemoveHandleFromEvents?");
// Entry must exist since it is still registered by the handle.
foreach (InstanceNormalEvent normal in eventNames.Select(name => owner.Events[name]))
{
Fx.Assert(normal.BoundHandles.Contains(handle) || normal.PendingHandles.Contains(handle), "Event should still have handle registration.");
normal.PendingHandles.Remove(handle);
normal.BoundHandles.Remove(handle);
if (!normal.IsSignaled && normal.BoundHandles.Count == 0 && normal.PendingHandles.Count == 0)
{
owner.Events.Remove(normal.Name);
}
}
}
}
internal List<InstancePersistenceEvent> SelectSignaledEvents(IEnumerable<XName> eventNames, InstanceOwner owner)
{
List<InstancePersistenceEvent> readyEvents = null;
lock (ThisLock)
{
Fx.Assert(this.owners.ContainsKey(owner.InstanceOwnerId), "InstanceHandle called SelectSignaledEvents on wrong InstanceStore!!");
Fx.Assert(object.ReferenceEquals(this.owners[owner.InstanceOwnerId].Target, owner), "How did multiple instances of the same owner become simultaneously active?");
// Entry must exist since it is still registered by the handle.
foreach (InstanceNormalEvent normal in eventNames.Select(name => owner.Events[name]))
{
if (normal.IsSignaled)
{
if (readyEvents == null)
{
readyEvents = new List<InstancePersistenceEvent>(1);
}
readyEvents.Add(normal);
}
}
}
return readyEvents;
}
internal InstancePersistenceEvent AddHandleToEvent(InstanceHandle handle, InstancePersistenceEvent persistenceEvent, InstanceOwner owner)
{
lock (ThisLock)
{
Fx.Assert(this.owners.ContainsKey(owner.InstanceOwnerId), "InstanceHandle called AddHandleToEvent on wrong InstanceStore!!");
Fx.Assert(object.ReferenceEquals(this.owners[owner.InstanceOwnerId].Target, owner), "How did multiple instances of the same owner become simultaneously active?");
InstanceNormalEvent normal = GetOwnerEventHelper(persistenceEvent, owner);
Fx.Assert(normal.PendingHandles.Contains(handle), "Should have already pended the handle.");
Fx.Assert(!normal.BoundHandles.Contains(handle), "Should not be able to add a handle to an event twice.");
normal.BoundHandles.Add(handle);
normal.PendingHandles.Remove(handle);
return normal.IsSignaled ? normal : null;
}
}
internal void PendHandleToEvent(InstanceHandle handle, InstancePersistenceEvent persistenceEvent, InstanceOwner owner)
{
lock (ThisLock)
{
Fx.Assert(this.owners.ContainsKey(owner.InstanceOwnerId), "InstanceHandle called PendHandleToEvent on wrong InstanceStore!!");
Fx.Assert(object.ReferenceEquals(this.owners[owner.InstanceOwnerId].Target, owner), "How did multiple of the same owner become simultaneously active?");
InstanceNormalEvent normal = GetOwnerEventHelper(persistenceEvent, owner);
Fx.Assert(!normal.PendingHandles.Contains(handle), "Should not have already pended the handle.");
Fx.Assert(!normal.BoundHandles.Contains(handle), "Should not be able to pend an already-bound handle.");
normal.PendingHandles.Add(handle);
}
}
internal InstancePersistenceEvent FindEventWithReset(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner)
{
return this.FindEventHelper(eventType, out instanceOwner, true);
}
protected void SignalEvent (InstancePersistenceEvent persistenceEvent, InstanceOwner owner)
{
throw new NotImplementedException ();
}
InstancePersistenceEvent FindEventHelper(InstancePersistenceEvent eventType, out InstanceOwner instanceOwner, bool withReset)
{
instanceOwner = null;
InstanceOwner[] instanceOwners = GetInstanceOwners();
if (instanceOwners.Length > 0)
{
foreach (InstanceOwner owner in instanceOwners)
{
if (owner.InstanceOwnerId == this.storeLock.LockOwnerId)
{
instanceOwner = owner;
break;
}
}
if (instanceOwner != null)
{
// Reset first. That will allow the event to be cleaned up, so GetEvents won't return it (it will always return signalled events).
if (withReset)
{
base.ResetEvent(eventType, instanceOwner);
}
InstancePersistenceEvent[] registeredEvents = base.GetEvents(instanceOwner);
foreach (InstancePersistenceEvent persistenceEvent in registeredEvents)
{
if (persistenceEvent == eventType)
{
return persistenceEvent;
}
}
}
}
return null;
}
protected InstancePersistenceEvent [] GetEvents (InstanceOwner owner)
{
throw new NotImplementedException ();
}
public void Open(TimeSpan timeout)
{
Fx.Assert(Host != null, "Extension should have been attached in WorkflowServiceHost constructor.");
lock (this.thisLock)
{
ThrowIfDisposedOrImmutable(this.state);
this.state = States.Opened;
}
InitializeDefinitionProvider();
CheckPersistenceProviderBehavior();
SetDefaultOwnerMetadata();
if (InstanceStore != null)
{
using (new TransactionScope(TransactionScopeOption.Suppress))
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
InstanceHandle handle = null;
try
{
handle = InstanceStore.CreateInstanceHandle(null);
this.owner = InstanceStore.Execute(handle, GetCreateOwnerCommand(), timeoutHelper.RemainingTime()).InstanceOwner;
this.handle = handle;
handle = null;
}
catch (InstancePersistenceException exception)
{
throw FxTrace.Exception.AsError(new CommunicationException(SR.UnableToOpenAndRegisterStore, exception));
}
finally
{
if (handle != null)
{
handle.Free();
}
}
}
}
InitializePersistenceProviderDirectory();
}
public void Open(TimeSpan timeout)
{
lock (this.thisLock)
{
ThrowIfDisposedOrImmutable(this.state);
this.state = 1;
}
this.CheckPersistenceProviderBehavior();
this.SetDefaultOwnerMetadata();
if (this.InstanceStore != null)
{
using (new TransactionScope(TransactionScopeOption.Suppress))
{
TimeoutHelper helper = new TimeoutHelper(timeout);
InstanceHandle handle = null;
try
{
handle = this.InstanceStore.CreateInstanceHandle((InstanceOwner) null);
this.owner = this.InstanceStore.Execute(handle, this.createOwnerCommand, helper.RemainingTime()).InstanceOwner;
this.handle = handle;
handle = null;
}
catch (InstancePersistenceException exception)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new CommunicationException(System.ServiceModel.Activities.SR.UnableToOpenAndRegisterStore, exception));
}
finally
{
if (handle != null)
{
handle.Free();
}
}
}
}
this.InitializePersistenceProviderDirectory();
}
public InstanceHandle CreateInstanceHandle (InstanceOwner owner, Guid instanceId)
{
throw new NotImplementedException ();
}
protected InstancePersistenceEvent[] GetEvents(InstanceOwner owner)
{
if (owner == null)
{
throw Fx.Exception.ArgumentNull("owner");
}
lock (ThisLock)
{
WeakReference ownerReference;
if (!this.owners.TryGetValue(owner.InstanceOwnerId, out ownerReference) || !object.ReferenceEquals(ownerReference.Target, owner))
{
throw Fx.Exception.Argument("owner", SRCore.OwnerBelongsToWrongStore);
}
return owner.Events.Values.ToArray();
}
}
