private static void CurrentContextOnOperationCompleted(object sender)
{
IStardustContext context = null;
try
{
context = (IStardustContext)sender;
WaitOperationRelease(context);
DisposeContext(context);
}
catch (Exception ex)
{
ex.Log();
}
finally
{
if (context != null)
{
if (DoLoggingLight)
{
Logging.DebugMessage($"Disconnecting event handler {context.ContextId}");
}
context.ClearDisposeActoion();
}
}
}
internal static void RegisterForDispose(this IStardustContext currentContext, IDisposable instance)
{
try
{
if (DoLoggingLight)
{
Logging.DebugMessage($"Register disposable item {instance.GetType().FullName}");
}
var container = GetStardustContextProvider(currentContext);
lock (container)
{
if (DoLoggingLight)
{
Logging.DebugMessage($"before insert: Dispose list size {container.DisposeList?.Count}");
}
container.DisposeList?.Add(instance);
if (DoLoggingLight)
{
Logging.DebugMessage($"after insert: Dispose list size {container.DisposeList?.Count}");
}
}
}
catch (Exception ex)
{
ex.Log();
}
}
public static void ClearContext(this IStardustContext currentContext)
{
var container = GetContainer(currentContext);
lock (container)
{
container.Clear();
}
}
private static void WaitOperationRelease(IStardustContext context)
{
var threadLocker = context.GetItemFromContext(typeof(ManualResetEvent).FullName) as ManualResetEvent;
if (threadLocker.IsInstance())
{
threadLocker.WaitOne();
}
}
public static void ClearContext(this IStardustContext currentContext)
{
var container = GetContainer(currentContext);
lock (container)
{
container.Clear();
GetStardustContextProvider(currentContext).DisposeList?.AsParallel().ForAll(i => i?.TryDispose());
}
}
public static void RemoveItemFromContext(this IStardustContext currentContext, string key)
{
var container = GetContainer(currentContext);
lock (container)
{
object instance;
if (!container.TryRemove(key, out instance))
{
Logging.DebugMessage("failed to remove item '{0}'", key);
}
}
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
IStardustContext ctx = null;
try
{
ctx = ContextScopeExtensions.CreateScope();
if (request.Version.Envelope == EnvelopeVersion.None)
{
runtime = RuntimeFactory.CreateRuntime();
runtime.GetStateStorageContainer().TryAddStorageItem((ThreadSynchronizationContext)ctx, Synccontext);
var httpRequest = request.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
if (httpRequest != null)
{
var msg = httpRequest.Headers["X-Stardust-Meta"];
if (msg.ContainsCharacters())
{
try
{
var item = Resolver.Activate <IReplaceableSerializer>().Deserialize <RequestHeader>(Convert.FromBase64String(msg).GetStringFromArray());
request.Properties.Add("autoHeader", item);
runtime.GetStateStorageContainer().TryAddStorageItem(true, "isRest");
}
catch
{
}
}
}
return(ctx);
}
if (request.Headers.Any(messageHeader => messageHeader.Name == "HeaderInfoIncluded"))
{
runtime = RuntimeFactory.CreateRuntime();
runtime.GetStateStorageContainer().TryAddStorageItem((ThreadSynchronizationContext)ctx, Synccontext);
return(ctx);
}
;
var header = request.Headers.GetHeader <RequestHeader>("RequestHeader", RequestHeader.NS);
request.Properties.Add("autoHeader", header);
runtime = RuntimeFactory.CreateRuntime();
runtime.GetStateStorageContainer().TryAddStorageItem((ThreadSynchronizationContext)ctx, Synccontext);
}
catch (Exception ex)
{
ex.Log();
}
return(ctx);
}
internal static void DisposeContext(this IStardustContext currentContext)
{
try
{
StardustContextProvider item;
int counter = 0;
while (!StateStorage.TryRemove(currentContext.ContextId.ToString(), out item))
{
Thread.Sleep(10);
counter++;
if (counter > 10)
{
if (DoLoggingLight)
{
Logging.DebugMessage($"Unable to remove item {currentContext.ContextId}");
}
return;
}
}
if (item.DisposeList != null)
{
if (DoLoggingLight)
{
Logging.DebugMessage($"Disposing {item.DisposeList.Count} items for context {currentContext.ContextId}");
}
foreach (var disposable in item.DisposeList)
{
if (DoLoggingLight)
{
Logging.DebugMessage($"Disposing {disposable?.GetType().Name}");
}
disposable.TryDispose();
}
}
if (DoLoggingLight)
{
Logging.DebugMessage($"Disposing clearing disposable list");
}
item?.DisposeList?.Clear();
if (DoLoggingLight)
{
Logging.DebugMessage($"Disposing clearing container");
}
item?.Dispose();
}
catch
{
}
}
private static void WaitOperationRelease(IStardustContext context)
{
try
{
var threadLocker = context.GetItemFromContext(typeof(ManualResetEvent).FullName) as ManualResetEvent;
threadLocker?.WaitOne();
}
catch (Exception ex)
{
if (DoLoggingLight)
{
ex.Log("WTF?!?");
}
}
}
private static StardustContextProvider GetStardustContextProvider(IStardustContext currentContext)
{
try
{
if (currentContext == null)
{
Logging.DebugMessage("WTF??");
currentContext = ThreadSynchronizationContext.BeginContext(Guid.NewGuid());
}
return(((ThreadSynchronizationContext)currentContext).StateContainer);
}
catch (Exception ex)
{
Logging.Exception(ex);
throw;
}
}
public static object GetItemFromContext(this IStardustContext currentContext, string key)
{
var container = GetContainer(currentContext);
lock (container)
{
object instance;
if (container.TryGetValue(key, out instance))
{
return(instance);
}
if (DoLogging && key != "Stardust.Nucleus.ContextProviders.IExtendedScopeProvider")
{
Logging.DebugMessage("Item with key {0} was not found in context {1}", key, currentContext.ContextId);
}
return(null);
}
}
public static void SetItemInContext(this IStardustContext currentContext, string key, object item)
{
var container = GetContainer(currentContext);
lock (container)
{
if (DoLogging)
{
Logging.DebugMessage("inserting {0}", key);
}
if (container.ContainsKey(key))
{
object oldValue;
container.TryRemove(key, out oldValue);
}
if (!container.TryAdd(key, item))
{
Logging.DebugMessage("inserting item {0} failed", key);
}
}
}
private static StardustContextProvider GetStardustContextProvider(IStardustContext currentContext)
{
try
{
return(((ThreadSynchronizationContext)currentContext).StateContainer);
}
catch (Exception ex)
{
Logging.Exception(ex);
//if (DoLogging)
{
try
{
//if (DoLogging)
{
for (var i = 0; i < 100; i++)
{
var st1 = new StackTrace(new StackFrame(i, true));
if (st1.ToString().ContainsCharacters())
{
Logging.DebugMessage("[ext] Stack{1}: {0} [{2}]", st1.ToString(), i, currentContext.ContextId);
}
else
{
break;
}
}
}
}
catch (Exception)
{
}
}
throw;
}
}
private static StardustContextProvider GetStardustContextProvider(IStardustContext currentContext)
{
try
{
return ((ThreadSynchronizationContext)currentContext).StateContainer;
}
catch (Exception ex)
{
Logging.Exception(ex);
//if (DoLogging)
{
try
{
//if (DoLogging)
{
for (var i = 0; i < 100; i++)
{
var st1 = new StackTrace(new StackFrame(i, true));
if(st1.ToString().ContainsCharacters())
Logging.DebugMessage("[ext] Stack{1}: {0} [{2}]", st1.ToString(), i, currentContext.ContextId);
else break;
}
}
}
catch (Exception)
{
}
}
throw;
}
}
internal static void RegisterForDispose(this IStardustContext currentContext, IDisposable instance)
{
var container = GetStardustContextProvider(currentContext);
container.DisposeList.Add(instance);
}
private static StardustContextProvider GetStardustContextProvider(IStardustContext currentContext)
{
try
{
if (currentContext == null)
{
Logging.DebugMessage("WTF??");
currentContext = ThreadSynchronizationContext.BeginContext(Guid.NewGuid());
}
return ((ThreadSynchronizationContext)currentContext).StateContainer;
}
catch (Exception ex)
{
Logging.Exception(ex);
throw;
}
}
private static ConcurrentDictionary <string, object> GetContainer(IStardustContext currentContext)
{
var container = GetStardustContextProvider(currentContext);
return(container.Container);
}
private static void WaitOperationRelease(IStardustContext context)
{
var threadLocker = context.GetItemFromContext(typeof(ManualResetEvent).FullName) as ManualResetEvent;
if (threadLocker.IsInstance())
threadLocker.WaitOne();
}
private static ConcurrentDictionary<string, object> GetContainer(IStardustContext currentContext)
{
var container = GetStardustContextProvider(currentContext);
return container.Container;
}
