protected ISuperSocketHostBuilder Configure(ISuperSocketHostBuilder hostBuilder, IHostConfigurator configurator = null) { var builder = hostBuilder.ConfigureAppConfiguration((hostCtx, configApp) => { configApp.AddInMemoryCollection(new Dictionary <string, string> { { "serverOptions:name", "TestServer" }, { "serverOptions:listeners:0:ip", "Any" }, { "serverOptions:listeners:0:backLog", "100" }, { "serverOptions:listeners:0:port", DefaultServerPort.ToString() } }); }) .ConfigureLogging((hostCtx, loggingBuilder) => { loggingBuilder.AddConsole(); loggingBuilder.SetMinimumLevel(LogLevel.Debug); loggingBuilder.AddDebug(); }) .ConfigureServices((hostCtx, services) => { ConfigureServices(hostCtx, services); }) as ISuperSocketHostBuilder; configurator?.Configure(builder); return(builder); }
private static ISuperSocketHostBuilder ConfigureCommand(this ISuperSocketHostBuilder builder) { return(builder.ConfigureServices((hostCxt, services) => { services.Configure <CommandOptions>(hostCxt.Configuration?.GetSection("serverOptions")?.GetSection("commands")); }) as ISuperSocketHostBuilder); }
public static ISuperSocketHostBuilder UseUdp(this ISuperSocketHostBuilder hostBuilder) { return(hostBuilder.ConfigureServices((context, services) => { services.AddSingleton <IChannelCreatorFactory, UdpChannelCreatorFactory>(); }) as ISuperSocketHostBuilder); }
public static ISuperSocketHostBuilder UseUdp <TUdpSessionIdentifierProvider>(this ISuperSocketHostBuilder hostBuilder) where TUdpSessionIdentifierProvider : class, IUdpSessionIdentifierProvider { return(hostBuilder.UseUdp().ConfigureServices((context, services) => { services.AddSingleton <IUdpSessionIdentifierProvider, TUdpSessionIdentifierProvider>(); }) as ISuperSocketHostBuilder); }
/// <summary> /// 使用中间件 /// </summary> /// <typeparam name="TMiddleware">中间件类型</typeparam> /// <param name="builder">Host Builder</param> /// <param name="implementationFactory">实施工厂</param> /// <returns></returns> public static ISuperSocketHostBuilder UseMiddleware <TMiddleware>(this ISuperSocketHostBuilder builder, Func <IServiceProvider, TMiddleware> implementationFactory) where TMiddleware : class, IMiddleware { return(builder.ConfigureServices((ctx, services) => { services.TryAddEnumerable(ServiceDescriptor.Singleton <IMiddleware, TMiddleware>(implementationFactory)); }).AsSuperSocketBuilder()); }
public static IHostBuilder UseSerialIO(this ISuperSocketHostBuilder hostBuilder) { return(hostBuilder.ConfigureServices( (hostCtx, services) => { services.AddSingleton <IChannelCreatorFactory, SerialIOChannelCreatorFactory>(); } )); }
public static ISuperSocketHostBuilder ConfigureSocketOptionsSetter(this ISuperSocketHostBuilder hostBuilder, Func <Socket> socketOptionsSetter) { return(hostBuilder.ConfigureServices( (hostCtx, services) => { services.AddSingleton <Func <Socket> >(socketOptionsSetter); } ) as ISuperSocketHostBuilder); }
public static ISuperSocketHostBuilder ConfigureSuperSocket(this ISuperSocketHostBuilder hostBuilder, Action <ServerOptions> configurator) { return(hostBuilder.ConfigureServices( (hostCtx, services) => { services.Configure <ServerOptions>(configurator); } ) as ISuperSocketHostBuilder); }
public static ISuperSocketHostBuilder UseInProcSessionContainer(this ISuperSocketHostBuilder builder) { return(builder.ConfigureServices((ctx, services) => { services.AddSingleton <InProcSessionContainerMiddleware>(); services.AddSingleton <ISessionContainer>((s) => s.GetRequiredService <InProcSessionContainerMiddleware>()); services.AddSingleton <IAsyncSessionContainer>((s) => s.GetRequiredService <ISessionContainer>().ToAsyncSessionContainer()); services.TryAddEnumerable(ServiceDescriptor.Singleton <IMiddleware, InProcSessionContainerMiddleware>(s => s.GetRequiredService <InProcSessionContainerMiddleware>())); }) as ISuperSocketHostBuilder); }
public virtual void Configure(ISuperSocketHostBuilder hostBuilder) { hostBuilder.ConfigureServices((ctx, services) => { services.Configure <ServerOptions>((options) => { var listener = options.Listeners[0]; Listener = listener; }); }); }
protected ISuperSocketHostBuilder <WebSocketPackage> CreateWebSocketServerBuilder(Func <ISuperSocketHostBuilder <WebSocketPackage>, ISuperSocketHostBuilder <WebSocketPackage> > configurator = null, IHostConfigurator hostConfigurator = null) { ISuperSocketHostBuilder <WebSocketPackage> builder = WebSocketHostBuilder.Create(); if (configurator != null) { builder = configurator(builder); } return(Configure(builder, hostConfigurator) as ISuperSocketHostBuilder <WebSocketPackage>); }
public static ISuperSocketHostBuilder UseSessionFactory <TSessionFactory>(this ISuperSocketHostBuilder hostBuilder) where TSessionFactory : class, ISessionFactory { hostBuilder.ConfigureServices( (hostCtx, services) => { services.AddSingleton <ISessionFactory, TSessionFactory>(); } ); return(hostBuilder); }
public async Task TestUsePackageHandlingContextAccessor() { ISuperSocketHostBuilder <StringPackageInfo> superSocketHostBuilder = CreateSocketServerBuilder <StringPackageInfo, CommandLinePipelineFilter>() .UseCommand(commandOptions => { commandOptions.AddCommand <TestCommand>(); }) .UsePackageHandlingContextAccessor(); using (var server = superSocketHostBuilder.BuildAsServer()) { var packageHandlingContextAccessor = server.ServiceProvider.GetService <IPackageHandlingContextAccessor <StringPackageInfo> >(); Assert.NotNull(packageHandlingContextAccessor); Assert.Equal("TestServer", server.Name); Assert.True(await server.StartAsync()); OutputHelper.WriteLine("Server started."); var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); await client.ConnectAsync(GetDefaultServerEndPoint()); OutputHelper.WriteLine("Connected."); await Task.Delay(1000); using (var stream = new NetworkStream(client)) using (var streamReader = new StreamReader(stream, Utf8Encoding, true)) using (var streamWriter = new StreamWriter(stream, Utf8Encoding, 1024 * 1024 * 4)) { await streamWriter.WriteAsync("TestCommand Package 1\r\n"); await streamWriter.FlushAsync(); OutputHelper.WriteLine("send 'Package 1'."); var line = await streamReader.ReadLineAsync(); Assert.Equal("Package 1", line); await streamWriter.WriteAsync("TestCommand Package 2\r\n"); await streamWriter.FlushAsync(); OutputHelper.WriteLine("send 'Package 2'."); line = await streamReader.ReadLineAsync(); Assert.Equal("Package 2", line); } await server.StopAsync(); } }
public override void Configure(ISuperSocketHostBuilder hostBuilder) { hostBuilder.ConfigureServices((ctx, services) => { services.Configure <ServerOptions>((options) => { var listener = options.Listeners[0]; }); }); hostBuilder.UseGZip(); base.Configure(hostBuilder); }
public static ISuperSocketHostBuilder UseSessionHandler(this ISuperSocketHostBuilder hostBuilder, Func <IAppSession, ValueTask> onConnected = null, Func <IAppSession, ValueTask> onClosed = null) { return(hostBuilder.ConfigureServices( (hostCtx, services) => { services.AddSingleton <SessionHandlers>(new SessionHandlers { Connected = onConnected, Closed = onClosed }); } ) as ISuperSocketHostBuilder); }
public static ISuperSocketHostBuilder UseUdp(this ISuperSocketHostBuilder hostBuilder) { return((hostBuilder.ConfigureServices((context, services) => { services.AddSingleton <IChannelCreatorFactory, UdpChannelCreatorFactory>(); services.AddSingleton <IUdpSessionIdentifierProvider, IPAddressUdpSessionIdentifierProvider>(); }) as ISuperSocketHostBuilder).ConfigureSupplementServices((context, services) => { if (services.Any(s => s.ServiceType == typeof(IAsyncSessionContainer))) { return; } services.TryAddEnumerable(ServiceDescriptor.Singleton <IMiddleware, InProcSessionContainerMiddleware>(s => s.GetRequiredService <InProcSessionContainerMiddleware>())); services.AddSingleton <InProcSessionContainerMiddleware>(); services.AddSingleton <ISessionContainer>((s) => s.GetRequiredService <InProcSessionContainerMiddleware>()); services.AddSingleton <IAsyncSessionContainer>((s) => s.GetRequiredService <ISessionContainer>().ToAsyncSessionContainer()); })); }
/// <summary> /// 使用包处理 /// </summary> /// <typeparam name="TReceivePackage">接收包的类型</typeparam> /// <param name="hostBuilder">Host Builder</param> /// <param name="packageHandler">包处理</param> /// <param name="errorHandler">错误处理</param> /// <returns></returns> // move to extensions public static ISuperSocketHostBuilder <TReceivePackage> UsePackageHandler <TReceivePackage>( this ISuperSocketHostBuilder <TReceivePackage> hostBuilder, Func <IAppSession, TReceivePackage, ValueTask> packageHandler, Func <IAppSession, PackageHandlingException <TReceivePackage>, ValueTask <bool> > errorHandler = null) { return(hostBuilder.ConfigureServices( (hostCtx, services) => { if (packageHandler != null) { services.AddSingleton <IPackageHandler <TReceivePackage> >(new DelegatePackageHandler <TReceivePackage>(packageHandler)); } if (errorHandler != null) { services.AddSingleton <Func <IAppSession, PackageHandlingException <TReceivePackage>, ValueTask <bool> > >(errorHandler); } } )); }
public override void Configure(ISuperSocketHostBuilder hostBuilder) { hostBuilder.ConfigureServices((ctx, services) => { services.Configure <ServerOptions>((options) => { var listener = options.Listeners[0]; if (listener.Security == SslProtocols.None) { listener.Security = GetServerEnabledSslProtocols(); } listener.CertificateOptions = new CertificateOptions { FilePath = "supersocket.pfx", Password = "******" }; }); }); base.Configure(hostBuilder); }
public static ISuperSocketHostBuilder <WebSocketPackage> UseWebSocketMessageHandler(this ISuperSocketHostBuilder <WebSocketPackage> builder, Func <WebSocketSession, WebSocketPackage, Task> handler) { return(builder.ConfigureServices((ctx, services) => { services.AddSingleton <Func <WebSocketSession, WebSocketPackage, Task> >(handler); }) as ISuperSocketHostBuilder <WebSocketPackage>); }
public static ISuperSocketHostBuilder UseChannelCreatorFactory <TChannelCreatorFactory>(this ISuperSocketHostBuilder builder) where TChannelCreatorFactory : class, IChannelCreatorFactory { return(builder.ConfigureServices((ctx, services) => { services.AddSingleton <IChannelCreatorFactory, TChannelCreatorFactory>(); }).AsSuperSocketBuilder()); }
public static ISuperSocketHostBuilder <TReceivePackage> UseUdp <TReceivePackage>(this ISuperSocketHostBuilder <TReceivePackage> hostBuilder) { return(hostBuilder.UseUdp() as ISuperSocketHostBuilder <TReceivePackage>); }
public static ISuperSocketHostBuilder <TReceivePackage> ConfigureErrorHandler <TReceivePackage>(this ISuperSocketHostBuilder <TReceivePackage> hostBuilder, Func <IAppSession, PackageHandlingException <TReceivePackage>, ValueTask <bool> > errorHandler) { return(hostBuilder.ConfigureServices( (hostCtx, services) => { services.AddSingleton <Func <IAppSession, PackageHandlingException <TReceivePackage>, ValueTask <bool> > >(errorHandler); } )); }
public static ISuperSocketHostBuilder <TReceivePackage> ConfigureSocketOptions <TReceivePackage>(this ISuperSocketHostBuilder <TReceivePackage> hostBuilder, Action <Socket> socketOptionsSetter) where TReceivePackage : class { return(hostBuilder.ConfigureServices( (hostCtx, services) => { services.AddSingleton <SocketOptionsSetter>(new SocketOptionsSetter(socketOptionsSetter)); } )); }
public static ISuperSocketHostBuilder <TReceivePackage> ConfigureSuperSocket <TReceivePackage>(this ISuperSocketHostBuilder <TReceivePackage> hostBuilder, Action <ServerOptions> configurator) { return(hostBuilder.ConfigureServices( (hostCtx, services) => { services.Configure <ServerOptions>(configurator); } )); }
public ISuperSocketHostBuilder GetServerHostBuilder() { if (Builder != null) { return(Builder); } var jttTypes = new Dictionary <Type, Type>(); var supersocketHostBuilder = SuperSocketHostBuilder.Create <TPackageInfo>(); IHostBuilder hostBuilder = null; if (Options.ServerOptions != null) { supersocketHostBuilder.UsePackageHandler( Options.ServerOptions.PackageHandler, Options.ServerOptions.ErrorHandler); supersocketHostBuilder.UseSessionHandler( Options.ServerOptions.OnConnected, Options.ServerOptions.OnClosed); if (Options.ServerOptions.InProcSessionContainer) { supersocketHostBuilder.UseInProcSessionContainer(); } hostBuilder = supersocketHostBuilder.ConfigureServices((context, services) => { Options.ServerOptions.ConfigureServices?.Invoke(context, services); }) .ConfigureAppConfiguration((hostCtx, configApp) => { configApp.AddInMemoryCollection(new Dictionary <string, string> { { "serverOptions:name", Options.ServerOptions?.Name ?? $"SuperSocket {(Options.ServerOptions.UseUdp?"UDP":"TCP")} Server" }, { "serverOptions:listeners:0:ip", Options.ServerOptions?.IP }, { "serverOptions:listeners:0:port", Options.ServerOptions?.Port.ToString() }, { "serverOptions:listeners:0:backLog", Options.ServerOptions?.BackLog.ToString() } }); Options.ServerOptions.ConfigureAppConfiguration?.Invoke(hostCtx, configApp); }); } if (Options.LoggingOptions != null) { hostBuilder = (hostBuilder ?? supersocketHostBuilder).ConfigureLogging((hostCtx, loggingBuilder) => { if (Options.LoggingOptions?.Provider != null) { loggingBuilder.AddProvider(Options.LoggingOptions.Provider); } if (Options.LoggingOptions?.AddConsole == true) { loggingBuilder.AddConsole(); } if (Options.LoggingOptions?.AddDebug != null) { loggingBuilder.AddDebug(); } }); } Builder = (hostBuilder ?? supersocketHostBuilder) as ISuperSocketHostBuilder; if (Options.ServerOptions.UseUdp) { Builder.UseUdp(); } return(Builder); }
public static ISuperSocketHostBuilder <WebSocketPackage> UseCommand <TPackageInfo, TPackageMapper>(this ISuperSocketHostBuilder <WebSocketPackage> builder) where TPackageInfo : class where TPackageMapper : class, IPackageMapper <WebSocketPackage, TPackageInfo> { var keyType = CommandMiddlewareExtensions.GetKeyType <TPackageInfo>(); var commandMiddlewareType = typeof(WebSocketCommandMiddleware <,>).MakeGenericType(keyType, typeof(TPackageInfo)); return(builder.ConfigureServices((ctx, services) => { services.AddSingleton(typeof(IWebSocketCommandMiddleware), commandMiddlewareType); services.AddSingleton <IPackageMapper <WebSocketPackage, TPackageInfo>, TPackageMapper>(); }).ConfigureServices((ctx, services) => { services.Configure <CommandOptions>(ctx.Configuration?.GetSection("serverOptions")?.GetSection("commands")); }) as ISuperSocketHostBuilder <WebSocketPackage>); }
public static ISuperSocketHostBuilder <WebSocketPackage> UseCommand <TPackageInfo, TPackageMapper>(this ISuperSocketHostBuilder <WebSocketPackage> builder, Action <CommandOptions> configurator) where TPackageInfo : class where TPackageMapper : class, IPackageMapper <WebSocketPackage, TPackageInfo>, new() { return(builder.UseCommand <TPackageInfo, TPackageMapper>() .ConfigureServices((ctx, services) => { services.Configure(configurator); }) as ISuperSocketHostBuilder <WebSocketPackage>); }
public static ISuperSocketHostBuilder <TReceivePackage> UsePipelineFilterFactory <TReceivePackage>(this ISuperSocketHostBuilder <TReceivePackage> hostBuilder, Func <object, IPipelineFilter <TReceivePackage> > filterFactory) { hostBuilder.ConfigureServices( (hostCtx, services) => { services.AddSingleton <Func <object, IPipelineFilter <TReceivePackage> > >(filterFactory); } ); return(hostBuilder.UsePipelineFilterFactory <DelegatePipelineFilterFactory <TReceivePackage> >()); }
// move to extensions public static ISuperSocketHostBuilder UseGZip(this ISuperSocketHostBuilder hostBuilder) { return(hostBuilder.UseChannelCreatorFactory <GZipTcpChannelCreatorFactory>()); }
public static ISuperSocketHostBuilder <TReceivePackage> UseClearIdleSession <TReceivePackage>(this ISuperSocketHostBuilder <TReceivePackage> hostBuilder) { return(hostBuilder.UseMiddleware <ClearIdleSessionMiddleware>()); }