Пример #1
0
        bool IRequestTransform.Transform(IRequestContext context)
        {
            if (_rules == null)
            {
                return(false);
            }

            if (_incoming)
            {
                context.Log?.Log(LogType.Logic, LogLevel.Standard, () => "Executing URL rewrite script on incoming request");

                var ruleContext = (IRuleExecutionContext) new IncomingContext(context);

                var ruleResult = _rules.Evaluate(ruleContext);

                if (ruleResult.EndRequest)
                {
                    return(true);
                }

                if (ruleContext.UrlIsModified)
                {
                    context.Incoming.Path       = new PathString(ruleContext.NewPathString);
                    context.Incoming.Query      = new QueryString(ruleContext.NewParametersString);
                    context.Incoming.DomainName = ruleContext.NewHost;
                }
            }
            else
            {
                var ruleContext = (IRuleExecutionContext) new OutgoingContext(context);

                context.Outgoing.OnSendHeaders.Add(ctx =>
                {
                    context.Log?.Log(LogType.Logic, LogLevel.Standard, () => "Executing URL rewrite script on outgoing response");
                    _rules.Evaluate(ruleContext);
                });
            }

            return(false);
        }
Пример #2
0
        private void OnBeginRequest(object source, EventArgs args)
        {
            var rules = _rules;

            if (rules == null)
            {
                return;
            }

            var application = (HttpApplication)source;
            var context     = application.Context;
            var requestInfo = _factory.Create <IRequestInfo>().Initialize(application, _log);

            try
            {
#if !TRACE_ALL
                if (_tracingEnabled &&
                    _forwardTracePredicate != null &&
                    _forwardTracePredicate(context.Request.RawUrl))
                {
#endif
                requestInfo.ExecutionMode = ExecutionMode.ExecuteAndTrace;
                requestInfo.Log.TraceRequestBegin(requestInfo);
#if !TRACE_ALL
            }
#endif

                var ruleListResult = _rules.Evaluate(requestInfo);

#if !TRACE_ALL
                if (_tracingEnabled &&
                    requestInfo.ExecutionMode == ExecutionMode.ExecuteOnly &&
                    _reverseTracePredicate != null)
                {
                    var newPath = "/";
                    if (requestInfo.NewPath != null && requestInfo.NewPath.Count > 0)
                    {
                        newPath = string.Join("/", requestInfo.NewPath).ToLower();
                    }

                    if (_reverseTracePredicate(newPath))
                    {
                        requestInfo.ExecutionMode = ExecutionMode.TraceOnly;
                        requestInfo.Log.TraceRequestBegin(requestInfo);
                        _rules.Evaluate(requestInfo);
                    }
                }
#endif

                if (requestInfo.ExecutionMode != ExecutionMode.ExecuteOnly)
                {
                    requestInfo.Log.TraceRequestEnd(requestInfo);
                }

                requestInfo.ExecuteDeferredActions();

                if (ruleListResult.EndRequest)
                {
                    application.CompleteRequest();
                }
                else if (requestInfo.UrlIsModified)
                {
                    requestInfo.Context.RewritePath(requestInfo.NewPathString, "", requestInfo.NewParametersString);
                }
            }
            catch (ThreadAbortException)
            {
            }
            catch (Exception ex)
            {
                _log.LogException(requestInfo, ex);
            }
        }