public void InvokeAction(ControllerContext context, String actionName)
{
Requires.NotNull(context, "context");
Requires.NotNull(actionName, "actionName");
MethodInfo method = GetSuitableMethod(context, actionName);
if (method != null)
{
ParameterInfo[] parameters = method.GetParameters();
Object[] parameterValues = GetParameterValues(parameters, context.RouteData);
var actionContext = new ActionContext(context, actionName);
IAsyncController asyncController = context.Controller as IAsyncController;
if ((asyncController != null) && (method.ReturnType.Equals(typeof(void))))
{
asyncController.ActionCompleted += DefaultActionInvoker_ActionCompleted;
_contextCache.Add(asyncController, actionContext);
method.Invoke(context.Controller, parameterValues);
}
else
{
IActionResult actionResult = method.Invoke(context.Controller, parameterValues) as IActionResult;
if (actionResult != null)
{
actionResult.Execute(actionContext);
}
}
}
}
public void HandleError(RequestContext context, int code, HttpException exception)
{
if (ShouldLogException(code))
{
HandleExceptionWithElmah(exception);
}
Entities.Documents.Web.Webpage webpage = _getErrorPage.GetPage(code);
if (webpage != null)
{
HttpContextBase httpContext = context.HttpContext;
httpContext.ClearError();
httpContext.Response.Clear();
httpContext.Response.StatusCode = code;
httpContext.Response.TrySkipIisCustomErrors = true;
CurrentRequestData.CurrentPage = webpage;
System.Web.Mvc.Controller controller = _controllerManager.GetController(context, webpage, httpContext.Request.HttpMethod);
IAsyncController asyncController = (controller as IAsyncController);
asyncController.BeginExecute(new RequestContext(httpContext, controller.RouteData), asyncController.EndExecute, null);
}
else
{
throw exception;
}
}
public void ExecuteCallsInitialize()
{
// Arrange
RequestContext requestContext = new RequestContext(new Mock <HttpContextBase>().Object, new RouteData());
MockAsyncResult asyncResult = new MockAsyncResult();
Mock <AsyncController> mockController = new Mock <AsyncController>()
{
CallBase = true
};
mockController.Expect(c => c.BeginExecuteCore(It.IsAny <AsyncCallback>(), It.IsAny <object>())).Returns(asyncResult).Verifiable();
mockController.Expect(c => c.EndExecuteCore(asyncResult)).Verifiable();
AsyncController controller = mockController.Object;
IAsyncController iController = controller;
// Act
IAsyncResult returnedAsyncResult = iController.BeginExecute(requestContext, null, null);
iController.EndExecute(returnedAsyncResult);
// Assert
Assert.AreEqual(requestContext, controller.ControllerContext.RequestContext);
mockController.Verify();
}
protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
{
AddVersionHeader(httpContext);
// Get the controller type
string controllerName = RequestContext.RouteData.GetRequiredString("controller");
// Instantiate the controller and call Execute
IControllerFactory factory = ControllerBuilder.GetControllerFactory();
IController controller = factory.CreateController(RequestContext, controllerName);
if (controller == null)
{
throw new InvalidOperationException(
String.Format(
CultureInfo.CurrentUICulture,
MvcResources.ControllerBuilder_FactoryReturnedNull,
factory.GetType(),
controllerName));
}
BeginExecuteDelegate beginExecute;
EndExecuteDelegate endExecute;
IAsyncController asyncController = controller as IAsyncController;
if (asyncController != null)
{
beginExecute = asyncController.BeginExecute;
endExecute = asyncController.EndExecute;
}
else
{
// execute synchronous controller asynchronously
ExecuteDelegate executeDelegate = rc => SynchronizationContext.Sync(() => controller.Execute(rc));
beginExecute = executeDelegate.BeginInvoke;
endExecute = executeDelegate.EndInvoke;
}
BeginInvokeCallback beginCallback = (innerCallback, innerState) => {
try {
return(beginExecute(RequestContext, innerCallback, innerState));
}
catch {
factory.ReleaseController(controller);
throw;
}
};
AsyncCallback endCallback = ar => {
try {
endExecute(ar);
}
finally {
factory.ReleaseController(controller);
}
};
return(AsyncResultWrapper.Wrap(callback, state, beginCallback, endCallback, _processRequestTag));
}
protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
{
return(SecurityUtil.ProcessInApplicationTrust(() =>
{
IController controller;
IControllerFactory factory;
ProcessRequestInit(httpContext, out controller, out factory);
IAsyncController asyncController = controller as IAsyncController;
if (asyncController != null)
{
// asynchronous controller
BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
{
try
{
return asyncController.BeginExecute(RequestContext, asyncCallback, asyncState);
}
catch
{
factory.ReleaseController(asyncController);
throw;
}
};
EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult)
{
try
{
asyncController.EndExecute(asyncResult);
}
finally
{
factory.ReleaseController(asyncController);
}
};
SynchronizationContext syncContext = SynchronizationContextUtil.GetSynchronizationContext();
AsyncCallback newCallback = AsyncUtil.WrapCallbackForSynchronizedExecution(callback, syncContext);
return AsyncResultWrapper.Begin(newCallback, state, beginDelegate, endDelegate, _processRequestTag);
}
else
{
// synchronous controller
Action action = delegate
{
try
{
controller.Execute(RequestContext);
}
finally
{
factory.ReleaseController(controller);
}
};
return AsyncResultWrapper.BeginSynchronous(callback, state, action, _processRequestTag);
}
}));
}
protected virtual IAsyncResult BeginProcessRequest(
HttpContextBase context, AsyncCallback callback, object state)
{
AppendVersionHeader(context);
string controllerName = Context.RouteData.GetRequiredValue <string>("controller");
IControllerFactory factory = Builder.GetControllerFactory();
IController controller = factory.CreateController(Context, controllerName);
if (controller == null)
{
throw Error.CouldNotCreateController(controllerName);
}
IAsyncController asyncController = (controller as IAsyncController);
if (asyncController == null) // synchronous controller
{
Action action = delegate {
try
{
controller.Execute(Context);
}
finally
{
factory.ReleaseController(controller);
}
};
return(AsyncResultWrapper.BeginSynchronous(callback, state, action, _tag));
}
// asynchronous controller
BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState) {
try
{
return(asyncController.BeginExecute(Context, asyncCallback, asyncState));
}
finally
{
factory.ReleaseController(asyncController);
}
};
EndInvokeDelegate endDelegate = delegate(IAsyncResult asyncResult) {
try
{
asyncController.EndExecute(asyncResult);
}
finally
{
factory.ReleaseController(asyncController);
}
};
return(AsyncResultWrapper.Begin(AsyncTask.WrapCallbackForSynchronizedExecution(callback,
SynchronizationContextExtensions.GetSynchronizationContext()),
state, beginDelegate, endDelegate, _tag));
}
private void DefaultActionInvoker_ActionCompleted(Object sender, ActionResultEventArgs e)
{
IAsyncController controller = sender as IAsyncController;
if (controller != null)
{
controller.ActionCompleted -= DefaultActionInvoker_ActionCompleted;
if (e.ActionResult != null)
{
ActionContext context = null;
if (_contextCache.TryGetValue(controller, out context))
{
_contextCache.Remove(controller);
e.ActionResult.Execute(context);
}
}
}
}
public void Init()
{
container = mockRepository.DynamicMock<IMonoRailContainer>();
serviceProviderLocatorMock = mockRepository.DynamicMock<IServiceProviderLocator>();
controllerFactoryMock = mockRepository.DynamicMock<IControllerFactory>();
controllerMock = mockRepository.DynamicMock<IAsyncController>();
controllerDescriptorProviderMock = mockRepository.DynamicMock<IControllerDescriptorProvider>();
controllerContextFactoryMock = mockRepository.DynamicMock<IControllerContextFactory>();
SetupResult.For(container.UrlTokenizer).Return(new DefaultUrlTokenizer());
SetupResult.For(container.UrlBuilder).Return(new DefaultUrlBuilder());
SetupResult.For(container.EngineContextFactory).Return(new DefaultEngineContextFactory());
SetupResult.For(container.ControllerFactory).Return(controllerFactoryMock);
SetupResult.For(container.ControllerContextFactory).Return(controllerContextFactoryMock);
SetupResult.For(container.ControllerDescriptorProvider).Return(controllerDescriptorProviderMock);
SetupResult.For(container.StaticResourceRegistry).Return(new DefaultStaticResourceRegistry());
handlerFactory = new MonoRailHttpHandlerFactory(serviceProviderLocatorMock);
handlerFactory.ResetState();
handlerFactory.Configuration = new MonoRailConfiguration();
handlerFactory.Container = container;
}
public bool Handle(RequestContext context)
{
ArticleList articleList = GetArticleList(context.HttpContext.Request.Url.AbsolutePath);
if (articleList != null)
{
IControllerFactory controllerFactory = _controllerManager.ControllerFactory;
Controller controller = controllerFactory.CreateController(context, "ArticleRSS") as Controller;
controller.ControllerContext = new ControllerContext(context, controller);
RouteValueDictionary routeValueDictionary = new RouteValueDictionary();
routeValueDictionary["controller"] = "ArticleRSS";
routeValueDictionary["action"] = "Show";
routeValueDictionary["page"] = articleList;
controller.RouteData.Values.Merge(routeValueDictionary);
controller.RouteData.DataTokens["app"] = MrCMSApp.AppWebpages[articleList.GetType()];
IAsyncController asyncController = (controller as IAsyncController);
asyncController.BeginExecute(context, asyncController.EndExecute, null);
return(true);
}
return(false);
}
public void Init()
{
container = mockRepository.DynamicMock <IMonoRailContainer>();
serviceProviderLocatorMock = mockRepository.DynamicMock <IServiceProviderLocator>();
controllerFactoryMock = mockRepository.DynamicMock <IControllerFactory>();
controllerMock = mockRepository.DynamicMock <IAsyncController>();
controllerDescriptorProviderMock = mockRepository.DynamicMock <IControllerDescriptorProvider>();
controllerContextFactoryMock = mockRepository.DynamicMock <IControllerContextFactory>();
SetupResult.For(container.UrlTokenizer).Return(new DefaultUrlTokenizer());
SetupResult.For(container.UrlBuilder).Return(new DefaultUrlBuilder());
SetupResult.For(container.EngineContextFactory).Return(new DefaultEngineContextFactory());
SetupResult.For(container.ControllerFactory).Return(controllerFactoryMock);
SetupResult.For(container.ControllerContextFactory).Return(controllerContextFactoryMock);
SetupResult.For(container.ControllerDescriptorProvider).Return(controllerDescriptorProviderMock);
SetupResult.For(container.StaticResourceRegistry).Return(new DefaultStaticResourceRegistry());
handlerFactory = new MonoRailHttpHandlerFactory(serviceProviderLocatorMock);
handlerFactory.ResetState();
handlerFactory.Configuration = new MonoRailConfiguration();
handlerFactory.Container = container;
}
public void Handle(RequestContext context, Webpage webpage, Action <MrCMSUIController> beforeExecute)
{
System.Web.Mvc.Controller controller = _controllerManager.GetController(context, webpage, context.HttpContext.Request.HttpMethod);
_controllerManager.SetFormData(webpage, controller, context.HttpContext.Request.Form);
if (beforeExecute != null)
{
MrCMSUIController uiController = controller as MrCMSUIController;
if (uiController != null)
{
beforeExecute(uiController);
}
}
if (_seoSettings.EnableHtmlMinification)
{
context.HttpContext.Response.Filter = new WhitespaceFilter(context.HttpContext.Response.Filter);
}
IAsyncController asyncController = (controller as IAsyncController);
asyncController.BeginExecute(context, asyncController.EndExecute, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="MonoRailHttpHandler"/> class.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The asyncController.</param>
/// <param name="context">The context.</param>
/// <param name="sessionLess">Have session?</param>
public BaseAsyncHttpHandler(IEngineContext engineContext, IAsyncController controller, IControllerContext context,
bool sessionLess)
: base(engineContext, controller, context, sessionLess)
{
this.asyncController = controller;
}
/// <summary>
/// Initializes a new instance of the <see cref="SessionlessMonoRailHttpHandler"/> class.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="context">The context.</param>
public AsyncSessionlessMonoRailHttpHandler(IEngineContext engineContext, IAsyncController controller,
IControllerContext context)
: base(engineContext, controller, context, true)
{
}
public Handler(RequestContext requestContext)
{
this.requestContext = requestContext;
controller = Components.Create<ErrorLogController>();
}
/// <summary>
/// Initializes a new instance of the <see cref="MonoRailHttpHandler"/> class.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="context">The context.</param>
public AsyncMonoRailHttpHandler(IEngineContext engineContext, IAsyncController controller, IControllerContext context)
: base(engineContext, controller, context, false)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MonoRailHttpHandler"/> class.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The asyncController.</param>
/// <param name="context">The context.</param>
/// <param name="sessionLess">Have session?</param>
public BaseAsyncHttpHandler(IEngineContext engineContext, IAsyncController controller, IControllerContext context,
bool sessionLess)
: base(engineContext, controller, context, sessionLess)
{
this.asyncController = controller;
}
/// <summary>
/// Initializes a new instance of the <see cref="MonoRailHttpHandler"/> class.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="context">The context.</param>
public AsyncMonoRailHttpHandler(IEngineContext engineContext, IAsyncController controller, IControllerContext context)
: base(engineContext, controller, context, false)
{
}
/// <summary>
/// Creates the handler.
/// </summary>
/// <param name="controllerDesc">The controller descriptor.</param>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
/// <returns>
/// A new <see cref="T:System.Web.IHttpHandler"></see> object that processes the request.
/// </returns>
protected virtual IHttpAsyncHandler CreateAsyncHandler(ControllerMetaDescriptor controllerDesc,
IEngineContext engineContext, IAsyncController controller,
IControllerContext controllerContext)
{
if (IgnoresSession(controllerDesc.ControllerDescriptor))
{
return new AsyncSessionlessMonoRailHttpHandler(engineContext, controller, controllerContext);
}
return new AsyncMonoRailHttpHandler(engineContext, controller, controllerContext);
}
/// <summary>
/// Creates the handler.
/// </summary>
/// <param name="controllerDesc">The controller descriptor.</param>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="controllerContext">The controller context.</param>
/// <returns>
/// A new <see cref="T:System.Web.IHttpHandler"></see> object that processes the request.
/// </returns>
protected virtual IHttpAsyncHandler CreateAsyncHandler(ControllerMetaDescriptor controllerDesc,
IEngineContext engineContext, IAsyncController controller,
IControllerContext controllerContext)
{
if (IgnoresSession(controllerDesc.ControllerDescriptor))
{
return(new AsyncSessionlessMonoRailHttpHandler(engineContext, controller, controllerContext));
}
return(new AsyncMonoRailHttpHandler(engineContext, controller, controllerContext));
}
protected internal virtual IAsyncResult BeginProcessRequest(
HttpContextBase httpContext,
AsyncCallback callback,
object state
)
{
IController controller;
IControllerFactory factory;
ProcessRequestInit(httpContext, out controller, out factory);
IAsyncController asyncController = controller as IAsyncController;
if (asyncController != null)
{
// asynchronous controller
// Ensure delegates continue to use the C# Compiler static delegate caching optimization.
BeginInvokeDelegate <ProcessRequestState> beginDelegate = delegate(
AsyncCallback asyncCallback,
object asyncState,
ProcessRequestState innerState
)
{
try
{
return(innerState.AsyncController.BeginExecute(
innerState.RequestContext,
asyncCallback,
asyncState
));
}
catch
{
innerState.ReleaseController();
throw;
}
};
EndInvokeVoidDelegate <ProcessRequestState> endDelegate = delegate(
IAsyncResult asyncResult,
ProcessRequestState innerState
)
{
try
{
innerState.AsyncController.EndExecute(asyncResult);
}
finally
{
innerState.ReleaseController();
}
};
ProcessRequestState outerState = new ProcessRequestState()
{
AsyncController = asyncController,
Factory = factory,
RequestContext = RequestContext
};
SynchronizationContext callbackSyncContext =
SynchronizationContextUtil.GetSynchronizationContext();
return(AsyncResultWrapper.Begin(
callback,
state,
beginDelegate,
endDelegate,
outerState,
_processRequestTag,
callbackSyncContext: callbackSyncContext
));
}
else
{
// synchronous controller
Action action = delegate
{
try
{
controller.Execute(RequestContext);
}
finally
{
factory.ReleaseController(controller);
}
};
return(AsyncResultWrapper.BeginSynchronous(
callback,
state,
action,
_processRequestTag
));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SessionlessMonoRailHttpHandler"/> class.
/// </summary>
/// <param name="engineContext">The engine context.</param>
/// <param name="controller">The controller.</param>
/// <param name="context">The context.</param>
public AsyncSessionlessMonoRailHttpHandler(IEngineContext engineContext, IAsyncController controller,
IControllerContext context)
: base(engineContext, controller, context, true)
{
}
