mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
689 lines
24 KiB
C#
689 lines
24 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
namespace System.ServiceModel.PeerResolvers
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.Threading;
|
|
|
|
|
|
[ObsoleteAttribute ("PeerChannel feature is obsolete and will be removed in the future.", false)]
|
|
[ServiceBehavior(UseSynchronizationContext = false, InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)]
|
|
public class CustomPeerResolverService : IPeerResolverContract
|
|
{
|
|
internal enum RegistrationState
|
|
{
|
|
OK, Deleted
|
|
}
|
|
|
|
internal class RegistrationEntry
|
|
{
|
|
Guid clientId;
|
|
Guid registrationId;
|
|
string meshId;
|
|
DateTime expires;
|
|
PeerNodeAddress address;
|
|
RegistrationState state;
|
|
|
|
|
|
public RegistrationEntry(Guid clientId, Guid registrationId, string meshId, DateTime expires, PeerNodeAddress address)
|
|
{
|
|
this.ClientId = clientId;
|
|
this.RegistrationId = registrationId;
|
|
this.MeshId = meshId;
|
|
this.Expires = expires;
|
|
this.Address = address;
|
|
this.State = RegistrationState.OK;
|
|
}
|
|
|
|
public Guid ClientId
|
|
{
|
|
get { return clientId; }
|
|
set { clientId = value; }
|
|
}
|
|
|
|
public Guid RegistrationId
|
|
{
|
|
get { return registrationId; }
|
|
set { registrationId = value; }
|
|
}
|
|
|
|
public string MeshId
|
|
{
|
|
get { return meshId; }
|
|
set { meshId = value; }
|
|
}
|
|
|
|
public DateTime Expires
|
|
{
|
|
get { return expires; }
|
|
set { expires = value; }
|
|
}
|
|
|
|
public PeerNodeAddress Address
|
|
{
|
|
get { return address; }
|
|
set { address = value; }
|
|
}
|
|
|
|
public RegistrationState State
|
|
{
|
|
get { return state; }
|
|
set { state = value; }
|
|
}
|
|
|
|
}
|
|
|
|
internal class LiteLock
|
|
{
|
|
bool forWrite;
|
|
bool upgraded;
|
|
ReaderWriterLock locker;
|
|
TimeSpan timeout = TimeSpan.FromMinutes(1);
|
|
LockCookie lc;
|
|
|
|
LiteLock(ReaderWriterLock locker, bool forWrite)
|
|
{
|
|
this.locker = locker;
|
|
this.forWrite = forWrite;
|
|
}
|
|
|
|
public static void Acquire(out LiteLock liteLock, ReaderWriterLock locker)
|
|
{
|
|
Acquire(out liteLock, locker, false);
|
|
}
|
|
|
|
public static void Acquire(out LiteLock liteLock, ReaderWriterLock locker, bool forWrite)
|
|
{
|
|
LiteLock theLock = new LiteLock(locker, forWrite);
|
|
try { }
|
|
finally
|
|
{
|
|
if (forWrite)
|
|
{
|
|
locker.AcquireWriterLock(theLock.timeout);
|
|
}
|
|
else
|
|
{
|
|
locker.AcquireReaderLock(theLock.timeout);
|
|
}
|
|
liteLock = theLock;
|
|
}
|
|
}
|
|
|
|
public static void Release(LiteLock liteLock)
|
|
{
|
|
if (liteLock == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (liteLock.forWrite)
|
|
{
|
|
liteLock.locker.ReleaseWriterLock();
|
|
}
|
|
else
|
|
{
|
|
Fx.Assert(!liteLock.upgraded, "Can't release while upgraded!");
|
|
liteLock.locker.ReleaseReaderLock();
|
|
}
|
|
}
|
|
public void UpgradeToWriterLock()
|
|
{
|
|
Fx.Assert(!forWrite, "Invalid call to Upgrade!!");
|
|
Fx.Assert(!upgraded, "Already upgraded!");
|
|
try { }
|
|
finally
|
|
{
|
|
lc = locker.UpgradeToWriterLock(timeout);
|
|
upgraded = true;
|
|
}
|
|
}
|
|
public void DowngradeFromWriterLock()
|
|
{
|
|
Fx.Assert(!forWrite, "Invalid call to Downgrade!!");
|
|
if (upgraded)
|
|
{
|
|
locker.DowngradeFromWriterLock(ref lc);
|
|
upgraded = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class MeshEntry
|
|
{
|
|
Dictionary<Guid, RegistrationEntry> entryTable;
|
|
Dictionary<string, RegistrationEntry> service2EntryTable;
|
|
List<RegistrationEntry> entryList;
|
|
ReaderWriterLock gate;
|
|
|
|
internal MeshEntry()
|
|
{
|
|
EntryTable = new Dictionary<Guid, RegistrationEntry>();
|
|
Service2EntryTable = new Dictionary<string, RegistrationEntry>();
|
|
EntryList = new List<RegistrationEntry>();
|
|
Gate = new ReaderWriterLock();
|
|
}
|
|
|
|
public Dictionary<Guid, RegistrationEntry> EntryTable
|
|
{
|
|
get { return entryTable; }
|
|
set { entryTable = value; }
|
|
}
|
|
|
|
public Dictionary<string, RegistrationEntry> Service2EntryTable
|
|
{
|
|
get { return service2EntryTable; }
|
|
set { service2EntryTable = value; }
|
|
}
|
|
|
|
public List<RegistrationEntry> EntryList
|
|
{
|
|
get { return entryList; }
|
|
set { entryList = value; }
|
|
}
|
|
|
|
public ReaderWriterLock Gate
|
|
{
|
|
get { return gate; }
|
|
set { gate = value; }
|
|
}
|
|
}
|
|
|
|
Dictionary<string, MeshEntry> meshId2Entry = new Dictionary<string, MeshEntry>();
|
|
ReaderWriterLock gate;
|
|
|
|
TimeSpan timeout = TimeSpan.FromMinutes(1);
|
|
TimeSpan cleanupInterval = TimeSpan.FromMinutes(1);
|
|
TimeSpan refreshInterval = TimeSpan.FromMinutes(10);
|
|
bool controlShape;
|
|
bool isCleaning;
|
|
IOThreadTimer timer;
|
|
object thisLock = new object();
|
|
bool opened;
|
|
TimeSpan LockWait = TimeSpan.FromSeconds(5);
|
|
|
|
public CustomPeerResolverService()
|
|
{
|
|
isCleaning = false;
|
|
gate = new ReaderWriterLock();
|
|
}
|
|
|
|
public TimeSpan CleanupInterval
|
|
{
|
|
get
|
|
{
|
|
return cleanupInterval;
|
|
}
|
|
set
|
|
{
|
|
if (value < TimeSpan.Zero)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.SFxTimeoutOutOfRange0)));
|
|
}
|
|
|
|
if (TimeoutHelper.IsTooLarge(value))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
|
|
}
|
|
|
|
lock (ThisLock)
|
|
{
|
|
ThrowIfOpened("Set CleanupInterval");
|
|
this.cleanupInterval = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public TimeSpan RefreshInterval
|
|
{
|
|
get
|
|
{
|
|
return refreshInterval;
|
|
}
|
|
set
|
|
{
|
|
if (value < TimeSpan.Zero)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.SFxTimeoutOutOfRange0)));
|
|
}
|
|
|
|
if (TimeoutHelper.IsTooLarge(value))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
|
|
SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
|
|
}
|
|
|
|
lock (ThisLock)
|
|
{
|
|
ThrowIfOpened("Set RefreshInterval");
|
|
this.refreshInterval = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool ControlShape
|
|
{
|
|
get
|
|
{
|
|
return this.controlShape;
|
|
}
|
|
set
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
ThrowIfOpened("Set ControlShape");
|
|
this.controlShape = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
MeshEntry GetMeshEntry(string meshId) { return GetMeshEntry(meshId, true); }
|
|
MeshEntry GetMeshEntry(string meshId, bool createIfNotExists)
|
|
{
|
|
MeshEntry meshEntry = null;
|
|
LiteLock ll = null;
|
|
try
|
|
{
|
|
LiteLock.Acquire(out ll, gate);
|
|
if (!this.meshId2Entry.TryGetValue(meshId, out meshEntry) && createIfNotExists)
|
|
{
|
|
meshEntry = new MeshEntry();
|
|
try
|
|
{
|
|
ll.UpgradeToWriterLock();
|
|
meshId2Entry.Add(meshId, meshEntry);
|
|
}
|
|
finally
|
|
{
|
|
ll.DowngradeFromWriterLock();
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
LiteLock.Release(ll);
|
|
}
|
|
Fx.Assert(meshEntry != null || !createIfNotExists, "GetMeshEntry failed to get an entry!");
|
|
return meshEntry;
|
|
}
|
|
|
|
public virtual RegisterResponseInfo Register(Guid clientId, string meshId, PeerNodeAddress address)
|
|
{
|
|
Guid registrationId = Guid.NewGuid();
|
|
DateTime expiry = DateTime.UtcNow + RefreshInterval;
|
|
|
|
RegistrationEntry entry = null;
|
|
MeshEntry meshEntry = null;
|
|
|
|
lock (ThisLock)
|
|
{
|
|
entry = new RegistrationEntry(clientId, registrationId, meshId, expiry, address);
|
|
meshEntry = GetMeshEntry(meshId);
|
|
if (meshEntry.Service2EntryTable.ContainsKey(address.ServicePath))
|
|
PeerExceptionHelper.ThrowInvalidOperation_DuplicatePeerRegistration(address.ServicePath);
|
|
LiteLock ll = null;
|
|
|
|
try
|
|
{
|
|
// meshEntry.gate can be held by this thread for write if this is coming from update
|
|
// else MUST not be held at all.
|
|
if (!meshEntry.Gate.IsWriterLockHeld)
|
|
{
|
|
LiteLock.Acquire(out ll, meshEntry.Gate, true);
|
|
}
|
|
meshEntry.EntryTable.Add(registrationId, entry);
|
|
meshEntry.EntryList.Add(entry);
|
|
meshEntry.Service2EntryTable.Add(address.ServicePath, entry);
|
|
}
|
|
finally
|
|
{
|
|
if (ll != null)
|
|
LiteLock.Release(ll);
|
|
}
|
|
}
|
|
return new RegisterResponseInfo(registrationId, RefreshInterval);
|
|
}
|
|
|
|
public virtual RegisterResponseInfo Register(RegisterInfo registerInfo)
|
|
{
|
|
if (registerInfo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("registerInfo", SR.GetString(SR.PeerNullRegistrationInfo));
|
|
}
|
|
|
|
ThrowIfClosed("Register");
|
|
|
|
if (!registerInfo.HasBody() || String.IsNullOrEmpty(registerInfo.MeshId))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("registerInfo", SR.GetString(SR.PeerInvalidMessageBody, registerInfo));
|
|
}
|
|
return Register(registerInfo.ClientId, registerInfo.MeshId, registerInfo.NodeAddress);
|
|
}
|
|
|
|
public virtual RegisterResponseInfo Update(UpdateInfo updateInfo)
|
|
{
|
|
if (updateInfo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("updateInfo", SR.GetString(SR.PeerNullRegistrationInfo));
|
|
}
|
|
|
|
ThrowIfClosed("Update");
|
|
|
|
if (!updateInfo.HasBody() || String.IsNullOrEmpty(updateInfo.MeshId) || updateInfo.NodeAddress == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("updateInfo", SR.GetString(SR.PeerInvalidMessageBody, updateInfo));
|
|
}
|
|
|
|
Guid registrationId = updateInfo.RegistrationId;
|
|
RegistrationEntry entry;
|
|
|
|
MeshEntry meshEntry = GetMeshEntry(updateInfo.MeshId);
|
|
LiteLock ll = null;
|
|
|
|
//handle cases when Update ----s with Register.
|
|
if (updateInfo.RegistrationId == Guid.Empty || meshEntry == null)
|
|
return Register(updateInfo.ClientId, updateInfo.MeshId, updateInfo.NodeAddress);
|
|
//
|
|
// preserve locking order between ThisLock and the LiteLock.
|
|
lock (ThisLock)
|
|
{
|
|
try
|
|
{
|
|
LiteLock.Acquire(out ll, meshEntry.Gate);
|
|
if (!meshEntry.EntryTable.TryGetValue(updateInfo.RegistrationId, out entry))
|
|
{
|
|
try
|
|
{
|
|
// upgrade to writer lock
|
|
ll.UpgradeToWriterLock();
|
|
return Register(updateInfo.ClientId, updateInfo.MeshId, updateInfo.NodeAddress);
|
|
}
|
|
finally
|
|
{
|
|
ll.DowngradeFromWriterLock();
|
|
}
|
|
}
|
|
lock (entry)
|
|
{
|
|
entry.Address = updateInfo.NodeAddress;
|
|
entry.Expires = DateTime.UtcNow + this.RefreshInterval;
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
LiteLock.Release(ll);
|
|
}
|
|
}
|
|
return new RegisterResponseInfo(registrationId, RefreshInterval);
|
|
}
|
|
|
|
public virtual ResolveResponseInfo Resolve(ResolveInfo resolveInfo)
|
|
{
|
|
if (resolveInfo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("resolveInfo", SR.GetString(SR.PeerNullResolveInfo));
|
|
}
|
|
|
|
ThrowIfClosed("Resolve");
|
|
|
|
if (!resolveInfo.HasBody())
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("resolveInfo", SR.GetString(SR.PeerInvalidMessageBody, resolveInfo));
|
|
}
|
|
|
|
int currentCount = 0;
|
|
int index = 0;
|
|
int maxEntries = resolveInfo.MaxAddresses;
|
|
ResolveResponseInfo response = new ResolveResponseInfo();
|
|
List<PeerNodeAddress> results = new List<PeerNodeAddress>();
|
|
List<RegistrationEntry> entries = null;
|
|
PeerNodeAddress address;
|
|
RegistrationEntry entry;
|
|
MeshEntry meshEntry = GetMeshEntry(resolveInfo.MeshId, false);
|
|
if (meshEntry != null)
|
|
{
|
|
LiteLock ll = null;
|
|
try
|
|
{
|
|
LiteLock.Acquire(out ll, meshEntry.Gate);
|
|
entries = meshEntry.EntryList;
|
|
if (entries.Count <= maxEntries)
|
|
{
|
|
foreach (RegistrationEntry e in entries)
|
|
{
|
|
results.Add(e.Address);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Random random = new Random();
|
|
while (currentCount < maxEntries)
|
|
{
|
|
index = random.Next(entries.Count);
|
|
entry = entries[index];
|
|
Fx.Assert(entry.State == RegistrationState.OK, "A deleted registration is still around!");
|
|
address = entry.Address;
|
|
if (!results.Contains(address))
|
|
results.Add(address);
|
|
currentCount++;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
LiteLock.Release(ll);
|
|
}
|
|
}
|
|
response.Addresses = results.ToArray();
|
|
return response;
|
|
}
|
|
|
|
public virtual void Unregister(UnregisterInfo unregisterInfo)
|
|
{
|
|
if (unregisterInfo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterinfo", SR.GetString(SR.PeerNullRegistrationInfo));
|
|
}
|
|
|
|
ThrowIfClosed("Unregister");
|
|
|
|
if (!unregisterInfo.HasBody() || String.IsNullOrEmpty(unregisterInfo.MeshId) || unregisterInfo.RegistrationId == Guid.Empty)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterInfo", SR.GetString(SR.PeerInvalidMessageBody, unregisterInfo));
|
|
}
|
|
|
|
RegistrationEntry registration = null;
|
|
MeshEntry meshEntry = GetMeshEntry(unregisterInfo.MeshId, false);
|
|
//there could be a ---- that two different threads could be working on the same entry
|
|
//we wont optimize for that case.
|
|
LiteLock ll = null;
|
|
try
|
|
{
|
|
LiteLock.Acquire(out ll, meshEntry.Gate, true);
|
|
if (!meshEntry.EntryTable.TryGetValue(unregisterInfo.RegistrationId, out registration))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("unregisterInfo", SR.GetString(SR.PeerInvalidMessageBody, unregisterInfo));
|
|
meshEntry.EntryTable.Remove(unregisterInfo.RegistrationId);
|
|
meshEntry.EntryList.Remove(registration);
|
|
meshEntry.Service2EntryTable.Remove(registration.Address.ServicePath);
|
|
registration.State = RegistrationState.Deleted;
|
|
}
|
|
finally
|
|
{
|
|
LiteLock.Release(ll);
|
|
}
|
|
}
|
|
|
|
public virtual RefreshResponseInfo Refresh(RefreshInfo refreshInfo)
|
|
{
|
|
if (refreshInfo == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("refreshInfo", SR.GetString(SR.PeerNullRefreshInfo));
|
|
}
|
|
|
|
ThrowIfClosed("Refresh");
|
|
|
|
if (!refreshInfo.HasBody() || String.IsNullOrEmpty(refreshInfo.MeshId) || refreshInfo.RegistrationId == Guid.Empty)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("refreshInfo", SR.GetString(SR.PeerInvalidMessageBody, refreshInfo));
|
|
}
|
|
RefreshResult result = RefreshResult.RegistrationNotFound;
|
|
RegistrationEntry entry = null;
|
|
MeshEntry meshEntry = GetMeshEntry(refreshInfo.MeshId, false);
|
|
LiteLock ll = null;
|
|
|
|
if (meshEntry != null)
|
|
{
|
|
try
|
|
{
|
|
LiteLock.Acquire(out ll, meshEntry.Gate);
|
|
if (!meshEntry.EntryTable.TryGetValue(refreshInfo.RegistrationId, out entry))
|
|
return new RefreshResponseInfo(RefreshInterval, result);
|
|
lock (entry)
|
|
{
|
|
if (entry.State == RegistrationState.OK)
|
|
{
|
|
entry.Expires = DateTime.UtcNow + RefreshInterval;
|
|
result = RefreshResult.Success;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
LiteLock.Release(ll);
|
|
}
|
|
}
|
|
return new RefreshResponseInfo(RefreshInterval, result);
|
|
}
|
|
|
|
public virtual ServiceSettingsResponseInfo GetServiceSettings()
|
|
{
|
|
ThrowIfClosed("GetServiceSettings");
|
|
ServiceSettingsResponseInfo info = new ServiceSettingsResponseInfo(this.ControlShape);
|
|
return info;
|
|
}
|
|
|
|
public virtual void Open()
|
|
{
|
|
ThrowIfOpened("Open");
|
|
if (this.refreshInterval <= TimeSpan.Zero)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("RefreshInterval", SR.GetString(SR.RefreshIntervalMustBeGreaterThanZero, this.refreshInterval));
|
|
if (this.CleanupInterval <= TimeSpan.Zero)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("CleanupInterval", SR.GetString(SR.CleanupIntervalMustBeGreaterThanZero, this.cleanupInterval));
|
|
|
|
//check that we are good to open
|
|
timer = new IOThreadTimer(new Action<object>(CleanupActivity), null, false);
|
|
timer.Set(CleanupInterval);
|
|
opened = true;
|
|
}
|
|
|
|
public virtual void Close()
|
|
{
|
|
ThrowIfClosed("Close");
|
|
timer.Cancel();
|
|
opened = false;
|
|
}
|
|
|
|
internal virtual void CleanupActivity(object state)
|
|
{
|
|
if (!opened)
|
|
return;
|
|
|
|
if (!isCleaning)
|
|
{
|
|
lock (ThisLock)
|
|
{
|
|
if (!isCleaning)
|
|
{
|
|
isCleaning = true;
|
|
try
|
|
{
|
|
MeshEntry meshEntry = null;
|
|
//acquire a write lock. from the reader/writer lock can we postpone until no contention?
|
|
ICollection<string> keys = null;
|
|
LiteLock ll = null;
|
|
try
|
|
{
|
|
LiteLock.Acquire(out ll, gate);
|
|
keys = meshId2Entry.Keys;
|
|
}
|
|
finally
|
|
{
|
|
LiteLock.Release(ll);
|
|
}
|
|
foreach (string meshId in keys)
|
|
{
|
|
meshEntry = GetMeshEntry(meshId);
|
|
CleanupMeshEntry(meshEntry);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
isCleaning = false;
|
|
if (opened)
|
|
timer.Set(this.CleanupInterval);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//always call this from a readlock
|
|
void CleanupMeshEntry(MeshEntry meshEntry)
|
|
{
|
|
List<Guid> remove = new List<Guid>();
|
|
if (!opened)
|
|
return;
|
|
LiteLock ll = null;
|
|
try
|
|
{
|
|
LiteLock.Acquire(out ll, meshEntry.Gate, true);
|
|
foreach (KeyValuePair<Guid, RegistrationEntry> item in meshEntry.EntryTable)
|
|
{
|
|
if ((item.Value.Expires <= DateTime.UtcNow) || (item.Value.State == RegistrationState.Deleted))
|
|
{
|
|
remove.Add(item.Key);
|
|
meshEntry.EntryList.Remove(item.Value);
|
|
meshEntry.Service2EntryTable.Remove(item.Value.Address.ServicePath);
|
|
}
|
|
}
|
|
foreach (Guid id in remove)
|
|
{
|
|
meshEntry.EntryTable.Remove(id);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
LiteLock.Release(ll);
|
|
}
|
|
}
|
|
|
|
object ThisLock
|
|
{
|
|
get
|
|
{
|
|
return this.thisLock;
|
|
}
|
|
}
|
|
void ThrowIfOpened(string operation)
|
|
{
|
|
if (opened)
|
|
PeerExceptionHelper.ThrowInvalidOperation_NotValidWhenOpen(operation);
|
|
}
|
|
void ThrowIfClosed(string operation)
|
|
{
|
|
if (!opened)
|
|
PeerExceptionHelper.ThrowInvalidOperation_NotValidWhenClosed(operation);
|
|
|
|
}
|
|
}
|
|
}
|
|
|