// Register an assembly as an application module, which makes its compiled web pages // and embedded resources available internal void Register(ApplicationPart applicationPart, Func<object> registerPageAction) { // Throw if this assembly has been registered if (_applicationParts.ContainsKey(applicationPart.Assembly)) { throw new InvalidOperationException( String.Format(CultureInfo.CurrentCulture, WebPageResources.ApplicationPart_ModuleAlreadyRegistered, applicationPart.Assembly)); } // Throw if the virtual path is already in use if (_registeredVirtualPaths.ContainsKey(applicationPart.RootVirtualPath)) { throw new InvalidOperationException( String.Format(CultureInfo.CurrentCulture, WebPageResources.ApplicationPart_ModuleAlreadyRegisteredForVirtualPath, applicationPart.RootVirtualPath)); } // REVIEW: Should we register the app-part after we scan the assembly for webpages? // Add the part to the list if (_applicationParts.TryAdd(applicationPart.Assembly, applicationPart)) { // We don't really care about the value _registeredVirtualPaths.TryAdd(applicationPart.RootVirtualPath, true); // Get all of the web page types var webPageTypes = from type in applicationPart.Assembly.GetTypes() where type.IsSubclassOf(_webPageType) select type; // Register each of page with the plan9 foreach (Type webPageType in webPageTypes) { RegisterWebPage(applicationPart, webPageType, registerPageAction); } } }
public static Exception PublishingFailedBecauseVariableValueWasNotPresent( ApplicationPart part, Component component, string variableName) => new PublishingException( $"Could not publish application part {part.Name}. No variable with name ${variableName} " + $"was found");
/// <summary> /// Create the view engine. /// </summary> public static void Init() { // Create new precompiled view engine var engine = new PrecompiledMvcEngine(typeof(ManagerModule).Assembly) { UsePhysicalViewsIfNewer = true }; engine.PartialViewLocationFormats = engine.PartialViewLocationFormats.Union(ExtensionsFolder).ToArray(); var standard = new RazorViewEngine(); standard.PartialViewLocationFormats = standard.PartialViewLocationFormats.Union(ExtensionsFolder).ToArray(); ViewEngines.Engines.Insert(0, standard); ViewEngines.Engines.Insert(1, engine); VirtualPathFactoryManager.RegisterVirtualPathFactory(engine); // Register the manager area var manager = new ManagerRegistration(); var context = new AreaRegistrationContext(manager.AreaName, RouteTable.Routes); manager.RegisterArea(context); // Register custom model binders RegisterBinders(); // Register json deserialization for post data ValueProviderFactories.Factories.Add(new JsonValueProviderFactory()); // Register application part ApplicationPart.Register(new ApplicationPart(typeof(ManagerModule).Assembly, "~/")); }
internal static void RegisterAdminModule() { // Add a admin module as an application module (precompiled) ApplicationPart.Register( new ApplicationPart(typeof(SiteAdmin).Assembly, AdminVirtualPath) ); }
private void RegisterWebPage( ApplicationPart module, Type webPageType, Func <object> registerPageAction ) { var virtualPathAttribute = webPageType .GetCustomAttributes(typeof(PageVirtualPathAttribute), false) .Cast <PageVirtualPathAttribute>() .SingleOrDefault(); // Ignore it if it doesn't have a PageVirtualPathAttribute if (virtualPathAttribute == null) { return; } // Get the path of the page relative to the module root string virtualPath = GetRootRelativeVirtualPath( module.RootVirtualPath, virtualPathAttribute.VirtualPath ); // Create a factory for the page type Func <object> pageFactory = registerPageAction ?? NewTypeInstance(webPageType); // Register a page factory for it _virtualPathFactory.RegisterPath(virtualPath, pageFactory); }
public static Exception ClaimFailedBecauseVariableValueWasNotPresent( ApplicationPart part, string environment, string variableName) => new ClaimVersionFailedException( $"Could not claim application part {part.Name}. No value for variable ${variableName} " + $"in env {environment}");
public IHttpHandler GetHttpHandler(RequestContext requestContext) { // Get the package name and static resource path from the route string partName = (string)requestContext.RouteData.GetRequiredString("module"); // Try to find an application module by this name ApplicationPart module = _partRegistry[partName]; // Throw an exception if we can't find the module by name if (module == null) { throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, WebPageResources.ApplicationPart_ModuleCannotBeFound, partName ) ); } // Get the resource path string path = (string)requestContext.RouteData.GetRequiredString("path"); // Return the resource handler for this module and path return(new ResourceHandler(module, path)); }
public void RemoveControllers(string pluginId) { ApplicationPart last = _applicationPartManager.ApplicationParts.First(m => m.Name == pluginId); _applicationPartManager.ApplicationParts.Remove(last); ResetControllActions(); }
public void DisableModule(string moduleName) { ApplicationPart last = _partManager.ApplicationParts.First(p => p.Name == moduleName); _partManager.ApplicationParts.Remove(last); ResetControllActions(); }
private static CompiledRazorAssemblyPart GetViewsPartOrNull(ApplicationPartManager partManager, ApplicationPart assemblyPart) { var viewsAssemblyName = assemblyPart.Name + ".Views"; return(partManager .ApplicationParts .OfType <CompiledRazorAssemblyPart>() .FirstOrDefault(p => p.Name == viewsAssemblyName)); }
public async Task <IEnumerable <DeployedEnvironment> > GetDeployments( [Service] IPublishingService service, [Parent] ApplicationPart applicationPart, CancellationToken cancellationToken) { IReadOnlyList <Environment> envs = await service .GetDeployedEnvironmentByPartIdAsync(applicationPart.Id, cancellationToken); return(envs.Select(x => new DeployedEnvironment(applicationPart.Id, x.Id))); }
public void PopulateFeature(ApplicationPart applicationPart, ControllerFeature feature) { if (feature == null) { throw new ArgumentNullException(nameof(feature)); } foreach (var provider in this._applicationFeatureProviders) { provider.PopulateFeature(applicationPart, feature); } }
public static void Start() { SiteAdmin.Register("~/Rabbit/", "Rabbit Framework Admin", "Administrative Tools to manage modules, to generate code and to run unit tests."); var appPart = new ApplicationPart(typeof(PreApplicationStartCode).Assembly, SiteAdmin.GetVirtualPath("~/Rabbit/")); ApplicationPart.Register(appPart); SiteEngine.Start(); }
public void DisableModule(string moduleName) { ApplicationPart last = _partManager.ApplicationParts.First(p => p.Name == moduleName); _partManager.ApplicationParts.Remove(last); CollectibleAssemblyLoadContext context = PluginsLoadContexts.Get(moduleName); context.Disable(); ResetControllActions(); }
public ResourceHandler(ApplicationPart applicationPart, string path) { if (applicationPart == null) { throw new ArgumentNullException("applicationPart"); } if (String.IsNullOrEmpty(path)) { throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path"); } _applicationPart = applicationPart; _path = path; }
public void GetResourceNameFromVirtualPathForItemInSubDir() { // Arrange var moduleName = "my-module"; var path = "/bar/foo"; // Act var name = ApplicationPart.GetResourceNameFromVirtualPath(moduleName, path); // Assert Assert.Equal(name, "my-module.bar.foo"); }
public void GetResourceNameFromVirtualPathForTopLevelPath() { // Arrange var moduleName = "my-module"; var path = "foo.baz"; // Act var name = ApplicationPart.GetResourceNameFromVirtualPath(moduleName, path); // Assert Assert.Equal(name, moduleName + "." + path); }
public void GetResourceNameFromVirtualPathForItemWithSpaces() { // Arrange var moduleName = "my-module"; var path = "/program files/data files/my file .foo"; // Act var name = ApplicationPart.GetResourceNameFromVirtualPath(moduleName, path); // Assert Assert.Equal(name, "my-module.program_files.data_files.my file .foo"); }
public void GetResourceVirtualPathEncodesModuleName() { // Arrange var moduleName = "Debugger Package v?&%"; var moduleRoot = "~/root-path/sub-path"; var path = moduleRoot + "/foo.txt"; // Act var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path); // Assert Assert.Equal(virtualPath, "~/r.ashx/" + "Debugger%20Package%20v?&%" + "/" + "foo.txt"); }
public void ResourceHandlerThrows404IfResourceNotFound() { // Arrange var applicationPart = new ApplicationPart(BuildAssembly(), "~/my-app-assembly"); MemoryStream stream = new MemoryStream(); var response = new Mock<HttpResponseBase>(); response.SetupGet(c => c.OutputStream).Returns(stream); response.SetupSet(c => c.ContentType = "image/jpeg").Verifiable(); var resourceHandler = new ResourceHandler(applicationPart, "does-not-exist"); // Act and Assert ExceptionAssert.Throws<HttpException>(() => resourceHandler.ProcessRequest(response.Object), "The resource file \"does-not-exist\" could not be found."); }
public void ResolveVirtualPathResolvesAppRelativePathsUsingAppVirtualPath() { // Arrange var basePath = "~/base"; var path = "@/somefile"; var appPartRoot = "~/app/"; // Act var virtualPath = ApplicationPart.ResolveVirtualPath(appPartRoot, basePath, path); // Assert Assert.Equal(virtualPath, "~/app/somefile"); }
public void ResolveVirtualPathResolvesRegularPathsUsingBaseVirtualPath() { // Arrange var basePath = "~/base/"; var path = "somefile"; var appPartRoot = "~/app/"; // Act var virtualPath = ApplicationPart.ResolveVirtualPath(appPartRoot, basePath, path); // Assert Assert.Equal("~/base/somefile", virtualPath); }
public void ResolveVirtualPathDoesNotAffectRootRelativePaths() { // Arrange var basePath = "~/base"; var path = "~/somefile"; var appPartRoot = "~/app/"; // Act var virtualPath = ApplicationPart.ResolveVirtualPath(appPartRoot, basePath, path); // Assert Assert.Equal(virtualPath, "~/somefile"); }
public void GetResourceVirtualPathForTopLevelItemAndNestedModuleRootPath() { // Arrange var moduleName = "my-module"; var moduleRoot = "~/root-path/sub-path"; var path = moduleRoot + "/foo.txt"; // Act var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path); // Assert Assert.Equal(virtualPath, "~/r.ashx/" + moduleName + "/" + "foo.txt"); }
public void ApplicationPartRegistryLooksUpPartsByAssembly() { // Arrange var assembly = BuildAssembly(); var part = new ApplicationPart(assembly, "~/mymodule"); var dictionary = new DictionaryBasedVirtualPathFactory(); var registry = new ApplicationPartRegistry(dictionary); Func<object> myFunc = () => "foo"; // Act registry.Register(part, myFunc); // Assert Assert.AreEqual(registry[assembly], part); }
public void RegisterThrowsIfAssemblyAlreadyRegistered() { // Arrange var part = new ApplicationPart(BuildAssembly(), "~/mymodule"); var dictionary = new DictionaryBasedVirtualPathFactory(); var registry = new ApplicationPartRegistry(dictionary); Func<object> myFunc = () => "foo"; // Act registry.Register(part, myFunc); // Assert ExceptionAssert.Throws<InvalidOperationException>(() => registry.Register(part, myFunc), String.Format("The assembly \"{0}\" is already registered.", part.Assembly.ToString())); }
public void GetResourceVirtualPathForItemPathWithParameters() { // Arrange var moduleName = "DebuggerPackage"; var moduleRoot = "~/root-path/sub-path"; var itemPath = "some-path/some-more-please/foo.jpg?size=45&height=20"; var path = moduleRoot + "/" + itemPath; // Act var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path); // Assert Assert.Equal(virtualPath, "~/r.ashx/" + moduleName + "/" + itemPath); }
public void GetResourceVirtualPathForNestedItemPath() { // Arrange var moduleName = "DebuggerPackage"; var moduleRoot = "~/root-path/sub-path"; var itemPath = "some-path/some-more-please/foo.txt"; var path = moduleRoot + "/" + itemPath; // Act var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path); // Assert Assert.Equal(virtualPath, "~/r.ashx/" + moduleName + "/" + itemPath); }
public void PopulateFeature(ApplicationPart parts, ControllerFeature feature) { if (parts.Types == null) { return; } foreach (var type in parts.Types) { if (type.IsGrain() && this.IsController(type)) { feature.Controllers.Add(type); } } }
public void ControllerFeature_should_have_all_kind_of_close_generic_type_controller() { var parts = new ApplicationPart[] { new AssemblyPart(typeof(UserController <>).GetTypeInfo().Assembly) }; var feature = new ControllerFeature(); new GenericControllerFeatureProvider().PopulateFeature(parts, feature); Assert.Equal(3, feature.Controllers.Count); var controllers = feature.Controllers; var actualSummary = controllers.Contains(typeof(UserController <User>).GetTypeInfo()) && controllers.Contains(typeof(UserController <Owner>).GetTypeInfo()) && controllers.Contains(typeof(UserController <Admin>).GetTypeInfo()); Assert.True(actualSummary); }
public void ResourceHandlerThrows404IfResourceNotFound() { // Arrange var applicationPart = new ApplicationPart(BuildAssembly(), "~/my-app-assembly"); MemoryStream stream = new MemoryStream(); var response = new Mock <HttpResponseBase>(); response.SetupGet(c => c.OutputStream).Returns(stream); response.SetupSet(c => c.ContentType = "image/jpeg").Verifiable(); var resourceHandler = new ResourceHandler(applicationPart, "does-not-exist"); // Act and Assert Assert.Throws <HttpException>(() => resourceHandler.ProcessRequest(response.Object), "The resource file \"does-not-exist\" could not be found."); }
public void RegisterThrowsIfPathAlreadyRegistered() { // Arrange var part = new ApplicationPart(BuildAssembly(), "~/mymodule"); var dictionary = new DictionaryBasedVirtualPathFactory(); var registry = new ApplicationPartRegistry(dictionary); Func<object> myFunc = () => "foo"; // Act registry.Register(part, myFunc); // Assert var newPart = new ApplicationPart(BuildAssembly("different-assembly"), "~/mymodule"); ExceptionAssert.Throws<InvalidOperationException>(() => registry.Register(newPart, myFunc), "An application module is already registered for virtual path \"~/mymodule/\"."); }
public void ApplicationPartRegistryLooksUpPartsByName() { // Arrange var part = new ApplicationPart(BuildAssembly(), "~/mymodule"); var dictionary = new DictionaryBasedVirtualPathFactory(); var registry = new ApplicationPartRegistry(dictionary); Func<object> myFunc = () => "foo"; // Act registry.Register(part, myFunc); // Assert Assert.Equal(registry["my-assembly"], part); Assert.Equal(registry["MY-aSSembly"], part); }
private static IEnumerable <Type> GetApplicationControllerTypes() { var controllerProvider = new ControllerFeatureProvider(); var applicationParts = new ApplicationPart[] { new AssemblyPart(typeof(HomeController).GetTypeInfo().Assembly) }; var feature = new ControllerFeature(); controllerProvider.PopulateFeature(applicationParts, feature); return(feature.Controllers.Select(c => c.AsType())); }
public void RegisterThrowsIfAssemblyAlreadyRegistered() { // Arrange var part = new ApplicationPart(BuildAssembly(), "~/mymodule"); var dictionary = new DictionaryBasedVirtualPathFactory(); var registry = new ApplicationPartRegistry(dictionary); Func <object> myFunc = () => "foo"; // Act registry.Register(part, myFunc); // Assert Assert.Throws <InvalidOperationException>(() => registry.Register(part, myFunc), String.Format("The assembly \"{0}\" is already registered.", part.Assembly.ToString())); }
public void ApplicationPartRegistryLooksUpPartsByAssembly() { // Arrange var assembly = BuildAssembly(); var part = new ApplicationPart(assembly, "~/mymodule"); var dictionary = new DictionaryBasedVirtualPathFactory(); var registry = new ApplicationPartRegistry(dictionary); Func <object> myFunc = () => "foo"; // Act registry.Register(part, myFunc); // Assert Assert.Equal(registry[assembly], part); }
public void ResourceHandlerWritesContentsOfFileToStream() { // Arrange var applicationPart = new ApplicationPart(BuildAssembly(), "~/my-app-assembly"); MemoryStream stream = new MemoryStream(); var response = new Mock<HttpResponseBase>(); response.SetupGet(c => c.OutputStream).Returns(stream); response.SetupSet(c => c.ContentType = "image/jpeg").Verifiable(); var resourceHandler = new ResourceHandler(applicationPart, "bar.foo.jpg"); // Act resourceHandler.ProcessRequest(response.Object); // Assert response.Verify(); Assert.AreEqual(Encoding.Default.GetString(stream.ToArray()), _fileContent); }
private void RegisterWebPage(ApplicationPart module, Type webPageType, Func<object> registerPageAction) { var virtualPathAttribute = webPageType.GetCustomAttributes(typeof(PageVirtualPathAttribute), false) .Cast<PageVirtualPathAttribute>() .SingleOrDefault(); // Ignore it if it doesn't have a PageVirtualPathAttribute if (virtualPathAttribute == null) { return; } // Get the path of the page relative to the module root string virtualPath = GetRootRelativeVirtualPath(module.RootVirtualPath, virtualPathAttribute.VirtualPath); // Create a factory for the page type Func<object> pageFactory = registerPageAction ?? NewTypeInstance(webPageType); // Register a page factory for it _virtualPathFactory.RegisterPath(virtualPath, pageFactory); }
public void RegisterCreatesRoutesForValidPages() { // Arrange var part = new ApplicationPart(BuildAssembly(), "~/mymodule"); var dictionary = new DictionaryBasedVirtualPathFactory(); var registry = new ApplicationPartRegistry(dictionary); Func<object> myFunc = () => "foo"; // Act registry.Register(part, myFunc); // Assert Assert.IsTrue(dictionary.Exists("~/mymodule/Page1")); Assert.AreEqual(dictionary.CreateInstance("~/mymodule/Page1"), "foo"); Assert.IsFalse(dictionary.Exists("~/mymodule/Page2")); Assert.IsFalse(dictionary.Exists("~/mymodule/Page3")); }
// Register an assembly as an application module, which makes its compiled web pages // and embedded resources available public void Register(ApplicationPart applicationPart) { Register(applicationPart, registerPageAction: null); // Use default action which creates a new page }