public void ChangeFilter(Action <IRequestFilter> f)
{
IRequestFilter o = Filter;
f(o);
Filter = (RequestFilter)o;
}
private void InitializeRequestFilter(IRequestFilter requestFilter)
{
var factory = new RuleFactory();
foreach (var item in appSettings.AllowedUrlRegexps)
{
var rule = factory.CreateRule(FilterRuleType.Regex);
rule.Initialize(new FilterRuleSettings {
Expression = item, Result = FilterResult.Allow
});
requestFilter.Load(rule);
}
foreach (var item in appSettings.AllowedUrls)
{
var rule = factory.CreateRule(FilterRuleType.Simplified);
rule.Initialize(new FilterRuleSettings {
Expression = item, Result = FilterResult.Allow
});
requestFilter.Load(rule);
}
if (requestFilter.Process(new Request {
Url = startUrl
}) != FilterResult.Allow)
{
var rule = factory.CreateRule(FilterRuleType.Simplified);
rule.Initialize(new FilterRuleSettings {
Expression = startUrl, Result = FilterResult.Allow
});
requestFilter.Load(rule);
logger.Debug($"Automatically created filter rule to allow start URL '{startUrl}'.");
}
}
public FilterCondition[] GetFilterConditions(IRequestFilter cmd)
{
List <FilterCondition> conditions = new List <FilterCondition>();
if (cmd != null && cmd.Fields != null)
{
for (int i = 0; i < cmd.Fields.Length; i++)
{
conditions.Add(
new FilterCondition
{
FilterType = cmd.FiltersType[i],
Property = cmd.Fields[i],
DisplayName = this.GetDisplayName(cmd.Fields[i]),
DefaultOperator = int.Parse(cmd.Operators[i]),
DisplayOperator = this.GetDisplayOperator(cmd.Fields[i], cmd.Operators[i]),
DefaultValue = cmd.Values[i],
DisplayValue = this.GetDisplayValue(cmd.FiltersType[i], cmd.Fields[i], cmd.Values[i]),
FilterExistsColumn = (cmd.ExistsColumns != null) ? cmd.ExistsColumns[i] : string.Empty
});
}
conditions.AddRange(GetInternalFilterConditions(cmd));
}
else if (cmd == null || cmd.HasDefaultConditions || (cmd.FilterInternalDictionary != null && cmd.FilterInternalDictionary.Count > 0))
{
conditions = this.GetDefaultFilterConditions(cmd);
}
return((conditions != null) ? conditions.ToArray() : new FilterCondition[0]);
}
/// <summary>
/// Filters the request.
/// </summary>
/// <param name="readBuffer">The read buffer.</param>
/// <param name="offset">The offset.</param>
/// <param name="length">The length.</param>
/// <param name="toBeCopied">if set to <c>true</c> [to be copied].</param>
/// <param name="left">The left, the size of the data which has not been processed</param>
/// <returns></returns>
TRequestInfo FilterRequest(byte[] readBuffer, int offset, int length, bool toBeCopied, out int left)
{
if (!AppServer.OnRawDataReceived(this, readBuffer, offset, length))
{
left = 0;
return(null);
}
var requestInfo = m_RequestFilter.Filter(this, readBuffer, offset, length, toBeCopied, out left);
if (requestInfo == null)
{
int leftBufferCount = m_RequestFilter.LeftBufferSize;
if (leftBufferCount >= AppServer.Config.MaxRequestLength)
{
if (Logger.IsErrorEnabled)
{
Logger.ErrorFormat("Max command length: {0}, current processed length: {1}", AppServer.Config.MaxRequestLength, leftBufferCount);
}
Close(CloseReason.ServerClosing);
return(null);
}
}
//If next request filter wasn't set, still use current request filter in next round received data processing
if (m_RequestFilter.NextRequestFilter != null)
{
m_RequestFilter = m_RequestFilter.NextRequestFilter;
}
return(requestInfo);
}
IRequestRouter IRequestRouter.Add(IRequestFilter filter, int priority, string scenarioName)
{
var router = new RequestRouter();
((IRequestRouter)this).Register(router, filter, priority, scenarioName);
return(router);
}
internal RequestHandler(AppConfig appConfig, IRequestFilter filter, ILogger logger, BrowserSettings settings, IText text)
{
this.filter = filter;
this.logger = logger;
this.settings = settings;
this.resourceHandler = new ResourceHandler(appConfig, settings, filter, logger, text);
}
private void InitializeRequestFilter(IRequestFilter requestFilter)
{
if (settings.Filter.ProcessContentRequests || settings.Filter.ProcessMainRequests)
{
var factory = new RuleFactory();
foreach (var settings in settings.Filter.Rules)
{
var rule = factory.CreateRule(settings.Type);
rule.Initialize(settings);
requestFilter.Load(rule);
}
logger.Debug($"Initialized request filter with {settings.Filter.Rules.Count} rule(s).");
if (requestFilter.Process(new Request {
Url = settings.StartUrl
}) != FilterResult.Allow)
{
var rule = factory.CreateRule(FilterRuleType.Simplified);
rule.Initialize(new FilterRuleSettings {
Expression = settings.StartUrl, Result = FilterResult.Allow
});
requestFilter.Load(rule);
logger.Debug($"Automatically created filter rule to allow start URL{(WindowSettings.UrlPolicy.CanLog() ? $" '{settings.StartUrl}'" : "")}.");
}
}
}
public PaginatedList <TEntity> GetEntities(IComponentContext container, IRequestFilter cmd, Type modelType, string[] ordersBy, string[] directions, string[] includeProperties)
{
Filter filter = FilterFactory.GenerateFilter(container, cmd, modelType, new KeyValue {
Key = (!string.IsNullOrEmpty(cmd.ParentKey)) ? int.Parse(cmd.ParentKey) : 0, Value = cmd.ParentValue
});
return(context.Paginate(container, filter, cmd, modelType, cmd.Page, cmd.Take, ordersBy, directions, includeProperties));
}
public IDisposable Register(IRunable runable, IRequestFilter filter, int priority, Type declaringType)
{
Runable = runable;
Filter = filter;
Priority = priority;
DeclaringType = declaringType;
return(this);
}
internal ResourceHandler(AppConfig appConfig, BrowserFilterSettings settings, IRequestFilter filter, ILogger logger, IText text)
{
this.appConfig = appConfig;
this.filter = filter;
this.logger = logger;
this.settings = settings;
this.text = text;
}
public UdpSocketServer(IAppServer appServer, IPEndPoint localEndPoint, IRequestFilterFactory <TRequestInfo> requestFilterFactory)
: base(appServer, localEndPoint)
{
if (typeof(TRequestInfo).IsSubclassOf(typeof(UdpRequestInfo)))
{
m_SessionIDFromRequestInfo = true;
m_UdpRequestFilter = requestFilterFactory.CreateFilter(this.AppServer);
}
}
internal ResourceHandler(BrowserSettings settings, IRequestFilter filter, ILogger logger, IText text)
{
this.algorithm = new SHA256Managed();
this.htmlLoader = new HtmlLoader(text);
this.filter = filter;
this.logger = logger;
this.text = text;
this.settings = settings;
}
internal TestableResourceHandler(
AppConfig appConfig,
IRequestFilter filter,
ILogger logger,
BrowserSettings settings,
WindowSettings windowSettings,
IText text) : base(appConfig, filter, logger, settings, windowSettings, text)
{
}
/// <summary>
/// Initializes the specified app session by AppServer and SocketSession.
/// </summary>
/// <param name="appServer">The app server.</param>
/// <param name="socketSession">The socket session.</param>
/// <param name="requestFilter">The request filter.</param>
public virtual void Initialize(IAppServer <TAppSession, TRequestInfo> appServer, ISocketSession socketSession, IRequestFilter <TRequestInfo> requestFilter)
{
AppServer = (AppServerBase <TAppSession, TRequestInfo>)appServer;
SocketSession = socketSession;
SessionID = socketSession.SessionID;
m_Connected = true;
m_RequestFilter = requestFilter;
OnInit();
}
public IDisposable Register(IRunable runable, IRequestFilter filter, int priority, Type declaringType, string scenarioName)
{
Runable = runable;
Filter = filter;
Priority = priority;
DeclaringType = declaringType;
UserSegmentKey = scenarioName;
return(this);
}
public IDisposable Register(IRunable runable, IRequestFilter filter, int priority, MethodInfo methodInfo, string scenarioName)
{
Runable = runable;
Filter = filter;
Priority = priority;
MethodInfo = methodInfo;
UserSegmentKey = scenarioName;
return(this);
}
private static FilterCondition GetFilterCondition(IRequestFilter request, int index)
{
return(new FilterCondition
{
FilterType = request.FiltersType[index],
Property = request.Fields[index],
DefaultOperator = int.Parse(request.Operators[index]),
DefaultValue = request.Values[index],
FilterExistsColumn = (request.ExistsColumns != null) ? request.ExistsColumns[index] : null
});
}
public void AddFilter(string name)
{
IRequestFilter filter = Gateway.Filters.GetFilter(name);
if (filter == null)
{
Gateway.HttpServer.Log(BeetleX.EventArgs.LogType.Warring, $"{Url} route add filter error {name} filter not found!");
return;
}
AddFilter(filter);
}
/// <summary>
/// Initializes a new instance of the <see cref="UdpSocketServer<TRequestInfo>"/> class.
/// </summary>
/// <param name="appServer">The app server.</param>
/// <param name="listeners">The listeners.</param>
public UdpSocketServer(IAppServer appServer, ListenerInfo[] listeners)
: base(appServer, listeners)
{
m_RequestHandler = appServer as IRequestHandler <TRequestInfo>;
m_EndPointIPv4 = new IPEndPoint(IPAddress.Any, 0);
m_EndPointIPv6 = new IPEndPoint(IPAddress.IPv6Any, 0);
m_IsUdpRequestInfo = typeof(TRequestInfo).IsSubclassOf(typeof(UdpRequestInfo));
m_UdpRequestFilter = ((IRequestFilterFactory <TRequestInfo>)appServer.RequestFilterFactory).CreateFilter(appServer, null, null);
}
internal RequestHandler(
ILogger logger,
BrowserSettings settings,
IRequestFilter filter,
ResourceHandler resourceHandler,
IText text)
{
this.logger = logger;
this.settings = settings;
this.filter = filter;
this.resourceHandler = resourceHandler;
}
IDisposable IRequestRouter.Register(
IRequestRouter router,
IRequestFilter filter,
int priority,
string scenarioName)
{
return(Add(new Registration
{
Priority = priority,
Filter = filter,
TestScenarioName = string.IsNullOrWhiteSpace(scenarioName) ? null : scenarioName,
Router = router
}));
}
private void LoadFilter(IRequestFilter filter)
{
for (int i = 0; i < Filters.Count; i++)
{
if (Filters[i].Name == filter.Name)
{
Filters[i] = filter;
return;
}
}
Filters.Add(filter);
Gateway.HttpServer.Log(BeetleX.EventArgs.LogType.Info, $"{Url} route load {filter.Name} filter");
mRequestFilters = Filters.ToArray();
}
public override bool Handshake(IWebSocketSession session, WebSocketRequestFilterBase previousFilter, out IRequestFilter<IWebSocketFragment> dataFrameReader)
{
if (!VersionTag.Equals(session.SecWebSocketVersion) && NextProcessor != null)
{
return NextProcessor.Handshake(session, previousFilter, out dataFrameReader);
}
dataFrameReader = null;
session.ProtocolProcessor = this;
var secWebSocketKey = session.Items.GetValue<string>(WebSocketConstant.SecWebSocketKey, string.Empty);
if (string.IsNullOrEmpty(secWebSocketKey))
{
return false;
}
var responseBuilder = new StringBuilder();
string secKeyAccept = string.Empty;
try
{
secKeyAccept = Convert.ToBase64String(SHA1.Create().ComputeHash(Encoding.ASCII.GetBytes(secWebSocketKey + m_Magic)));
}
catch (Exception)
{
return false;
}
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseHeadLine10);
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseUpgradeLine);
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseConnectionLine);
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseAcceptLine, secKeyAccept);
var subProtocol = session.GetAvailableSubProtocol(session.Items.GetValue<string>(WebSocketConstant.SecWebSocketProtocol, string.Empty));
if (!string.IsNullOrEmpty(subProtocol))
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseProtocolLine, subProtocol);
responseBuilder.AppendWithCrCf();
byte[] data = Encoding.UTF8.GetBytes(responseBuilder.ToString());
session.SendRawData(data, 0, data.Length);
dataFrameReader = new WebSocketDataFrameRequestFilter();
return true;
}
internal RequestHandler(
AppConfig appConfig,
IRequestFilter filter,
ILogger logger,
ResourceHandler resourceHandler,
BrowserSettings settings,
WindowSettings windowSettings,
IText text)
{
this.filter = filter;
this.logger = logger;
this.resourceHandler = resourceHandler;
this.settings = settings;
this.windowSettings = windowSettings;
}
IDisposable IRequestRouter.Register(
IRunable runable,
IRequestFilter filter,
int priority,
Type declaringType,
string scenarioName)
{
return(Add(new Registration
{
Priority = priority,
Filter = filter,
TestScenarioName = string.IsNullOrWhiteSpace(scenarioName) ? null : scenarioName,
Runable = runable,
DeclaringType = declaringType ?? runable.GetType()
}));
}
/// <summary>
/// 注册筛选器
/// </summary>
/// <param name="filter"></param>
public static void RegisterFilter(IRequestFilter filter)
{
var type = filter.GetType();
if (!filters.ContainsKey(type))
{
lock (filtersLock)
{
if (!filters.ContainsKey(type))
{
var newFilters = new Dictionary<Type, IRequestFilter>(filters);
newFilters.Add(type, filter);
filters = newFilters;
}
}
}
}
internal ResourceHandler(
AppConfig appConfig,
IRequestFilter filter,
ILogger logger,
BrowserSettings settings,
WindowSettings windowSettings,
IText text)
{
this.appConfig = appConfig;
this.algorithm = new SHA256Managed();
this.filter = filter;
this.htmlLoader = new HtmlLoader(text);
this.logger = logger;
this.settings = settings;
this.windowSettings = windowSettings;
this.text = text;
}
IDisposable IRequestRouter.Register(IRequestRouter router, IRequestFilter filter, int priority)
{
var registration = new Registration
{
Priority = priority,
Filter = filter,
Router = router
};
lock (_registrations)
{
_registrations.Add(registration);
_registrations.Sort();
}
return(registration);
}
private List <FilterCondition> GetInternalFilterConditions(IRequestFilter cmd)
{
var filters = this.Filters.Where(p => p.Internal == true).ToList();
var conditions = new List <FilterCondition>();
if (filters.Count == 0 || cmd == null || cmd.FilterInternalDictionary == null || cmd.FilterInternalDictionary.Count == 0)
{
return(conditions);
}
foreach (PropertyValue value in filters)
{
string key = Convert.ToString(value.DefaultValue);
conditions.Add(this.GetFilterCondition(value, cmd.FilterInternalDictionary[key]));
}
return(conditions);
}
public IProductsList Get(IRequestFilter productsFilter)
{
//var url = new BackendUrl(productsFilter);
//IJObject products = _backend.Request(url.ToString());
var product1 = new Product {
UPC = "123"
};
var product2 = new Product {
UPC = "321"
};
IEnumerable <Product> products =
new List <Product> {
product1, product2
}.Where(
p => GetValue <string>(p, productsFilter.FindBy).Contains(productsFilter.FindByValue));
return(new ProductsList(products));
}
IDisposable IRequestRouter.Register(IRunable runable, IRequestFilter filter, int priority, Type declaringType)
{
var registration = new Registration
{
Priority = priority,
Filter = filter,
Runable = runable,
DeclaringType = declaringType ?? runable.GetType()
};
lock (_registrations)
{
_registrations.Add(registration);
_registrations.Sort();
}
return(registration);
}
public override bool Handshake(IWebSocketSession session, WebSocketRequestFilterBase previousFilter, out IRequestFilter<IWebSocketFragment> dataFrameReader)
{
var secKey1 = session.Items.GetValue<string>(WebSocketConstant.SecWebSocketKey1, string.Empty);
var secKey2 = session.Items.GetValue<string>(WebSocketConstant.SecWebSocketKey2, string.Empty);
if (string.IsNullOrEmpty(secKey1) && string.IsNullOrEmpty(secKey2) && NextProcessor != null)
{
return NextProcessor.Handshake(session, previousFilter, out dataFrameReader);
}
session.ProtocolProcessor = this;
var secKey3 = session.Items.GetValue<byte[]>(WebSocketConstant.SecWebSocketKey3, m_ZeroKeyBytes);
var responseBuilder = new StringBuilder();
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseHeadLine00);
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseUpgradeLine);
responseBuilder.AppendWithCrCf(WebSocketConstant.ResponseConnectionLine);
if (!string.IsNullOrEmpty(session.Origin))
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseOriginLine, session.Origin);
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseLocationLine, session.UriScheme, session.Host, session.Path);
var subProtocol = session.GetAvailableSubProtocol(session.Items.GetValue<string>(WebSocketConstant.SecWebSocketProtocol, string.Empty));
if (!string.IsNullOrEmpty(subProtocol))
responseBuilder.AppendFormatWithCrCf(WebSocketConstant.ResponseProtocolLine, subProtocol);
responseBuilder.AppendWithCrCf();
byte[] data = Encoding.UTF8.GetBytes(responseBuilder.ToString());
session.SendRawData(data, 0, data.Length);
//Encrypt message
byte[] secret = GetResponseSecurityKey(secKey1, secKey2, secKey3);
session.SendRawData(secret, 0, secret.Length);
dataFrameReader = new WebSocketDataRequestFilter(previousFilter);
return true;
}
private List <FilterCondition> GetDefaultFilterConditions(IRequestFilter cmd)
{
var filters = this.Filters.Where(p => p.PreLoaded == true || p.Internal == true).ToList();
var conditions = new List <FilterCondition>();
if (filters.Count == 0)
{
return(conditions);
}
foreach (PropertyValue value in filters)
{
if (value.Internal == false)
{
conditions.Add(this.GetFilterCondition(value, null));
}
}
conditions.AddRange(GetInternalFilterConditions(cmd));
return(conditions);
}
public bool Handshake(IWebSocketSession session, WebSocketRequestFilterBase previousReader, out IRequestFilter<IWebSocketFragment> dataFrameReader)
{
dataFrameReader = null;
session.SendRawData(m_SwitchResponse, 0, m_SwitchResponse.Length);
return true;
}
public static void InitSessionFactory(ISessionFactory sessionFactory, IRequestFilter requestFilter)
{
_sessionFactory = sessionFactory;
_requestFilter = requestFilter;
}
public abstract bool Handshake(IWebSocketSession session, WebSocketRequestFilterBase previousFilter, out IRequestFilter<IWebSocketFragment> dataFrameReader);
public void AddRequestFilter(IRequestFilter requestFilter)
{
_serverContext.RequestFilter = requestFilter;
}
