static IHostBuilder CreateSocketServerBuilder(string[] args) =>
MultipleServerHostBuilder.Create()
.AddServer<OnlinePackageInfo, OnlinePackagePipelineFilter>(onlineServerBuilder =>
{
onlineServerBuilder
.ConfigureServerOptions((ctx, config) => config.GetSection("onlineServer"))
//.UseHostedService<OnlineService>()
.UseCommand<short, OnlinePackageInfo>()
//.UseSession<OnlineSession>()
.UseSessionFactory<OnlineSessionFactory>()
.UseInProcSessionContainer();
})
//.AddServer<RemotePackageInfo, RemotePackagePipelineFilter>(onlineServerBuilder =>
// {
// onlineServerBuilder
// .ConfigureServerOptions((ctx, config) => config.GetSection("remoteServer"))
// .UseCommand<string, RemotePackageInfo>()
// .UseInProcSessionContainer();
// })
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>()
.UseUrls("http://*:4050")
.UseStaticWebAssets();
})
//.UseWindowsService()
.UseAutofac()
.UseSerilog();
public async Task TestMultipleHostStartup(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
var hostBuilder = MultipleServerHostBuilder.Create()
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.Sources.Clear();
config.AddJsonFile("Config/multiple_server.json", optional: false, reloadOnChange: true);
})
.AddServer <TextPackageInfo, LinePipelineFilter>(builder =>
{
hostConfigurator.Configure(builder);
builder
.ConfigureServerOptions((ctx, config) =>
{
return(config.GetSection("TestServer1"));
})
.UsePackageHandler(async(IAppSession s, TextPackageInfo p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes("Hello World\r\n"));
});
});
using (var host = hostBuilder.Build())
{
await host.StartAsync();
await host.StopAsync();
}
}
public async Task TestMultipleServerHost()
{
var serverName1 = "TestServer1";
var serverName2 = "TestServer2";
var server1 = default(IServer);
var server2 = default(IServer);
IHostEnvironment actualHostEvn = null;
var hostBuilder = MultipleServerHostBuilder.Create()
.ConfigureAppConfiguration((hostingContext, config) =>
{
actualHostEvn = hostingContext.HostingEnvironment;
config.Sources.Clear();
config.AddJsonFile("Config/multiple_server.json", optional: false, reloadOnChange: true);
})
.ConfigureServices((hostingContext, services) =>
{
services.AddSingleton <MyTestService>();
})
.AddServer <SuperSocketServiceA, TextPackageInfo, LinePipelineFilter>(builder =>
{
builder
.ConfigureServerOptions((ctx, config) =>
{
return(config.GetSection(serverName1));
}).UseSessionHandler(async(s) =>
{
server1 = s.Server as IServer;
await s.SendAsync(Utf8Encoding.GetBytes($"{s.Server.Name}\r\n"));
});
})
.AddServer <SuperSocketServiceB, TextPackageInfo, LinePipelineFilter>(builder =>
{
builder
.ConfigureServerOptions((ctx, config) =>
{
return(config.GetSection(serverName2));
}).UseSessionHandler(async(s) =>
{
server2 = s.Server as IServer;
await s.SendAsync(Utf8Encoding.GetBytes($"{s.Server.Name}\r\n"));
});
})
.ConfigureLogging((hostCtx, loggingBuilder) =>
{
loggingBuilder.AddConsole();
loggingBuilder.AddDebug();
});
using (var host = hostBuilder.Build())
{
await host.StartAsync();
var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 4040));
using (var stream = new NetworkStream(client))
using (var streamReader = new StreamReader(stream, Utf8Encoding, true))
using (var streamWriter = new StreamWriter(stream, Utf8Encoding, 1024 * 1024 * 4))
{
var line = await streamReader.ReadLineAsync();
Assert.Equal(serverName1, line);
}
client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 4041));
using (var stream = new NetworkStream(client))
using (var streamReader = new StreamReader(stream, Utf8Encoding, true))
using (var streamWriter = new StreamWriter(stream, Utf8Encoding, 1024 * 1024 * 4))
{
var line = await streamReader.ReadLineAsync();
Assert.Equal(serverName2, line);
}
var hostEnv = server1.ServiceProvider.GetService <IHostEnvironment>();
Assert.NotNull(hostEnv);
Assert.Equal(actualHostEvn.ContentRootPath, hostEnv.ContentRootPath);
var hostAppLifetime = server1.ServiceProvider.GetService <IHostApplicationLifetime>();
Assert.NotNull(hostAppLifetime);
var hostLifetime = server1.ServiceProvider.GetService <IHostLifetime>();
Assert.NotNull(hostLifetime);
var hostFromServices = server1.ServiceProvider.GetService <IHost>();
Assert.NotNull(hostFromServices);
var loggerFactory0 = host.Services.GetService <ILoggerFactory>();
var loggerFactory1 = server1.ServiceProvider.GetService <ILoggerFactory>();
var loggerFactory2 = server2.ServiceProvider.GetService <ILoggerFactory>();
Assert.Equal(loggerFactory0, loggerFactory1);
Assert.Equal(loggerFactory1, loggerFactory2);
var testService0 = host.Services.GetService <MyTestService>();
testService0.Name = "SameInstance";
testService0.Version = 1;
var testService1 = server1.ServiceProvider.GetService <MyTestService>();
Assert.Equal(testService0.Name, testService1.Name);
Assert.Equal(1, testService1.Version);
testService1.Version = 2;
var testService2 = server2.ServiceProvider.GetService <MyTestService>();
Assert.Equal(testService0.Name, testService2.Name);
Assert.Equal(2, testService2.Version);
await host.StopAsync();
}
}
public static MultipleServerHostBuilder AddWebSocketServer <TWebSocketService>(this MultipleServerHostBuilder hostBuilder, Action <ISuperSocketHostBuilder <WebSocketPackage> > hostBuilderDelegate)
where TWebSocketService : WebSocketService
{
var appHostBuilder = new WebSocketHostBuilderAdapter(hostBuilder);
appHostBuilder
.UseHostedService <TWebSocketService>();
hostBuilderDelegate?.Invoke(appHostBuilder);
hostBuilder.AddServer(appHostBuilder);
return(hostBuilder);
}
public static MultipleServerHostBuilder AddWebSocketServer(this MultipleServerHostBuilder hostBuilder, Action <ISuperSocketHostBuilder <WebSocketPackage> > hostBuilderDelegate)
{
return(hostBuilder.AddWebSocketServer <WebSocketService>(hostBuilderDelegate));
}
public async Task TestMultipleServerHost()
{
var serverName1 = "TestServer1";
var serverName2 = "TestServer2";
var hostBuilder = MultipleServerHostBuilder.Create()
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.Sources.Clear();
config.AddJsonFile("Config/multiple_server.json", optional: false, reloadOnChange: true);
})
.AddServer <MySocketService, StringPackageInfo, CommandLinePipelineFilter>(builder =>
{
builder
.ConfigureServerOptions((ctx, config) =>
{
return(config.GetSection(serverName1));
}).UseSessionHandler(async(s) =>
{
await s.SendAsync(Utf8Encoding.GetBytes($"{s.Server.Name}\r\n"));
})
.UseCommand(commandOptions =>
{
// register all commands in one assembly
commandOptions.AddCommandAssembly(typeof(MIN).GetTypeInfo().Assembly);
});
})
.AddWebSocketServer <MyWebSocketService>(builder =>
{
builder
.ConfigureServerOptions((ctx, config) =>
{
return(config.GetSection(serverName2));
})
.UseCommand <StringPackageInfo, StringPackageConverter>(commandOptions =>
{
commandOptions.AddCommand <ADD>();
commandOptions.AddCommand <MULT>();
commandOptions.AddCommand <SUB>();
});
})
.ConfigureLogging((hostCtx, loggingBuilder) =>
{
loggingBuilder.AddConsole();
loggingBuilder.AddDebug();
});
using (var host = hostBuilder.Build())
{
await host.StartAsync();
var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, DefaultServerPort));
using (var stream = new NetworkStream(client))
using (var streamReader = new StreamReader(stream, Utf8Encoding, true))
using (var streamWriter = new StreamWriter(stream, Utf8Encoding, 1024 * 1024 * 4))
{
var line = await streamReader.ReadLineAsync();
Assert.Equal(serverName1, line);
await streamWriter.WriteAsync("MIN 8 6 3\r\n");
await streamWriter.FlushAsync();
line = await streamReader.ReadLineAsync();
Assert.Equal("3", line);
await streamWriter.WriteAsync("SORT 8 6 3\r\n");
await streamWriter.FlushAsync();
line = await streamReader.ReadLineAsync();
Assert.Equal("SORT 3 6 8", line);
}
var websocket = new ClientWebSocket();
await websocket.ConnectAsync(new Uri($"ws://localhost:{AlternativeServerPort}"), CancellationToken.None);
Assert.Equal(WebSocketState.Open, websocket.State);
var receiveBuffer = new byte[256];
Assert.Equal("11", await GetWebSocketReply(websocket, receiveBuffer, "ADD 5 6"));
Assert.Equal("8", await GetWebSocketReply(websocket, receiveBuffer, "SUB 10 2"));
Assert.Equal("21", await GetWebSocketReply(websocket, receiveBuffer, "MULT 3 7"));
await websocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
Assert.Equal(WebSocketState.Closed, websocket.State);
await host.StopAsync();
}
}
public async Task TestCommandsWithCustomSessionMultipleServerHost(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = MultipleServerHostBuilder.Create()
.ConfigureAppConfiguration((hostCtx, configApp) =>
{
configApp.Sources.Clear();
configApp.AddInMemoryCollection(new Dictionary <string, string>
{
{ "serverOptions:name", "TestServer" },
{ "serverOptions:listeners:0:ip", "Any" },
{ "serverOptions:listeners:0:port", "4040" }
});
})
.AddServer <StringPackageInfo, CommandLinePipelineFilter>(builder =>
{
builder
.UseCommand()
.UseSession <MySession>()
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.ConfigureContainer <ContainerBuilder>(builder =>
{
builder.RegisterType <ADD>().As <IAsyncCommand <IAppSession, StringPackageInfo> >();
builder.RegisterType <MULT>().As <IAsyncCommand <IAppSession, StringPackageInfo> >();
builder.RegisterType <SUB>().As <IAsyncCommand <IAppSession, StringPackageInfo> >();
builder.RegisterType <DIV>().As <IAsyncCommand <MySession, StringPackageInfo> >();
});
}).BuildAsServer())
{
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(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 4040));
OutputHelper.WriteLine("Connected.");
using (var stream = await hostConfigurator.GetClientStream(client))
using (var streamReader = new StreamReader(stream, Utf8Encoding, true))
using (var streamWriter = new StreamWriter(stream, Utf8Encoding, 1024 * 1024 * 4))
{
await streamWriter.WriteAsync("ADD 1 2 3\r\n");
await streamWriter.FlushAsync();
var line = await streamReader.ReadLineAsync();
Assert.Equal("6", line);
await streamWriter.WriteAsync("MULT 2 5\r\n");
await streamWriter.FlushAsync();
line = await streamReader.ReadLineAsync();
Assert.Equal("10", line);
await streamWriter.WriteAsync("SUB 8 2\r\n");
await streamWriter.FlushAsync();
line = await streamReader.ReadLineAsync();
Assert.Equal("6", line);
await streamWriter.WriteAsync("DIV 8 2\r\n");
await streamWriter.FlushAsync();
line = await streamReader.ReadLineAsync();
Assert.Equal("4", line);
}
await server.StopAsync();
}
}
