3. Hosting

Purpose

A web hosting service (often shortened to web host) is a type of Internet hosting service that allows individuals and organizations to make their website accessible via the World Wide Web. Web hosts are companies that provide space on a server owned or leased for use by clients, as well as providing Internet connectivity, typically in a data center.

Web applications built with Signals don’t have specific hosting requirements, it can be hosted as any other web application and be hosted as the underlying framework demands.

.NET Core startup configuration example

/// <summary>
/// Signals bootstrapping class
/// </summary>
public static class SignalsStartup
{
    /// <summary>
    /// Add signals aspects
    /// </summary>
    /// <param name="services"></param>
    /// <returns></returns>
    public static IServiceProvider AddSignals(this IServiceCollection services)
    {
        // integrate autofac into mvc.core
        var registrationService = new RegistrationService();

        var assemblies = Directory
            .GetFiles(AppContext.BaseDirectory, "*.dll")
            .Select(Assembly.LoadFrom)
            .ToList();

        services.AddConfiguration();

        services.AddAuthentication("Cookies")
                .AddSignalsAuth(opts =>
                {
                    opts.SlidingExpiration = true;
                    opts.ExpireTimeSpan = TimeSpan.FromDays(365);
                    opts.Cookie.Expiration = TimeSpan.FromDays(365);
                    opts.Cookie.MaxAge = TimeSpan.FromDays(365);
                    opts.Cookie.IsEssential = true;
                });

        registrationService.Builder.Populate(services);
        services
            .AddSignals(config =>
            {
                config.ConfigureJsonSerialization();
                config.ScanAssemblies = assemblies;
                config.RegistrationService = registrationService;
                config.CacheConfiguration = new InMemoryCacheConfiguration();
                config.LoggerConfiguration = new DatabaseLoggingConfiguration();
                config.LocalizationConfiguration = new JsonDataProviderConfiguration();
                config.SecurityConfiguration = new DatabaseSecurityConfiguration();
                config.ChannelConfiguration = new ServiceBusChannelConfiguration();
                config.AuditingConfiguration = new DatabaseAuditingConfiguration();
                config.StrategyBuilder = new StrategyBuilder();
                config.BenchmarkingConfiguration = new DatabaseBenchmarkingConfiguration();
            });

        // wrap autofac container
        return new AutofacServiceProvider(registrationService.ServiceContainer.Container);
    }

    /// <summary>
    /// Load configuration from files
    /// </summary>
    /// <param name="services"></param>
    /// <returns></returns>
    private static void AddConfiguration(this IServiceCollection services)
    {
        FileConfigurationProvider ProviderForFile(string name) => new FileConfigurationProvider
        {
            File = name,
            Path = @"example/path/to",
            ReloadOnAccess = false
        };

        WebApplicationConfiguration.UseProvider(ProviderForFile("web.application.config.json"));
        ApplicationConfiguration.UseProvider(ProviderForFile("application.config.json"));
    }

    /// <summary>
    /// Configure JSON serialization
    /// </summary>
    /// <param name="services"></param>
    /// <returns></returns>
    private static void ConfigureJsonSerialization(this ApplicationBootstrapConfiguration config)
    {
        config.JsonSerializerSettings = new Newtonsoft.Json.JsonSerializerSettings();
    }
}

/// <summary>
/// Statrtup configuration
/// </summary>
public class Startup
{
    /// <summary>
    /// CTOR
    /// </summary>
    /// <param name="configuration"></param>
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    /// <summary>
    /// Application configuration
    /// </summary>
    public IConfiguration Configuration { get; }

    /// <summary>
    /// This method gets called by the runtime.
    /// Use this method to add services to the container.
    /// </summary>
    /// <param name="services"></param>
    /// <returns></returns>
    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        services
            .AddMvc()
            .SetCompatibilityVersion(CompatibilityVersion.Version_2_1);

        return services.AddSignals();
    }

    /// <summary>
    /// This method gets called by the runtime.
    /// Use this method to configure the HTTP request pipeline.
    /// </summary>
    /// <param name="app"></param>
    /// <param name="env"></param>
    public void Configure(IApplicationBuilder app, IHostingEnvironment env)
    {
        if (!DeploymentConfiguration.IsProduction)
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();

        app.UseStaticFiles();
        app.UseCookiePolicy();

        app.UseSignalsAuth();
        app.UseSignals();

        app.UseMvcWithDefaultRoute();
    }
}

See the official Microsoft documentation for hosting .NET Core

Hosting under IIS

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;

namespace App.Client.Web
{
    /// <summary>
    /// Web application entry
    /// </summary>
    public class Program
    {
        /// <summary>
        /// Main entry point
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        /// <summary>
        /// Starts applicaiton as web hosted application
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseIIS()
                .UseStartup<Startup>();
    }
}

Self-hosted

using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;

namespace App.Client.Web
{
    /// <summary>
    /// Web application entry
    /// </summary>
    public class Program
    {
        /// <summary>
        /// Main entry point
        /// </summary>
        /// <param name="args"></param>
        public static void Main(string[] args)
        {
            CreateWebHostBuilder(args).Build().Run();
        }

        /// <summary>
        /// Starts applicaiton as web hosted application
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>();
    }
}