public void Configuration(IAppBuilder appBuilder) { HttpConfiguration config = new HttpConfiguration(); PhysicalFileSystem physicalFileSystem = new PhysicalFileSystem(@".\wwwroot"); FileServerOptions fileOptions = new FileServerOptions(); fileOptions.EnableDefaultFiles = true; fileOptions.RequestPath = PathString.Empty; fileOptions.FileSystem = physicalFileSystem; fileOptions.DefaultFilesOptions.DefaultFileNames = new[] {"index.html"}; fileOptions.StaticFileOptions.FileSystem = fileOptions.FileSystem = physicalFileSystem; fileOptions.StaticFileOptions.ServeUnknownFileTypes = true; try { config.MessageHandlers.Add(new ProxyHandler(this.configSettings)); appBuilder.UseWebApi(config); appBuilder.UseFileServer(fileOptions); } catch (Exception e) { Trace.WriteLine(e); } }
public void Configuration(IAppBuilder appBuilder) { HttpConfiguration config = new HttpConfiguration(); PhysicalFileSystem physicalFileSystem = new PhysicalFileSystem(@".\wwwroot"); FileServerOptions fileOptions = new FileServerOptions(); fileOptions.EnableDefaultFiles = true; fileOptions.RequestPath = PathString.Empty; fileOptions.FileSystem = physicalFileSystem; fileOptions.DefaultFilesOptions.DefaultFileNames = new[] {"Default.html"}; fileOptions.StaticFileOptions.FileSystem = fileOptions.FileSystem = physicalFileSystem; fileOptions.StaticFileOptions.ServeUnknownFileTypes = true; FormatterConfig.ConfigureFormatters(config.Formatters); RouteConfig.RegisterRoutes(config); appBuilder.UseWebApi(config); appBuilder.UseFileServer(fileOptions); //CORS & SignalR appBuilder.UseCors(CorsOptions.AllowAll); HubConfiguration configR = new HubConfiguration(); configR.EnableDetailedErrors = true; appBuilder.MapSignalR(configR); GlobalHost.DependencyResolver.Register(typeof(IUserIdProvider), () => new SignalRUserIdProvider()); config.EnsureInitialized(); }
// This code configures Web API. The Startup class is specified as a type // parameter in the WebApp.Start method. public void Configuration(IAppBuilder appBuilder) { //Database.SetInitializer<ServerContext>(null); // Configure Web API for self-host. HttpConfiguration config = new HttpConfiguration(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); appBuilder.UseWebApi(config); var physicalFileSystem = new PhysicalFileSystem(@"./wwwroot"); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] { "index.html" }; appBuilder.UseFileServer(options); }
public void Configuration(IAppBuilder app) { // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888 //HttpConfiguration config = new HttpConfiguration(); //config.Routes.MapHttpRoute( // name: "DefaultWebApi", // routeTemplate: "api/{controller}/{id}", // defaults: new { id = RouteParameter.Optional } //); //app.UseWebApi(config); var physicalFileSystem = new PhysicalFileSystem(@"./Plugins"); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] { "Index.html" }; app.UseFileServer(options); app.MapSignalR(); }
public void Configuration(IAppBuilder app) { // Configure Web API for self-host. HttpConfiguration config = new HttpConfiguration(); // Enable attribute based routing config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); app.UseCors(CorsOptions.AllowAll); app.UseWebApi(config); // Configure Web API for static files var physicalFileSystem = new PhysicalFileSystem(@".\www"); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] { "index.html" }; app.UseFileServer(options); }
// This code configures Web API. The Startup class is specified as a type // parameter in the WebApp.Start method. public void Configuration(IAppBuilder app) { HttpConfiguration config = new HttpConfiguration(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); app.UseWebApi(config); var root = Directory.GetParent(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location)).Parent.FullName; var physicalFileSystem = new PhysicalFileSystem(root); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] { "app\\index.html" }; app.UseFileServer(options); }
public void Configuration(IAppBuilder app) { #if DEBUG app.UseErrorPage(); #endif app.Use( async (context, next) => { // Log all exceptions and incoming requests Console.WriteLine("{0} {1} {2}", context.Request.Method, context.Request.Path, context.Request.QueryString); try { await next(); } catch (Exception exception) { Console.WriteLine(exception.ToString()); throw; } }); var contentFileSystem = new PhysicalFileSystem("Content"); app.UseBabel(new BabelFileOptions() { StaticFileOptions = new StaticFileOptions() { FileSystem = contentFileSystem }}); app.UseFileServer(new FileServerOptions() { FileSystem = contentFileSystem }); app.Use<CommentsMiddleware>(); }
public void Configuration(IAppBuilder appBuilder) { var physicalFileSystem = new PhysicalFileSystem(@"C:\Work\Advanced\ACSStarTrek\ACS.Client"); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] { "index.html" }; appBuilder.UseFileServer(options); HttpConfiguration config = new HttpConfiguration(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); appBuilder.UseWebApi(config); }
static void Main() { log.Info("Starting application"); string baseUrl = "http://*****:*****@"C:\projects\LuxRecon\Lux.Recon.UI"; var root = Directory.GetParent(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location)).Parent.FullName; var fileSystem = new PhysicalFileSystem(root); WebApp.Start<Startup>(new StartOptions(baseUrl) { ServerFactory = "Microsoft.Owin.Host.HttpListener" }); // Launch default browser Process.Start(baseUrl); // Create HttpCient and make a request to api/values HttpClient client = new HttpClient(); var response2 = client.GetAsync(baseUrl + "/main").Result; //Console.WriteLine(response2); //Console.WriteLine(response2.Content.ReadAsStringAsync().Result); Console.ReadLine(); }
public static IDisposable Start(DirectoryPath path, int port, bool forceExtension) { IDisposable server; try { StartOptions options = new StartOptions("http://localhost:" + port); // Disable built-in owin tracing by using a null trace output // http://stackoverflow.com/questions/17948363/tracelistener-in-owin-self-hosting options.Settings.Add(typeof(ITraceOutputFactory).FullName, typeof(NullTraceOutputFactory).AssemblyQualifiedName); server = WebApp.Start(options, app => { Microsoft.Owin.FileSystems.IFileSystem outputFolder = new PhysicalFileSystem(path.FullPath); // Disable caching app.Use((c, t) => { c.Response.Headers.Append("Cache-Control", "no-cache, no-store, must-revalidate"); c.Response.Headers.Append("Pragma", "no-cache"); c.Response.Headers.Append("Expires", "0"); return t(); }); // Support for extensionless URLs if (!forceExtension) { app.UseExtensionlessUrls(new ExtensionlessUrlsOptions { FileSystem = outputFolder }); } // Serve up all static files app.UseDefaultFiles(new DefaultFilesOptions { RequestPath = PathString.Empty, FileSystem = outputFolder, DefaultFileNames = new List<string> { "index.html", "index.htm", "home.html", "home.htm", "default.html", "default.html" } }); app.UseStaticFiles(new StaticFileOptions { RequestPath = PathString.Empty, FileSystem = outputFolder, ServeUnknownFileTypes = true }); }); } catch (Exception ex) { Trace.Critical("Error while running preview server: {0}", ex.Message); return null; } Trace.Information("Preview server listening on port {0} and serving from path {1}", port, path); return server; }
public void InitializesFileSystem() { // Arrange IFileSystem expected = new PhysicalFileSystem(@"C:\"); // Act var router = new DefaultRouter(expected); // Assert Assert.Same(expected, router.FileSystem); }
public static void Configure(IAppBuilder app) { const string rootFolder = "."; var fileSystem = new PhysicalFileSystem(rootFolder); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = fileSystem }; app.UseFileServer(options); }
public void Configuration(IAppBuilder app) { var config = new HttpConfiguration(); var container = CreateKernel(); _backgroundTicker = new BackgroundTicker(container.Resolve<IHubMessageService>()); app.UseAutofacMiddleware(container).UseAutofacWebApi(config); app.MapSignalR(); WebApiConfig.Register(config); app.UseWebApi(config); var physicalFileSystem = new PhysicalFileSystem(@".."); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] { "index.html" }; app.UseFileServer(options); ActorSystem StatsActorSystem = container.Resolve<IActorSystemFactory>().Create("StatsCoordinatorActor"); MongoDbPersistence.Instance.Apply(StatsActorSystem); BsonClassMap.RegisterClassMap<CreateHitterMessage>(cm => { cm.AutoMap(); }); BsonClassMap.RegisterClassMap<HitHomeRunMessage>(cm => { cm.AutoMap(); }); BsonClassMap.RegisterClassMap<HomeRunHitEvent>(cm => { cm.AutoMap(); }); BsonClassMap.RegisterClassMap<HitterAddedEvent>(cm => { cm.AutoMap(); }); StatsActors stats = container.Resolve<StatsActors>(); stats.statActorRef = StatsActorSystem.ActorOf(StatsActorSystem.DI().Props<StatsCoordinatorActor>() .WithRouter(new RoundRobinPool(2)), "StatsCoordinatorActor"); stats.statCommandActorRef = StatsActorSystem.ActorOf(StatsActorSystem.DI().Props<StatsCoordinatorCommandActor>(), "StatsCoordinatorCommandActor"); stats.statViewActorRef = StatsActorSystem.ActorOf(StatsActorSystem.DI().Props<StatsCoordinatorViewActor>(), "StatsCoordinatorViewActor"); }
public void Configuration(IAppBuilder app) { var physicalFileSystem = new PhysicalFileSystem("wwwroot"); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = false; options.DefaultFilesOptions.DefaultFileNames = new[] { "index.html" }; app.UseFileServer(options); }
public void Configuration(IAppBuilder app) { //logger for testing //app.Use(typeof (RequestLogger)); app.MapSignalR(); //Where our content lives string contentPath = Path.Combine(Environment.CurrentDirectory, @".\Modules\App\www"); var physicalFileSystem = new PhysicalFileSystem(contentPath); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] {"index.htm"}; //Default file to serve if none specified options.StaticFileOptions.OnPrepareResponse = _ => _.OwinContext.Response.Headers.Add("X-UA-Compatible", new [] { "IE=Edge" }); app.UseFileServer(options); var config = new HttpConfiguration(); // JSON stuff //config.Formatters.JsonFormatter.SerializerSettings.TypeNameHandling = TypeNameHandling.Auto; //config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter()); //Route config config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApiWithAction", routeTemplate: "api/{controller}/{action}/{id}", defaults: new {id = RouteParameter.Optional} ); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new {id = RouteParameter.Optional} ); app.UseWebApi(config); }
private void ConfigureManager(IAppBuilder appBuilder) { var fileSystem = new PhysicalFileSystem("./Portal"); appBuilder.UseDefaultFiles(new DefaultFilesOptions { DefaultFileNames = new[] {"index.html"}, FileSystem = fileSystem }); appBuilder.UseStaticFiles(new StaticFileOptions { RequestPath = new PathString(""), FileSystem = fileSystem, ServeUnknownFileTypes = true, }); }
public void Configuration(IAppBuilder appBuilder) { PhysicalFileSystem physicalFileSystem = new PhysicalFileSystem(@".\wwwroot"); FileServerOptions fileOptions = new FileServerOptions(); fileOptions.EnableDefaultFiles = true; fileOptions.RequestPath = PathString.Empty; fileOptions.FileSystem = physicalFileSystem; fileOptions.DefaultFilesOptions.DefaultFileNames = new[] {"index.html"}; fileOptions.StaticFileOptions.FileSystem = physicalFileSystem; fileOptions.StaticFileOptions.ServeUnknownFileTypes = true; appBuilder.UseFileServer(fileOptions); }
void ConfigureAdmin(IAppBuilder application) { var appFolder = FindAppRoot(); var fileSystem = new PhysicalFileSystem(appFolder); var options = new FileServerOptions { EnableDirectoryBrowsing = true, FileSystem = fileSystem, EnableDefaultFiles = true }; application.UseFileServer(options); }
public TripContext(string fileDBLocation) { _fileDBLocation = fileDBLocation; var fileSystem = new Microsoft.Owin.FileSystems.PhysicalFileSystem(""); IFileInfo fi; if (fileSystem.TryGetFileInfo(_fileDBLocation, out fi)) { var json = File.ReadAllText(fi.PhysicalPath); var result = JsonConvert.DeserializeObject <List <Trip> >(json); Trips = result.ToList(); } }
public TripContext(string fileDBLocation) { _fileDBLocation = fileDBLocation; var fileSystem = new Microsoft.Owin.FileSystems.PhysicalFileSystem(""); IFileInfo fi; if (fileSystem.TryGetFileInfo(_fileDBLocation, out fi)) { var json = File.ReadAllText(fi.PhysicalPath); var result = JsonConvert.DeserializeObject<List<Trip>>(json); Trips = result.ToList(); } }
public void Configuration(IAppBuilder app) { // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888 var webRroot = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "app"); var fileSystem = new PhysicalFileSystem(webRroot); var options = new FileServerOptions { EnableDirectoryBrowsing = false, FileSystem = fileSystem }; options.StaticFileOptions.RequestPath = new PathString("/app"); app.UseFileServer(enableDirectoryBrowsing:true); }
public bool SaveChanges() { // write trips to json file, overwriting the old one var json = JsonConvert.SerializeObject(Trips); var fileSystem = new Microsoft.Owin.FileSystems.PhysicalFileSystem(""); IFileInfo fi; if (fileSystem.TryGetFileInfo(_fileDBLocation, out fi)) { File.WriteAllText(fi.PhysicalPath, json); return true; } return false; }
public static void Register(IAppBuilder app) { var physicalFileSystem = new PhysicalFileSystem(@"./"); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] { "index.html" }; app.UseFileServer(options); }
public void Configuration(IAppBuilder appBuilder) { // Configure Web API for self-host. HttpConfiguration config = new HttpConfiguration(); config.Routes.MapHttpRoute( name: "Api with action", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); config.Routes.MapHttpRoute( name: "Fallback", routeTemplate: "{name}/{*other}", defaults: new { controller = "Home", action = "Index" }, constraints: new { name = "^(?!(api|controller|css|fonts|img|js)$).*$" } ); appBuilder.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll); appBuilder.UseWebApi(config); var physicalFileSystem = new PhysicalFileSystem(@"./www"); var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = physicalFileSystem }; options.StaticFileOptions.FileSystem = physicalFileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = new[] { "index.html" }; config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize; config.Formatters.JsonFormatter.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects; appBuilder.UseFileServer(options); }
public void Configure(IAppBuilder app) { IFileSystem fs; if (Debugger.IsAttached) fs = new PhysicalFileSystem("../../../Magistrate/client"); else fs = new AssemblyResourceFileSystem(Assembly.GetExecutingAssembly(), "Magistrate.client"); var fileOptions = new FileServerOptions { FileSystem = fs, EnableDefaultFiles = true, DefaultFilesOptions = { DefaultFileNames = { "app.htm" } } }; app.UseFileServer(fileOptions); }
public bool SaveChanges() { // write trips to json file, overwriting the old one var json = JsonConvert.SerializeObject(Trips); var fileSystem = new Microsoft.Owin.FileSystems.PhysicalFileSystem(""); IFileInfo fi; if (fileSystem.TryGetFileInfo(_fileDBLocation, out fi)) { File.WriteAllText(fi.PhysicalPath, json); return(true); } return(false); }
public static IAppBuilder UseHtml5Routing(this IAppBuilder builder, string rootPath, string entryPath) { var fileSystem = new PhysicalFileSystem(rootPath); var fileServerOptions = new FileServerOptions() { EnableDirectoryBrowsing = false, FileSystem = fileSystem }; var options = new HTML5ServerOptions() { FileServerOptions = fileServerOptions, EntryPath = new PathString(entryPath) }; builder.UseDefaultFiles(options.FileServerOptions.DefaultFilesOptions); return builder.Use(new Func<AppFunc, AppFunc>(next => new Html5Middleware(next, options).Invoke)); }
public void Configuration(IAppBuilder app) { app.MapSignalR(); var staticFilesPath = GetStaticFilesPath(); var fileSystem = new PhysicalFileSystem(staticFilesPath); var fileServerOptions = new FileServerOptions { EnableDefaultFiles = true, FileSystem = fileSystem }; fileServerOptions.StaticFileOptions.FileSystem = fileSystem; fileServerOptions.StaticFileOptions.ServeUnknownFileTypes = true; fileServerOptions.DefaultFilesOptions.DefaultFileNames = new[] { "index.html", "index.htm" }; app.UseFileServer(fileServerOptions); }
/// <summary> /// Configure OWIN static file hosting /// </summary> /// <param name="app">IAppBuilder</param> /// <param name="root">Root path to host</param> /// <param name="defaultFileNames">Default file names to host</param> public static void UseStaticFileHosting(this IAppBuilder app, string root, string[] defaultFileNames) { //The file system for the server to host var fileSystem = new PhysicalFileSystem(root); //File server configuration options var options = new FileServerOptions { EnableDefaultFiles = true, FileSystem = fileSystem }; options.StaticFileOptions.FileSystem = fileSystem; options.StaticFileOptions.ServeUnknownFileTypes = true; options.DefaultFilesOptions.DefaultFileNames = defaultFileNames; app.UseFileServer(options); }
public void Configuration(IAppBuilder app) { var fileSystem = new PhysicalFileSystem(this.serverConfig.RootFolder); if (this.serverConfig.AllowDirectoryBrowsing) { app.UseDirectoryBrowser(new DirectoryBrowserOptions() { FileSystem = fileSystem }); } app.UseStaticFiles(new StaticFileOptions() { FileSystem = fileSystem, ServeUnknownFileTypes = true }); }
public void Configuration(IAppBuilder app) { HttpConfiguration configuration = new HttpConfiguration(); // SignalR app.MapSignalR(); //// Make sure we're shipping our own provider //var dependencyResolver = Microsoft.AspNet.SignalR.GlobalHost.DependencyResolver; //dependencyResolver.Register(typeof(Microsoft.AspNet.SignalR.Hubs.IHubDescriptorProvider), () => new EcoHubDescriptorProvider(dependencyResolver)); // Web API app.UseWebApi(configuration); // Static files var staticFilesDirectory = _webRoot.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); if (!Directory.Exists(staticFilesDirectory)) throw new InvalidOperationException($"Could not find webroot directory at {staticFilesDirectory}. Please check your installation."); var fileSystem = new PhysicalFileSystem(staticFilesDirectory); var requestPath = PathString.Empty; app.UseDefaultFiles(new DefaultFilesOptions { DefaultFileNames = new List<string> { "index.html" }, FileSystem = fileSystem, RequestPath = requestPath }); app.UseStaticFiles(new StaticFileOptions { FileSystem = fileSystem, RequestPath = requestPath, ServeUnknownFileTypes = false }); app.Run(async (context) => { var response = context.Response; response.StatusCode = 404; response.ReasonPhrase = "Not Found"; await response.WriteAsync(@"<!DOCTYPE html><html><head><title>404 - Not Found</title></head><body><h1>404 - Not Found</h1></body></html>"); }); }
private void ConfigureUserSpace(IAppBuilder appBuilder) { var appConfig = ObjectFactory.GetProvider<IAppConfigProvider>().AppConfig; var fileSystem = new PhysicalFileSystem(appConfig.WebRoot); appBuilder.Use(typeof(RedirectUrl)); appBuilder.UseDirectoryBrowser(new DirectoryBrowserOptions { RequestPath = new PathString(""), FileSystem = fileSystem }); appBuilder.UseStaticFiles(new StaticFileOptions { RequestPath = new PathString(""), FileSystem = fileSystem, ServeUnknownFileTypes = true }); }