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>());
}
