Example #1
0
        public GameHostOptions(IConfiguration configuration, string applicationNameFallback)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }

            ApplicationName        = configuration[GameHostDefaults.ApplicationKey] ?? applicationNameFallback;
            StartupAssembly        = configuration[GameHostDefaults.StartupAssemblyKey];
            DetailedErrors         = GameHostUtilities.ParseBool(configuration, GameHostDefaults.DetailedErrorsKey);
            CaptureStartupErrors   = GameHostUtilities.ParseBool(configuration, GameHostDefaults.CaptureStartupErrorsKey);
            Environment            = configuration[GameHostDefaults.EnvironmentKey];
            GameRoot               = configuration[GameHostDefaults.GameRootKey];
            ContentRootPath        = configuration[GameHostDefaults.ContentRootKey];
            PreventHostingStartup  = GameHostUtilities.ParseBool(configuration, GameHostDefaults.PreventHostingStartupKey);
            SuppressStatusMessages = GameHostUtilities.ParseBool(configuration, GameHostDefaults.SuppressStatusMessagesKey);

            // Search the primary assembly and configured assemblies.
            HostingStartupAssemblies        = Split($"{ApplicationName};{configuration[GameHostDefaults.HostingStartupAssembliesKey]}");
            HostingStartupExcludeAssemblies = Split(configuration[GameHostDefaults.HostingStartupExcludeAssembliesKey]);

            var timeout = configuration[GameHostDefaults.ShutdownTimeoutKey];

            if (!string.IsNullOrEmpty(timeout) &&
                int.TryParse(timeout, NumberStyles.None, CultureInfo.InvariantCulture, out var seconds))
            {
                ShutdownTimeout = TimeSpan.FromSeconds(seconds);
            }
        }
Example #2
0
        void EnsureServer()
        {
            if (Server == null && Services.GetService <IServer>() != null)
            {
                Server = Services.GetRequiredService <IServer>();

                var serverAddressesFeature = Server.Features?.Get <IServerAddressesFeature>();
                var addresses = serverAddressesFeature?.Addresses;
                if (addresses != null && !addresses.IsReadOnly && addresses.Count == 0)
                {
                    var urls = _config[GameHostDefaults.ServerUrlsKey] ?? _config[DeprecatedServerUrlsKey];
                    if (!string.IsNullOrEmpty(urls))
                    {
                        serverAddressesFeature.PreferHostingUrls = GameHostUtilities.ParseBool(_config, GameHostDefaults.PreferHostingUrlsKey);

                        foreach (var value in urls.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
                        {
                            addresses.Add(value);
                        }
                    }
                }
            }
        }
Example #3
0
        void EnsureClient()
        {
            if (Client == null && Services.GetService <IClient>() != null)
            {
                Client = Services.GetRequiredService <IClient>();

                var clientAddressesFeature = Client.Features?.Get <IClientAddressesFeature>();
                var addresses = clientAddressesFeature?.Addresses;
                if (addresses != null && !addresses.IsReadOnly && addresses.Count == 0)
                {
                    var urls = _config[GameHostDefaults.ClientUrlsKey];
                    if (!string.IsNullOrEmpty(urls))
                    {
                        clientAddressesFeature.PreferHostingUrls = GameHostUtilities.ParseBool(_config, GameHostDefaults.PreferHostingUrlsKey);

                        foreach (var value in urls.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
                        {
                            addresses.Add(value);
                        }
                    }
                }
            }
        }
        public async Task StartAsync(CancellationToken cancellationToken)
        {
            HostingEventSource.Log.HostStart();

            var serverAddressesFeature = Server.Features?.Get <IServerAddressesFeature>();
            var addresses = serverAddressesFeature?.Addresses;

            if (addresses != null && !addresses.IsReadOnly && addresses.Count == 0)
            {
                var urls = Configuration[GameHostDefaults.ServerUrlsKey];
                if (!string.IsNullOrEmpty(urls))
                {
                    serverAddressesFeature.PreferHostingUrls = GameHostUtilities.ParseBool(Configuration, GameHostDefaults.PreferHostingUrlsKey);

                    foreach (var value in urls.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
                    {
                        addresses.Add(value);
                    }
                }
            }

            RequestDelegate application = null;

            try
            {
                Action <IApplicationBuilder> configure = Options.ConfigureApplication;

                if (configure == null)
                {
                    throw new InvalidOperationException($"No application configured. Please specify an application via IGameHostBuilder.UseStartup, IGameHostBuilder.Configure, or specifying the startup assembly via {nameof(GameHostDefaults.StartupAssemblyKey)} in the game host configuration.");
                }

                var builder = ApplicationBuilderFactory.CreateBuilder(Server.Features);

                foreach (var filter in StartupFilters.Reverse())
                {
                    configure = filter.Configure(configure);
                }

                configure(builder);

                // Build the request pipeline
                application = builder.Build();
            }
            catch (Exception ex)
            {
                Logger.ApplicationError(ex);

                if (!Options.GameHostOptions.CaptureStartupErrors)
                {
                    throw;
                }

                application = BuildErrorPageApplication(ex);
            }

            var httpApplication = new HostingApplication(application, Logger, DiagnosticListener, ProtoContextFactory);

            await Server.StartAsync(httpApplication, cancellationToken);

            if (addresses != null)
            {
                foreach (var address in addresses)
                {
                    LifetimeLogger.LogInformation("Now listening on: {address}", address);
                }
            }

            if (Logger.IsEnabled(LogLevel.Debug))
            {
                foreach (var assembly in Options.GameHostOptions.GetFinalHostingStartupAssemblies())
                {
                    Logger.LogDebug("Loaded hosting startup assembly {assemblyName}", assembly);
                }
            }

            if (Options.HostingStartupExceptions != null)
            {
                foreach (var exception in Options.HostingStartupExceptions.InnerExceptions)
                {
                    Logger.HostingStartupAssemblyError(exception);
                }
            }
        }