public override void Track(object instance, Burden burden)
{
if (ShouldTrack(burden.Model))
{
base.Track(instance, burden);
}
}
private void ExitResolutionContext(Burden burden, bool trackContext)
{
handlerStack.Pop();
if (trackContext)
{
resolutionStack.Pop();
}
if (burden == null)
{
return;
}
if (burden.Instance == null)
{
return;
}
if (burden.RequiresPolicyRelease == false)
{
return;
}
if (resolutionStack.Count != 0)
{
var parent = resolutionStack.Peek().Burden;
if (parent == null)
{
return;
}
parent.AddChild(burden);
}
}
public Burden CreateBurden(bool trackedExternally)
{
// NOTE: not sure we should allow crreating burden again, when it was already created...
// this is currently employed by pooled lifestyle
burden = new Burden(handler, requiresDecommission, trackedExternally);
return(burden);
}
public virtual object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy)
{
var instance = CreateInstance(context, burden);
Track(burden, releasePolicy);
return instance;
}
public override bool ReleaseCore(Burden burden)
{
var genericType = ProxyUtil.GetUnproxiedType(burden.Instance);
var handler = type2SubHandler.GetOrThrow(genericType);
return(handler.Release(burden));
}
public override object Resolve(CreationContext context, IReleasePolicy releasePolicy)
{
// 1. read from cache
if (cachedBurden != null)
{
return cachedBurden.Instance;
}
var instanceFromContext = context.GetContextualProperty(ComponentActivator);
if (instanceFromContext != null)
{
//we've been called recursively, by some dependency from base.Resolve call
return instanceFromContext;
}
var initializing = false;
try
{
initializing = init.ExecuteThreadSafeOnce();
if (cachedBurden != null)
{
return cachedBurden.Instance;
}
var burden = CreateInstance(context, true);
cachedBurden = burden;
Track(burden, releasePolicy);
return burden.Instance;
}
finally
{
if (initializing)
{
init.EndThreadSafeOnceSection();
}
}
}
public virtual void Track(object instance, Burden burden)
{
using(@lock.ForWriting())
{
instance2Burden[instance] = burden;
}
}
public BurdenView(Burden burden)
{
BurdenId = burden.BurdenId;
NextRunTime = burden.NextRunTime;
Task = burden.ToString();
}
public override object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy)
{
lock (slot)
{
var map = (Dictionary<IComponentActivator, object>)Thread.GetData(slot);
if (map == null)
{
map = new Dictionary<IComponentActivator, object>();
Thread.SetData(slot, map);
}
Object instance;
if (!map.TryGetValue(ComponentActivator, out instance))
{
instance = base.Resolve(context, burden, releasePolicy);
map.Add(ComponentActivator, instance);
instances.Add(burden);
}
return instance;
}
}
private object GetNewInstance(CreationContext context, IReleasePolicy releasePolicy)
{
var burden = CreateInstance(context, true);
cachedBurden = burden;
Track(burden, releasePolicy);
return burden.Instance;
}
public override object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy)
{
if (cachedBurden != null)
{
return cachedBurden.Instance;
}
var instanceFromContext = context.GetContextualProperty(ComponentActivator);
if (instanceFromContext != null)
{
//we've been called recursively, by some dependency from base.Resolve call
return instanceFromContext;
}
object instance;
lock (ComponentActivator)
{
if (cachedBurden != null)
{
return cachedBurden.Instance;
}
instance = base.CreateInstance(context, burden);
cachedBurden = burden;
}
Track(burden, releasePolicy);
return instance;
}
public static async Task <bool> WithdrawToWallet(Burden burden)
{
var amountToWithdraw = burden.BurdenTypeAmount;
if (amountToWithdraw <= 0)
{
var balance = await _api.Account.ListAccounts();
var curr = balance.Accounts.FirstOrDefault(a => a.Currency == burden.BurdenTypeCurrency.ToString());
if (curr == null)
{
return(await Task.FromResult(false));
}
amountToWithdraw = curr.Available;
}
var resp = await _api.Withdrawals.Crypto(
amountToWithdraw, burden.BurdenTypeCurrency.ToString(), burden.WalletAddr);
if (httpSuccess(burden, resp))
{
var str = String.Format("Withdrawal of {0} {1} requested. Transaction Id: {2}",
resp.Amount,
resp.Currency,
resp.Id);
taskResult(burden, true, str);
}
return(resp.HttpResponse.IsSuccessStatusCode);
}
public override bool ReleaseCore(Burden burden)
{
var genericType = ProxyUtil.GetUnproxiedType(burden.Instance);
var handler = type2SubHandler.GetOrThrow(genericType);
return handler.Release(burden);
}
public virtual void Track(object instance, Burden burden)
{
if (burden.RequiresPolicyRelease == false)
{
var lifestyle = ((object)burden.Model.CustomLifestyle) ?? burden.Model.LifestyleType;
throw new ArgumentException(
string.Format(
"Release policy was asked to track object '{0}', but its burden has 'RequiresPolicyRelease' set to false. If object is to be tracked the flag must be true. This is likely a bug in the lifetime manager '{1}'.",
instance, lifestyle));
}
try
{
using (@lock.ForWriting())
{
instance2Burden.Add(instance, burden);
}
}
catch (ArgumentNullException)
{
//eventually we should probably throw something more useful here too
throw;
}
catch (ArgumentException)
{
throw HelpfulExceptionsUtil.TrackInstanceCalledMultipleTimes(instance, burden);
}
burden.Released += OnInstanceReleased;
perfCounter.IncrementTrackedInstancesCount();
}
public override object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy)
{
var current = HttpContext.Current;
if (current == null)
{
throw new InvalidOperationException(
"HttpContext.Current is null. PerWebRequestLifestyle can only be used in ASP.Net");
}
var cachedBurden = current.Items[PerRequestObjectID];
if (cachedBurden != null)
{
return cachedBurden;
}
if (!PerWebRequestLifestyleModule.Initialized)
{
var message =
string.Format(
"Looks like you forgot to register the http module {0}{1}Add '<add name=\"PerRequestLifestyle\" type=\"Castle.MicroKernel.Lifestyle.PerWebRequestLifestyleModule, Castle.Windsor\" />' to the <httpModules> section on your web.config. If you're running IIS7 in Integrated Mode you will need to add it to <modules> section under <system.webServer>",
typeof(PerWebRequestLifestyleModule).FullName, Environment.NewLine);
throw new Exception(message);
}
var instance = base.Resolve(context, burden, releasePolicy);
current.Items[PerRequestObjectID] = burden;
PerWebRequestLifestyleModule.RegisterForEviction(this, burden);
return instance;
}
public override object Resolve(CreationContext context, IReleasePolicy releasePolicy)
{
// 1. read from cache
if (cachedBurden != null)
{
return(cachedBurden.Instance);
}
var initializing = false;
try
{
initializing = init.ExecuteThreadSafeOnce();
if (cachedBurden != null)
{
return(cachedBurden.Instance);
}
var burden = CreateInstance(context, true);
cachedBurden = burden;
Track(burden, releasePolicy);
return(burden.Instance);
}
finally
{
if (initializing)
{
init.EndThreadSafeOnceSection();
}
}
}
public override object Resolve(CreationContext context, IReleasePolicy releasePolicy)
{
// 1. read from cache
if (cachedBurden != null)
{
return cachedBurden.Instance;
}
var initializing = false;
try
{
initializing = init.ExecuteThreadSafeOnce();
if (cachedBurden != null)
{
return cachedBurden.Instance;
}
var burden = CreateInstance(context, true);
cachedBurden = burden;
Track(burden, releasePolicy);
return burden.Instance;
}
finally
{
if (initializing)
{
init.EndThreadSafeOnceSection();
}
}
}
protected virtual void Track(Burden burden, IReleasePolicy releasePolicy)
{
if (burden.RequiresPolicyRelease)
{
releasePolicy.Track(burden.Instance, burden);
}
}
public override void Track(object instance, Burden burden)
{
if (burden.Model.LifestyleType == LifestyleType.Custom
&& burden.Model.CustomLifestyle == typeof(UnmanagedLifestyleManager))
return;
base.Track(instance, burden);
}
public override bool ReleaseCore(Burden burden)
{
var genericType = ProxyUtil.GetUnproxiedType(burden.Instance);
var handler = GetSubHandler(CreationContext.CreateEmpty(), genericType);
return handler.Release(burden);
}
public override bool ReleaseCore(Burden burden)
{
var genericType = ProxyUtil.GetUnproxiedType(burden.Instance);
var handler = GetSubHandler(CreationContext.CreateEmpty(), genericType);
return(handler.Release(burden));
}
public override void Track(object instance, Burden burden)
{
var model = burden.Model;
if (burden.GraphRequiresDecommission || model.LifestyleType == LifestyleType.Pooled)
{
base.Track(instance, burden);
}
}
public override void Dispose()
{
var localInstance = cachedBurden;
if (localInstance != null)
{
localInstance.Release();
cachedBurden = null;
}
}
private object PerformCreation(CreationContext context, Burden burden)
{
if (customActivator != null)
{
return(customActivator.Create(context, burden));
}
return(base.InternalCreate(context));
}
public override void Track(object instance, Burden burden)
{
if (instantiateAndForgetItType.Equals(burden.Model.CustomLifestyle))
{
return;
}
base.Track(instance, burden);
}
public virtual object Create(CreationContext context, Burden burden)
{
var instance = InternalCreate(context);
burden.SetRootInstance(instance);
onCreation(model, instance);
return instance;
}
protected override void Track(Burden burden, IReleasePolicy releasePolicy)
{
var track = burden.RequiresPolicyRelease;
burden.RequiresPolicyRelease = false;
if (track)
{
releasePolicy.Track(burden.Instance, burden);
}
}
public override object Create(CreationContext context, Burden burden)
{
var instance = InternalCreate(context, burden);
burden.SetRootInstance(instance);
OnCreation(Model, instance);
return(instance);
}
private void setFormData(Burden item)
{
cmbBurdenTypeId.SelectedIndex = (int)item.BurdenTypeId - 1;
cmbCurrency.SelectedIndex = (int)item.BurdenTypeCurrency - 1;
numAmount.Value = item.BurdenTypeAmount;
txtWalletAddr.Text = item.WalletAddr;
dtpNextRunTime.Value = item.NextRunTime;
cmbRepeatUnit.SelectedIndex = (int)item.RepeatUnit - 1;
numRepeatValue.Value = item.RepeatValue;
}
public override void Track(object instance, Burden burden)
{
if (instance.GetType().FullName.StartsWith("MassTransit") ||
instance.Implements(typeof(Consumes <> .All)))
{
return;
}
base.Track(instance, burden);
}
public override void Dispose()
{
var localInstance = cachedBurden;
if (localInstance != null)
{
localInstance.Release();
cachedBurden = null;
}
}
public virtual object Create(CreationContext context, Burden burden)
{
var instance = InternalCreate(context);
burden.SetRootInstance(instance);
onCreation(model, instance);
return(instance);
}
private static bool httpSuccess(Burden burden, ExchangeResponseGenericBase resp)
{
var httpResp = resp.HttpResponse;
if (!httpResp.IsSuccessStatusCode)
{
taskResult(burden, false, httpResp.ErrorMessage());
}
return(httpResp.IsSuccessStatusCode);
}
public override bool Release(Burden burden)
{
if (releaseExtensions == null)
{
return base.Release(burden);
}
var invocation = new ReleaseInvocation(burden);
InvokeReleasePipeline(0, invocation);
return invocation.ReturnValue;
}
/// <summary>
/// Creates the <see cref="ISessionFactory"/> from the configuration
/// </summary>
/// <param name="context"></param>
/// <param name="burden"></param>
/// <returns></returns>
public override object Create(CreationContext context, Burden burden)
{
//HACK:bugfix SessionFactoryActivator override Create with burden
RaiseCreatingSessionFactory();
var configuration = Model.ExtendedProperties[Constants.SessionFactoryConfiguration]
as Configuration;
var f= configuration.BuildSessionFactory();
burden.SetRootInstance(f);
//onCreation(model, instance);
return f;
}
private object InternalCreate(CreationContext context, Burden burden)
{
var createOnUIThread = (CreateOnUIThreadDelegate)Model.ExtendedProperties[Constants.CreateOnUIThead];
if (createOnUIThread != null)
{
return(createOnUIThread(c => performCreation(c, burden), context));
}
return(base.InternalCreate(context));
}
public virtual void Track(object instance, Burden burden)
{
rwLock.AcquireWriterLock(Timeout.Infinite);
try
{
instance2Burden[instance] = burden;
}
finally
{
rwLock.ReleaseWriterLock();
}
}
/// <summary>
/// Creates the <see cref="ISessionFactory"/> from the configuration
/// </summary>
/// <param name="context"></param>
/// <param name="burden"> </param>
/// <returns></returns>
public override object Create(CreationContext context, Burden burden)
{
RaiseCreatingSessionFactory();
var configuration = Model.ExtendedProperties[Constants.SessionFactoryConfiguration]
as Configuration;
var factory = configuration.BuildSessionFactory();
burden.SetRootInstance(factory);
return factory;
}
/// <summary>
/// Creates the <see cref="ISessionFactory"/> from the configuration
/// </summary>
/// <param name="context"></param>
/// <param name="burden"> </param>
/// <returns></returns>
public override object Create(CreationContext context, Burden burden)
{
RaiseCreatingSessionFactory();
var configuration = Model.ExtendedProperties[Constants.SessionFactoryConfiguration]
as Configuration;
var factory = configuration.BuildSessionFactory();
burden.SetRootInstance(factory);
return(factory);
}
public override bool Release(Burden burden)
{
if (releaseExtensions == null)
{
return(base.Release(burden));
}
var invocation = new ReleaseInvocation(burden);
InvokeReleasePipeline(0, invocation);
return(invocation.ReturnValue);
}
/// <summary>
/// Gets the cached instance.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="createInstance">The create instance.</param>
/// <returns></returns>
public Burden GetCachedInstance(ComponentModel model, ScopedInstanceActivationCallback createInstance)
{
lock (_lock)
{
Burden burden = _scopeCache[model];
if (burden == null)
{
_scopeCache[model] = burden = createInstance(_onAfterCreated);
}
return(burden);
}
}
private void OnInstanceReleased(Burden burden)
{
using (@lock.ForWriting())
{
if (instance2Burden.Remove(burden.Instance) == false)
{
return;
}
burden.Released -= OnInstanceReleased;
}
perfCounter.DecrementTrackedInstancesCount();
}
/// <summary>
/// Creates the <see cref="ISessionFactory"/> from the configuration
/// </summary>
/// <param name="context"></param>
/// <param name="burden"></param>
/// <returns></returns>
public override object Create(CreationContext context, Burden burden)
{
//HACK:bugfix SessionFactoryActivator override Create with burden
RaiseCreatingSessionFactory();
var configuration = Model.ExtendedProperties[Constants.SessionFactoryConfiguration]
as Configuration;
var f = configuration.BuildSessionFactory();
burden.SetRootInstance(f);
//onCreation(model, instance);
return(f);
}
public override void Track(object instance, Burden burden)
{
ComponentModel model = burden.Model;
// to modify the way Castle handles the Transient object uncomment the following lines
if (model.LifestyleType == LifestyleType.Transient)
{
return;
}
base.Track(instance, burden);
}
/// <summary></summary>
public override void Track(object instance, Burden burden)
{
ComponentModel model = burden.Model;
// we skip the tracking for object marked with our custom Transient lifestyle manager
if ((model.LifestyleType == LifestyleType.Custom) && (typeof(TrulyTransientLifestyle) == model.CustomLifestyle))
{
return;
}
base.Track(instance, burden);
}
public override Burden GenerateClone(string sourceNote = "")
{
var wrappedBurden = WrappedBurden;
WrappedBurden = null;
var clone = CloneFrom(this, sourceNote);
WrappedBurden = wrappedBurden;
clone.WrappedBurden = WrappedBurden;
return(clone);
}
public virtual void Track(object instance, Burden burden)
{
using (@lock.ForWriting())
{
var oldCount = instance2Burden.Count;
instance2Burden[instance] = burden;
if (oldCount < instance2Burden.Count)
{
burden.Released += OnInstanceReleased;
}
}
}
private void OnInstanceReleased(Burden burden)
{
using (@lock.ForWriting())
{
if (instance2Burden.Remove(burden.Instance) == false)
{
return;
}
burden.Released -= OnInstanceReleased;
}
#if !SILVERLIGHT
trackedComponentsDiagnostic.DecrementTrackedInstancesCount();
#endif
}
public override object Resolve(CreationContext context, Burden burden, IReleasePolicy releasePolicy)
{
Burden cachedBurden;
var dictionary = Map;
if (dictionary.TryGetValue(ComponentActivator, out cachedBurden))
{
return burden.Instance;
}
var instance = base.Resolve(context, burden, releasePolicy);
dictionary.Add(ComponentActivator, burden);
return instance;
}
internal static void RegisterForEviction(PerWebRequestLifestyleManager manager, Burden burden)
{
var context = HttpContext.Current;
var candidates = (IDictionary<PerWebRequestLifestyleManager, Burden>)context.Items[PerRequestEvict];
if (candidates == null)
{
candidates = new Dictionary<PerWebRequestLifestyleManager, Burden>();
context.Items[PerRequestEvict] = candidates;
}
candidates.Add(manager, burden);
}
public void AttachExistingBurden(Burden burden)
{
ResolutionContext resolutionContext;
try
{
resolutionContext = resolutionStack.Peek();
}
catch (InvalidOperationException)
{
throw new ComponentActivatorException(
"Not in a resolution context. 'ActivateNewInstance' method can only be called withing a resoltion scope. (after 'EnterResolutionContext' was called within a handler)");
}
resolutionContext.AttachBurden(burden);
}
protected override object CreateInstance(CreationContext context, Burden burden)
{
var scope = InstanceScope.Current;
if (scope == null)
{
throw new InvalidOperationException("Scope is null");
}
object instance;
if (scope.Cache.TryGetValue(Model, out instance) == false)
{
instance = base.CreateInstance(context, burden);
scope.Cache[Model] = instance;
}
return instance;
}
/// <summary>
/// Tracks the specified instance.
/// </summary>
/// <param name="instance">The instance.</param>
/// <param name="burden">The burden.</param>
public override void Track( object instance, Burden burden )
{
var model = burden.Model;
if( this.Behavior == TrulyTransientReleasePolicyBehavior.IgnoreAllTransientObjects && model.LifestyleType == LifestyleType.Transient )
{
return;
}
// we skip the tracking for object marked with our custom Transient lifestyle manager
if( ( model.LifestyleType == LifestyleType.Custom ) && ( typeof( TrulyTransientLifestyleManager ) == model.CustomLifestyle ) )
{
return;
}
base.Track( instance, burden );
}
protected override object CreateInstance(CreationContext context, Burden burden)
{
if (pool == null)
{
lock (ComponentActivator)
{
if (pool == null)
{
pool = CreatePool(initialSize, maxSize);
}
}
}
var instance = pool.Request(context);
burden.SetRootInstance(instance);
return instance;
}
/// <summary>
/// Returns an instance of the component this handler
/// is responsible for
/// </summary>
/// <param name = "context"></param>
/// <param name = "requiresDecommission"></param>
/// <param name = "instanceRequired"></param>
/// <param name = "burden"></param>
/// <returns></returns>
protected object ResolveCore(CreationContext context, bool requiresDecommission, bool instanceRequired, out Burden burden)
{
if (CanResolvePendingDependencies(context) == false)
{
if (instanceRequired == false)
{
burden = null;
return null;
}
AssertNotWaitingForDependency();
}
using (var ctx = context.EnterResolutionContext(this, requiresDecommission))
{
var instance = lifestyleManager.Resolve(context, context.ReleasePolicy);
burden = ctx.Burden;
return instance;
}
}
private void OnInstanceReleased(Burden burden)
{
using (@lock.ForWriting())
{
if (instance2Burden.Remove(burden.Instance) == false)
{
return;
}
burden.Released -= OnInstanceReleased;
}
perfCounter.DecrementTrackedInstancesCount();
}
public virtual void Track(object instance, Burden burden)
{
if (burden.RequiresPolicyRelease == false)
{
var lifestyle = ((object)burden.Model.CustomLifestyle) ?? burden.Model.LifestyleType;
throw new ArgumentException(
string.Format(
"Release policy was asked to track object '{0}', but its burden has 'RequiresPolicyRelease' set to false. If object is to be tracked the flag must be true. This is likely a bug in the lifetime manager '{1}'.",
instance, lifestyle));
;
}
using (@lock.ForWriting())
{
instance2Burden.Add(instance, burden);
burden.Released += OnInstanceReleased;
}
perfCounter.IncrementTrackedInstancesCount();
}
/// <summary>
/// disposes the component instance (or recycle it).
/// </summary>
/// <param name = "burden"></param>
/// <returns></returns>
public virtual bool Release(Burden burden)
{
return ReleaseCore(burden);
}
/// <summary> /// Should be implemented by derived classes: /// disposes the component instance (or recycle it) /// </summary> /// <param name = "burden"></param> /// <returns>true if destroyed.</returns> public abstract bool ReleaseCore(Burden burden);
