public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (lifecycleEvent == LifecycleEvent.BeginRequest)
return true;
return Configuration.ContentTypes.Contains(context.Response.ContentType);
}
internal PoolConfig(Constructor <T> inConstructor, bool inbStrictTyping)
{
StrictTyping = inbStrictTyping;
if (StrictTyping)
{
Pool.VerifyType <T>();
}
Pool.VerifyConstructor(inConstructor);
m_Constructor = inConstructor;
Type type = typeof(T);
if (typeof(IPooledObject <T>).IsAssignableFrom(type))
{
m_OnConstruct += PooledObjectOnConstruct;
m_OnDestruct += PooledObjectOnDestruct;
m_OnAlloc += PooledObjectOnAlloc;
m_OnFree += PooledObjectOnFree;
}
if (typeof(IPoolConstructHandler).IsAssignableFrom(type))
{
m_OnConstruct += PooledConstructHandlerOnConstruct;
m_OnDestruct += PooledConstructHandlerOnDestruct;
}
if (typeof(IPoolAllocHandler).IsAssignableFrom(type))
{
m_OnAlloc += PooledAllocHandlerOnAlloc;
m_OnFree += PooledAllocHandlerOnFree;
}
}
private static DateTime?GetPeriodDateTimeFromEvent(LifecycleEvent @event, ResolveSchedulingPeriodsRequest request)
{
switch (@event)
{
case LifecycleEvent.RequestDate:
return(request.RequestDate ?? request.CalculationDate);
case LifecycleEvent.ContractSigned:
return(request.SigningDate ?? (request.RequestDate ?? request.CalculationDate).Value.AddMonths(1));
case LifecycleEvent.Approved:
return(request.ApprovalDate ?? (request.RequestDate ?? request.CalculationDate).Value.AddMonths(1));
case LifecycleEvent.FundsDisbursed:
return(request.DisbursmentDate ?? (request.RequestDate ?? request.CalculationDate).Value.AddMonths(1));
case LifecycleEvent.FirstInstallmentDate:
return(request.FirstInstallmentDate ?? (request.DisbursmentDate.HasValue ? (DateTime?)request.DisbursmentDate.Value.AddMonths(1) : null) ??
(request.RequestDate ?? request.CalculationDate).Value.AddMonths(2));
case LifecycleEvent.MaturityDate:
return(request.MaturityDate ?? (request.DisbursmentDate.HasValue ? (DateTime?)request.DisbursmentDate.Value.AddMonths(12) : null) ??
(request.RequestDate ?? request.CalculationDate).Value.AddMonths(13));
default:
return(null);
}
}
/// <inheritdoc />
public async Task WaitForLoadStateAsync(LifecycleEvent state = LifecycleEvent.Load, int?timeout = null)
{
Task <LoadStateEventArgs> task;
Waiter waiter = null;
try
{
lock (_loadStates)
{
if (_loadStates.Contains(state))
{
return;
}
waiter = SetupNavigationWaiter(timeout);
task = waiter.WaitForEventAsync <LoadStateEventArgs>(this, "LoadState", s =>
{
waiter.Log($" \"{s}\" event fired");
return(s.LifecycleEvent == state);
});
}
await task.ConfigureAwait(false);
}
finally
{
waiter?.Dispose();
}
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (lifecycleEvent == LifecycleEvent.BeginRequest || lifecycleEvent == LifecycleEvent.Handler)
return true;
return context.GetGlimpseMode() != GlimpseMode.Off;
}
/**
* onPauseイベント
*/
public void OnPauseEvent()
{
#if (!NDEBUG && DEBUG && ENABLE_LOG)
Console.WriteLine($"{TAG}OnPauseEvent:");
#endif
LifecycleEvent?.Invoke(false);
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (lifecycleEvent == LifecycleEvent.BeginRequest || lifecycleEvent == LifecycleEvent.Handler)
return true;
return !(context.Handler is Handler);
}
public void StateChanged(LifecycleEvent lifecycleEvent)
{
if (lifecycleEvent.GetState() == LifecycleEvent.LifecycleState.ClientConnected)
{
reset.Set();
}
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
var validResponseCodes = new List <int> {
200, 301, 302
};
return(validResponseCodes.Contains(context.Response.StatusCode));
}
public bool IsValid(HttpContextBase context, GlimpseConfiguration configuration, LifecycleEvent lifecycleEvent)
{
if (configuration.IpAddresses.Count == 0) return true; //no configured list, allow all IP's
var userIpAddress = GetUserIpAddress(context, configuration.IpForwardingEnabled);
return configuration.IpAddresses.Contains(userIpAddress);
}
private void OnFrameStoppedLoading(BasicFrameResponse e)
{
if (Frames.TryGetValue(e.FrameId, out var frame))
{
frame.OnLoadingStopped();
LifecycleEvent?.Invoke(this, new FrameEventArgs(frame));
}
}
private void OnLifeCycleEvent(LifecycleEventResponse e)
{
if (Frames.TryGetValue(e.FrameId, out var frame))
{
frame.OnLifecycleEvent(e.LoaderId, e.Name);
LifecycleEvent?.Invoke(this, new FrameEventArgs(frame));
}
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (lifecycleEvent == LifecycleEvent.Handler)
{
return(true);
}
return(!(context.Handler is Handler));
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (lifecycleEvent == LifecycleEvent.BeginRequest || lifecycleEvent == LifecycleEvent.Handler)
{
return(true);
}
return(context.GetGlimpseMode() != GlimpseMode.Off);
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (lifecycleEvent == LifecycleEvent.BeginRequest)
{
return(true);
}
return(Configuration.ContentTypes.Contains(context.Response.ContentType));
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (IpFilters.Count == 0)
{
return(true); //no configured list, allow all IP's
}
var userIpAddress = GetUserIpAddress(context);
return(IpFilters.Any(f => f.IsValid(userIpAddress)));
}
private void OnLifeCycleEvent(MessageEventArgs e)
{
if (Frames.ContainsKey(e.MessageData.frameId.ToString()))
{
Frame frame = Frames[e.MessageData.frameId.ToString()];
frame.OnLifecycleEvent(e.MessageData.loaderId.ToString(), e.MessageData.name.ToString());
LifecycleEvent?.Invoke(this, new FrameEventArgs(frame));
}
}
public void FireLifecycleEvent(LifecycleEvent.LifecycleState lifecycleState)
{
var lifecycleEvent = new LifecycleEvent(lifecycleState);
Logger.Info("HazelcastClient[" + _client.GetName() + "] is " + lifecycleEvent.GetState());
foreach (var entry in _lifecycleListeners)
{
entry.Value.StateChanged(lifecycleEvent);
}
}
/// <inheritdoc />
public async Task WaitForLoadStateAsync(LifecycleEvent state = LifecycleEvent.Load, int?timeout = null)
{
if (_loadStates.Contains(state))
{
return;
}
using var waiter = SetupNavigationWaiter(timeout);
await waiter.WaitForEventAsync <LoadStateEventArgs>(this, "LoadState", s =>
{
waiter.Log($" \"{s}\" event fired");
return(s.LifecycleEvent == state);
}).ConfigureAwait(false);
}
public bool IsValid(HttpContextBase context, GlimpseConfiguration configuration, LifecycleEvent lifecycleEvent)
{
if (configuration.UrlBlackList.Count == 0) return true; //no configured list, allow all URL's
foreach (GlimpseUrl url in configuration.UrlBlackList)
{
if (Regex.IsMatch(context.Request.CurrentExecutionFilePath,url.Url,RegexOptions.IgnoreCase))
{
return false;
}
}
// if nothing matched, the URL is allowed
return true;
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (context == null) return false;
foreach (var validator in Validators)
{
if (!validator.IsValid(context, lifecycleEvent))
{
Logger.Warn(validator.GetType().FullName + " invalided request (it will now be ignored) with id " + context.GetGlimpseRequestId() + " (" + context.Request.Path + ")");
return false;
}
}
return true;
}
public void FireLifecycleEvent(LifecycleEvent.LifecycleState lifecycleState)
{
var lifecycleEvent = new LifecycleEvent(lifecycleState);
Logger.Info($"HazelcastClient[{_client.Name}] {VersionUtil.GetDllVersion()} is {lifecycleEvent.GetState()}");
Task.Run(() =>
{
lock (_lifecycleEventLock)
{
foreach (var entry in _lifecycleListeners)
{
entry.Value.StateChanged(lifecycleEvent);
}
}
}).IgnoreExceptions();
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (Configuration.UrlBlackList.Count == 0)
{
return(true); //no configured list, allow all URL's
}
foreach (GlimpseUrl url in Configuration.UrlBlackList)
{
if (Regex.IsMatch(context.Request.CurrentExecutionFilePath, url.Url, RegexOptions.IgnoreCase))
{
return(false);
}
}
// if nothing matched, the URL is allowed
return(true);
}
private void SetLifecycleStateAccordingTo(LifecycleEvent lifecycleEvent)
{
switch (lifecycleEvent)
{
case LifecycleEvent.ViewDidLoad:
CurrentState = LifecycleState.Loaded;
break;
case LifecycleEvent.ViewDidAppear:
CurrentState = LifecycleState.Appeared;
break;
case LifecycleEvent.ViewDidDisappear:
CurrentState = LifecycleState.Disappeared;
break;
}
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (context == null)
{
return(false);
}
foreach (var validator in Validators)
{
if (!validator.IsValid(context, lifecycleEvent))
{
Logger.Warn(validator.GetType().FullName + " invalided request (it will now be ignored) with id " + context.GetGlimpseRequestId() + " (" + context.Request.Path + ")");
return(false);
}
}
return(true);
}
public async void FireLifecycleEvent(LifecycleEvent.LifecycleState lifecycleState)
{
var lifecycleEvent = new LifecycleEvent(lifecycleState);
Logger.Info($"HazelcastClient[{_client.Name}] {VersionUtil.GetDllVersion()} is {lifecycleEvent.GetState()}");
await Task.Factory.StartNew(() =>
{
foreach (var entry in _lifecycleListeners)
{
try
{
entry.Value.StateChanged(lifecycleEvent);
}
catch (Exception e)
{
if (Logger.IsFinestEnabled)
{
Logger.Finest("Exception occured in a Lifecycle listeners", e);
}
}
}
}, Task.Factory.CancellationToken, Task.Factory.CreationOptions, _eventExecutor).IgnoreExceptions();
}
public void RegisterOnFree(LifecycleEvent <T> inEvent)
{
m_OnFree += inEvent;
}
public bool IsValid(HttpContextBase context, GlimpseConfiguration configuration, LifecycleEvent lifecycleEvent)
{
var validResponseCodes = new List<int> { 200, 301, 302 };
return validResponseCodes.Contains(context.Response.StatusCode);
}
public void RegisterOnAlloc(LifecycleEvent <T> inEvent)
{
m_OnAlloc += inEvent;
}
public bool IsValid(HttpContextBase context, GlimpseConfiguration configuration, LifecycleEvent lifecycleEvent)
{
if (configuration.IpAddresses.Count == 0) return true; //no configured list, allow all IP's
return configuration.IpAddresses.Contains(context.Request.UserHostAddress);
}
public void StateChanged(LifecycleEvent lifecycleEvent)
{
_action(lifecycleEvent);
}
public bool IsValid(HttpContextBase context, LifecycleEvent lifecycleEvent)
{
if (IpFilters.Count == 0) return true; //no configured list, allow all IP's
var userIpAddress = GetUserIpAddress(context);
return IpFilters.Any(f => f.IsValid(userIpAddress));
}
public StatementSyntax GetPipelineAdditionStatement()
{
if (WasSplit)
{
return(MiddlewareSyntaxHelper.ConstructMiddlewareRegistrationSyntax(NewClassName, LifecycleEvent.ToString(), OriginClassName));
}
return(MiddlewareSyntaxHelper.ConstructMiddlewareRegistrationSyntax(NewClassName, LifecycleEvent.ToString()));
}
public StatementSyntax GetPipelineAdditionStatement()
{
return(MiddlewareSyntaxHelper.ConstructMiddlewareLambdaRegistrationSyntax(MiddlewareLambda, LifecycleEvent.ToString()));
}
/**
* onPauseイベント
*/
public void OnPauseEvent()
{
Debug.Log(TAG + "OnPauseEvent:");
LifecycleEvent?.Invoke(false);
}
/**
* onResumeイベント
*/
public void OnResumeEvent()
{
Debug.Log(TAG + "OnResumeEvent:");
LifecycleEvent?.Invoke(true);
}
public void RegisterOnDestruct(LifecycleEvent <T> inEvent)
{
m_OnDestruct += inEvent;
}
public void HandleLifecycleEvent(LifecycleEvent lifecycleEvent)
{
CurrentEvent = lifecycleEvent;
SetLifecycleStateAccordingTo(lifecycleEvent);
SyncObservers();
}
