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> /// 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 )); } }