public static RoutingHandler LoadFromHtaccess(string defaultPage, string htaccessPath, Uri baseUri)
    {
        RoutingHandler handler = new RoutingHandler(defaultPage, baseUri);

        if (string.IsNullOrEmpty(htaccessPath)) return handler;
        FileInfo file = new FileInfo(htaccessPath);
        if (file.Exists)
        {
            HtaccessParser.Htaccess htaccess = new HtaccessParser.Htaccess(file.Open(FileMode.Open, FileAccess.Read));

            HtaccessParser.HtaccessNode rewriteEngineNode = htaccess.Find((HtaccessParser.HtaccessNode node) => { return node.Name == "RewriteEngine"; });
            if (rewriteEngineNode != null)
            {
                HtaccessParser.Directive rewriteEngineDirective = (HtaccessParser.Directive)rewriteEngineNode;
                if (rewriteEngineDirective.HasArgumentValue("on"))
                {
                    List<HtaccessParser.HtaccessNode> listRewriteRule = htaccess.FindAll((HtaccessParser.HtaccessNode node) => { return node.Name == "RewriteRule"; });
                    if (listRewriteRule != null && listRewriteRule.Count > 0)
                    {
                        foreach (HtaccessParser.Directive directive in listRewriteRule)
                        {
                            if (directive != null)
                            {
                                string[] args = directive.Arguments;
                                if (args != null && args.Length > 1)
                                {
                                    handler.SetUrlMatcher(args[0].Trim(), args[1].Trim());
                                }
                            }
                        }
                    }
                }
            }

            List<HtaccessParser.HtaccessNode> listErrorDocument = htaccess.FindAll((HtaccessParser.HtaccessNode node) => { return node.Name == "ErrorDocument"; });
            if (listErrorDocument != null)
            {
                foreach (HtaccessParser.Directive directive in listErrorDocument)
                {
                    if (directive != null)
                    {
                        string[] args = directive.Arguments;
                        if (args != null && args.Length > 1)
                        {
                            handler.SetErrorDocument(args[0].Trim(), args[1].Trim());
                        }
                    }
                }
            }
        }

        return handler;
    }
Example #2
0
        static void Main(string[] args)
        {
            var port   = GetPort(args);
            var server = new Server("127.0.0.1", port);

            var router = new RoutingHandler();

            router.CreateRoute(@"/api/ToDo", new RestHandler <ToDoService>());
            router.CreateRoute(@"/PostbackHandler", new PostbackHandler());
            router.CreateRoute(@"/Echo", new EchoRequestHandler());
            router.CreateRoute(@"/|(\..+)$", new StaticFileHandler(@"C:\Dev\CustomWebServer\angularjs_todo", "index.html"));
            router.SetDefaultHandler(new FileNotFoundHandler());

            server.StartAsync(router).Wait();
        }
Example #3
0
        static void Main(string[] args)
        {
            var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());

            XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
            var log           = log4net.LogManager.GetLogger(typeof(Program));
            var settings      = GetSettings();
            var mongoDbClient = new MongoDbClient(settings.MongoConnectionString, TimeSpan.FromSeconds(2));

            ThreadPool.SetMaxThreads(32767, 32767);
            ThreadPool.SetMinThreads(2048, 2048);

            var(authorizer, sourceStorage) = new StateRestorer(mongoDbClient).Restore().GetAwaiter().GetResult();

            var addUserInfoHandler = new AddSourceInfoHandler(mongoDbClient, authorizer, sourceStorage, log);
            var sseClient          = new SseClient();
            var subscriber         = new Subscriber(authorizer, sourceStorage, sseClient);
            var messagSender       = new MessageSender();
            var sendMessageHandler = new SendMessageHandler(messagSender, mongoDbClient, sourceStorage, authorizer, settings.dataTtl);
            var handlerMapper      = new HandlerMapper();

            var expDaemon = new ExpirationDaemon(sourceStorage, settings.dataTtl);

            handlerMapper.Add("/addUserInfo", HttpMethod.Post, addUserInfoHandler);
            handlerMapper.Add("/subscribe", HttpMethod.Get, new SubscribeOnSourceHandler(subscriber));
            handlerMapper.Add("/sendMessage", HttpMethod.Post, sendMessageHandler);


            var routingHandler = new RoutingHandler(handlerMapper, log);

            var host = WebHost.CreateDefaultBuilder(args)
                       .ConfigureServices(s =>
            {
                s.AddSingleton(routingHandler);
                s.AddHttpContextAccessor();
            })
                       .UseContentRoot(Directory.GetCurrentDirectory())
                       .UseKestrel()
                       .UseStartup <Startup>()
                       .ConfigureKestrel((context, options) =>
            {
                //options.Listen(new IPAddress(new byte[] { 10, 33, 54, 120 }), 5000);
                options.Listen(new IPAddress(new byte[] { 0, 0, 0, 0 }), 5000);
            })
                       .Build();

            host.Run();
        }
Example #4
0
 public Router Route(string route, RoutingHandler callback)
 {
     return this;
 }
Example #5
0
 public Startup(RoutingHandler handler, IHttpContextAccessor a)
 {
     this.handler = handler;
     this.a       = a;
 }
Example #6
0
 /// <summary>
 /// Set the callback function from the caller for the routing calculation
 /// </summary>
 /// <param name="finishedOperation"></param>
 public void SetFinishedEvent(RoutingHandler finishedOperation)
 {
     routingComplete += finishedOperation;
 }