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();
}
}
private void WriteMultiplePackages(Stream stream, string[] lines)
{
var pool = ArrayPool <byte> .Shared;
var buffer = pool.Rent(lines.Sum(x => 3 + Utf8Encoding.GetMaxByteCount(x.Length)));
Span <byte> span = buffer;
var total = 0;
foreach (var line in lines)
{
var pack = EncodePackage(line, span);
span = span.Slice(pack.Length);
total += pack.Length;
}
span = new Span <byte>(buffer, 0, total);
var rd = new Random();
var maxRd = total / 2;
while (span.Length > 0)
{
var size = rd.Next(1, maxRd);
size = Math.Min(size, span.Length);
stream.Write(span.Slice(0, size));
stream.Flush();
span = span.Slice(size);
}
pool.Return(buffer);
}
public async Task TestCloseAfterSend(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = CreateSocketServerBuilder <TextPackageInfo, LinePipelineFilter>(hostConfigurator)
.UsePackageHandler(async(IAppSession s, TextPackageInfo p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes("Hello World\r\n"));
await s.CloseAsync(Channel.CloseReason.LocalClosing);
}).BuildAsServer() as IServer)
{
Assert.True(await server.StartAsync());
Assert.Equal(0, server.SessionCount);
var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await client.ConnectAsync(hostConfigurator.GetServerEndPoint());
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("Hello World\r\n");
await streamWriter.FlushAsync();
var line = await streamReader.ReadLineAsync();
Assert.Equal("Hello World", line);
}
await server.StopAsync();
}
}
public async Task TestConsoleProtocol()
{
var server = CreateSocketServerBuilder <TextPackageInfo, LinePipelineFilter>()
.ConfigurePackageHandler(async(IAppSession s, TextPackageInfo p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes("Hello World\r\n"));
}).BuildAsServer() as IServer;
Assert.True(await server.StartAsync());
Assert.Equal(0, server.SessionCount);
var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await client.ConnectAsync(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 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))
{
await streamWriter.WriteAsync("Hello World\r\n");
await streamWriter.FlushAsync();
var line = await streamReader.ReadLineAsync();
Assert.Equal("Hello World", line);
}
await server.StopAsync();
}
/// <summary>
/// Subscribe an action to a topic
/// </summary>
/// <param name="topic"></param>
/// <param name="action"></param>
/// <param name="qoS"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public Guid SubscribeToTopic <T>(string topic, Action <T> action,
MqttQualityOfService qoS = MqttQualityOfService.ExactlyOnce) where T : class, new()
{
// Create a new id for the action
var guid = Guid.NewGuid();
var id = guid.ToString();
// Helper variables to assess topics with wildcards correctly
Func <string, string, bool> condition;
string sanitizedTopic;
// Does the topic contain a wildcard?
if (_containsWildcards(topic))
{
// Convert the mqtt wildcards with proper regex terms
sanitizedTopic = _replaceWildCards(topic);
// To compare those terms use the Regex.IsMatch functionality
condition = Regex.IsMatch;
}
else
{
// If the topic does not contain any mqtt wildcards, than it can stay as it is
sanitizedTopic = topic;
// To compare the topics, use regular string comparision
condition = (key, topic) => key.Equals(topic);
}
// If there was not prior subscription to that topic, subscribe for that topic at the mqtt message broker
if (!_consumers.Keys.Any(key => condition(key, sanitizedTopic)))
{
_bus.SubscribeAsync(sanitizedTopic, qoS);
}
// Get the list of actions that belong to that topic
if (!_consumers.Keys.Any(key => condition(key, sanitizedTopic)))
{
_consumers[sanitizedTopic] = new Dictionary <string, Action <byte[]> >();
}
// Add the new action
// The action of the caller is wrapped in an action that does the casting of the message
_consumers[sanitizedTopic][id] = bytes =>
{
T message = null;
try
{
var jsonString = Utf8Encoding.GetString(bytes);
message = JsonConvert.DeserializeObject <T>(jsonString);
}
catch (Exception e)
{
// ignore
}
// Execute the callers action with the message as parameter
action(message);
};
return(guid);
}
protected override IServer CreateServer()
{
return(CreateSocketServerBuilder <TextPackageInfo, MyFixedHeaderPipelineFilter>()
.ConfigurePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
}).BuildAsServer() as IServer);
}
protected override IServer CreateServer()
{
return(CreateSocketServerBuilder <TextPackageInfo, MyFixedHeaderPipelineFilter>()
.ConfigurePackageHandler(async(IAppSession s, TextPackageInfo p) =>
{
await s.Channel.SendAsync(new ReadOnlyMemory <byte>(Utf8Encoding.GetBytes(p.Text + "\r\n")));
}).BuildAsServer() as IServer);
}
/// <summary>
/// Publish a message to the mqtt message broker.
/// </summary>
/// <param name="topic"></param>
/// <param name="message"></param>
/// <param name="qoS"></param>
/// <typeparam name="T"></typeparam>
public void Publish <T>(string topic, T message, MqttQualityOfService qoS = MqttQualityOfService.ExactlyOnce)
where T : class
{
var jsonString = JsonConvert.SerializeObject(message);
var applicationMessage = new MqttApplicationMessage(topic, Utf8Encoding.GetBytes(jsonString));
_bus.PublishAsync(applicationMessage, qoS);
}
public async Task TestEcho(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = CreateSocketServerBuilder <TextPackageInfo, LinePipelineFilter>(hostConfigurator)
.UsePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
}).BuildAsServer())
{
Assert.Equal("TestServer", server.Name);
Assert.True(await server.StartAsync());
OutputHelper.WriteLine("Server started.");
IEasyClient <TextPackageInfo> client;
var services = new ServiceCollection();
services.AddLogging();
services.Configure <ILoggingBuilder>((loggingBuilder) =>
{
loggingBuilder.AddConsole();
});
var sp = services.BuildServiceProvider();
var loggerFactory = sp.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger("Client");
if (hostConfigurator.IsSecure)
{
client = (new SecureEasyClient <TextPackageInfo>(new LinePipelineFilter(), logger)).AsClient();
}
else
{
client = new EasyClient <TextPackageInfo>(new LinePipelineFilter(), logger).AsClient();
}
var connected = await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, hostConfigurator.Listener.Port));
Assert.True(connected);
for (var i = 0; i < 10; i++)
{
var msg = Guid.NewGuid().ToString();
await client.SendAsync(Utf8Encoding.GetBytes(msg + "\r\n"));
var package = await client.ReceiveAsync();
Assert.NotNull(package);
Assert.Equal(msg, package.Text);
}
await client.CloseAsync();
await server.StopAsync();
}
}
private void WriteHalfPackage(Stream stream, string line)
{
var pool = ArrayPool <byte> .Shared;
var buffer = pool.Rent(3 + Utf8Encoding.GetMaxByteCount(line.Length));
var pack = EncodePackage(line, buffer);
stream.Write(pack.Slice(0, pack.Length / 2));
pool.Return(buffer);
}
protected override IServer CreateServer(IHostConfigurator hostConfigurator)
{
var server = CreateSocketServerBuilder <TextPackageInfo>((x) => new TerminatorTextPipelineFilter(new[] { (byte)'#', (byte)'#' }), hostConfigurator)
.UsePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
}).BuildAsServer() as IServer;
return(server);
}
protected override IServer CreateServer()
{
var server = CreateSocketServerBuilder <TextPackageInfo>((x) => new TerminatorTextPipelineFilter(new[] { (byte)'#', (byte)'#' }))
.ConfigurePackageHandler(async(IAppSession s, TextPackageInfo p) =>
{
await s.Channel.SendAsync(new ReadOnlyMemory <byte>(Utf8Encoding.GetBytes(p.Text + "\r\n")));
}).BuildAsServer() as IServer;
return(server);
}
protected override IServer CreateServer(IHostConfigurator hostConfigurator)
{
var server = CreateSocketServerBuilder <TextPackageInfo, MyFixedSizePipelineFilter>(hostConfigurator)
.ConfigurePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
}).BuildAsServer() as IServer;
return(server);
}
public async Task TestCommandLine(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = CreateSocketServerBuilder <StringPackageInfo, CommandLinePipelineFilter>(hostConfigurator)
.UseCommand((options) =>
{
options.AddCommand <SORT>();
}).BuildAsServer())
{
Assert.Equal("TestServer", server.Name);
Assert.True(await server.StartAsync());
OutputHelper.WriteLine("Server started.");
var pipelineFilter = new CommandLinePipelineFilter
{
Decoder = new DefaultStringPackageDecoder()
};
var options = new ChannelOptions
{
Logger = DefaultLoggerFactory.CreateLogger(nameof(TestCommandLine))
};
var client = hostConfigurator.ConfigureEasyClient(pipelineFilter, options);
StringPackageInfo package = null;
client.PackageHandler += async(s, p) =>
{
package = p;
await Task.CompletedTask;
};
var connected = await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, hostConfigurator.Listener.Port));
Assert.True(connected);
client.StartReceive();
await client.SendAsync(Utf8Encoding.GetBytes("SORT 10 7 3 8 6 43 23\r\n"));
await Task.Delay(1000);
Assert.NotNull(package);
Assert.Equal("SORT", package.Key);
Assert.Equal("3 6 7 8 10 23 43", package.Body);
await client.CloseAsync();
await server.StopAsync();
}
}
protected override IServer CreateServer()
{
var server = CreateSocketServerBuilder <TextPackageInfo>((x) => new TerminatorTextPipelineFilter(new[] { (byte)'#' }))
.ConfigurePackageHandler(async(s, p) =>
{
//OutputHelper.WriteLine(p.Text);
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
}).BuildAsServer() as IServer;
return(server);
}
private ReadOnlySpan <byte> EncodePackage(string line, Span <byte> span)
{
span[0] = 0x0B;
var len = Utf8Encoding.GetBytes(line.AsSpan(), span.Slice(1));
var rest = span.Slice(1 + len);
rest[0] = 0x1C;
rest[1] = 0x0D;
return(span.Slice(0, len + 3));
}
/*
* [Theory]
* [InlineData(typeof(RegularHostConfigurator))]
* [InlineData(typeof(SecureHostConfigurator))]
*/
public async Task TestPingFromServer(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
WebSocketSession session = null;
using (var server = CreateWebSocketSocketServerBuilder(builder =>
{
builder.UseSessionHandler(async(s) =>
{
session = s as WebSocketSession;
await Task.CompletedTask;
});
return(builder);
}, hostConfigurator: hostConfigurator)
.BuildAsServer())
{
Assert.True(await server.StartAsync());
OutputHelper.WriteLine("Server started.");
var websocket = new WebSocket($"{hostConfigurator.WebSocketSchema}://{_loopbackIP}:{hostConfigurator.Listener.Port}");
hostConfigurator.ConfigureClient(websocket);
Assert.True(await websocket.OpenAsync(), "Failed to connect");
var lastPingReceived = websocket.PingPongStatus.LastPingReceived;
Assert.Equal(WebSocketState.Open, websocket.State);
await Task.Delay(1 * 1000);
Assert.NotNull(session);
// send ping from server
await session.SendAsync(new WebSocketPackage
{
OpCode = OpCode.Ping,
Data = new ReadOnlySequence <byte>(Utf8Encoding.GetBytes("Hello"))
});
await Task.Delay(1 * 1000);
var lastPingReceivedNow = websocket.PingPongStatus.LastPingReceived;
Assert.NotEqual(lastPingReceived, lastPingReceivedNow);
await websocket.CloseAsync();
await server.StopAsync();
}
}
protected override IServer CreateServer(IHostConfigurator hostConfigurator)
{
return(CreateSocketServerBuilder <TextPackageInfo, MyFixedHeaderPipelineFilter>(hostConfigurator)
.UsePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
})
.ConfigureAppConfiguration((HostBuilder, configBuilder) =>
{
configBuilder.AddInMemoryCollection(new Dictionary <string, string>
{
{ "serverOptions:values:enableSendingPipe", "true" }
});
}).BuildAsServer() as IServer);
}
private void WriteFragmentPackage(Stream stream, string line)
{
var pool = ArrayPool <byte> .Shared;
var buffer = pool.Rent(3 + Utf8Encoding.GetMaxByteCount(line.Length));
var pack = EncodePackage(line, buffer);
for (var i = 0; i < pack.Length; i++)
{
stream.Write(buffer, i, 1);
stream.Flush();
Thread.Sleep(50);
}
pool.Return(buffer);
}
public async Task MaxPackageLength(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = CreateSocketServerBuilder <TextPackageInfo, LinePipelineFilter>(hostConfigurator)
.ConfigureSuperSocket((options) =>
{
options.MaxPackageLength = 100;
})
.ConfigurePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
}).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 = hostConfigurator.GetClientStream(client))
using (var streamReader = new StreamReader(stream, Utf8Encoding, true))
using (var streamWriter = new StreamWriter(stream, Utf8Encoding, 1024 * 1024 * 4))
{
for (var i = 0; i < 5; i++)
{
await streamWriter.WriteAsync(Guid.NewGuid().ToString());
}
await streamWriter.WriteAsync("\r\n");
await streamWriter.FlushAsync();
Thread.Sleep(1000);
var line = await streamReader.ReadLineAsync();
Assert.Null(line);
}
await server.StopAsync();
}
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="passphrase">Password.</param>
public Document(string passphrase)
: this()
{
if (passphrase == null)
{
throw new ArgumentNullException(nameof(passphrase), "Passphrase cannot be null.");
}
var passphraseBuffer = Utf8Encoding.GetBytes(passphrase);
try {
this.Passphrase = passphraseBuffer; //no need for copy - will be done in property setter
} finally {
Array.Clear(passphraseBuffer, 0, passphraseBuffer.Length); //remove passphrase bytes from memory - nothing to do about the string. :(
}
}
internal PasswordHistoryItem(PasswordHistoryCollection owner, DateTime firstTimeUsed, string historicalPassword)
{
Owner = owner;
TimeFirstUsed = firstTimeUsed;
byte[]? historicalPasswordBytes = null;
try {
historicalPasswordBytes = Utf8Encoding.GetBytes(historicalPassword);
RawHistoricalPasswordData = historicalPasswordBytes;
} finally {
if (historicalPasswordBytes != null)
{
Array.Clear(historicalPasswordBytes, 0, historicalPasswordBytes.Length);
}
}
}
public async Task TestEcho(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = CreateSocketServerBuilder <TextPackageInfo, LinePipelineFilter>(hostConfigurator)
.ConfigurePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
}).BuildAsServer())
{
Assert.Equal("TestServer", server.Name);
Assert.True(await server.StartAsync());
OutputHelper.WriteLine("Server started.");
EasyClient <TextPackageInfo> client;
if (hostConfigurator.IsSecure)
{
client = new SecureEasyClient <TextPackageInfo>(new LinePipelineFilter());
}
else
{
client = new EasyClient <TextPackageInfo>(new LinePipelineFilter());
}
var connected = await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, hostConfigurator.Listener.Port));
Assert.True(connected);
for (var i = 0; i < 10; i++)
{
var msg = Guid.NewGuid().ToString();
await client.SendAsync(Utf8Encoding.GetBytes(msg + "\r\n"));
var package = await client.ReceiveAsync();
Assert.NotNull(package);
Assert.Equal(msg, package.Text);
}
client.Close();
await server.StopAsync();
}
}
public async Task TestEcho(Type hostConfiguratorType, bool clientReadAsDemand)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = CreateSocketServerBuilder <TextPackageInfo, LinePipelineFilter>(hostConfigurator)
.UsePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes(p.Text + "\r\n"));
}).BuildAsServer())
{
Assert.Equal("TestServer", server.Name);
Assert.True(await server.StartAsync());
OutputHelper.WriteLine("Server started.");
var options = new ChannelOptions
{
Logger = NullLogger.Instance,
ReadAsDemand = clientReadAsDemand
};
var client = hostConfigurator.ConfigureEasyClient(new LinePipelineFilter(), options);
var connected = await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, hostConfigurator.Listener.Port));
Assert.True(connected);
for (var i = 0; i < 100; i++)
{
var msg = Guid.NewGuid().ToString();
await client.SendAsync(Utf8Encoding.GetBytes(msg + "\r\n"));
var package = await client.ReceiveAsync();
Assert.NotNull(package);
Assert.Equal(msg, package.Text);
}
await client.CloseAsync();
await server.StopAsync();
}
}
public string ReadString()
{
int length = ReadLength();
// No need to read any data for an empty string.
if (length == 0)
{
return("");
}
CheckReadSize(length);
// Fast path: We already have the bytes in a contiguous buffer, so
// just copy directly from it.
String result = Utf8Encoding.GetString(mBuffer, mReadPos, length);
mReadPos += length;
return(result);
}
/// <summary>
/// Send the message to the server.
/// </summary>
/// <param name="serverCall">Call to server with arguments.</param>
public async Task Send(ServerCall serverCall)
{
LastServerCall = serverCall;
//Make sure there is not already one sent
if (SendWaiting)
{
return;
}
//Create the bugger and wait for confirmation
var json = serverCall.ToJson();
var buffer = Utf8Encoding.GetBytes(json);
SendWaiting = true;
await WebSocket.SendAsync(new ArraySegment <byte>(buffer), WebSocketMessageType.Text, true, CancellationToken.None);
SendWaiting = false;
OnConnectionLog($"WS message sent to server: {json}");
}
public async Task TestSessionCount()
{
using (var server = CreateSocketServerBuilder <TextPackageInfo, LinePipelineFilter>()
.UsePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes("Hello World\r\n"));
}).BuildAsServer())
{
Assert.Equal("TestServer", server.Name);
Assert.True(await server.StartAsync());
OutputHelper.WriteLine("Started.");
Assert.Equal(0, server.SessionCount);
OutputHelper.WriteLine("SessionCount:" + server.SessionCount);
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.");
await Task.Delay(1000);
Assert.Equal(1, server.SessionCount);
OutputHelper.WriteLine("SessionCount:" + server.SessionCount);
client.Shutdown(SocketShutdown.Both);
client.Close();
await Task.Delay(1000);
Assert.Equal(0, server.SessionCount);
OutputHelper.WriteLine("SessionCount:" + server.SessionCount);
await server.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 async Task TestDetachableChannel(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = CreateSocketServerBuilder <TextPackageInfo, LinePipelineFilter>(hostConfigurator)
.UsePackageHandler(async(s, p) =>
{
await s.SendAsync(Utf8Encoding.GetBytes("PRE-" + p.Text + "\r\n"));
}).BuildAsServer())
{
Assert.Equal("TestServer", server.Name);
Assert.True(await server.StartAsync());
OutputHelper.WriteLine("Server started.");
var services = new ServiceCollection();
services.AddLogging();
services.Configure <ILoggingBuilder>((loggingBuilder) =>
{
loggingBuilder.AddConsole();
});
var sp = services.BuildServiceProvider();
var loggerFactory = sp.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger("Client");
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await socket.ConnectAsync(new IPEndPoint(IPAddress.Loopback, 4040));
var stream = await hostConfigurator.GetClientStream(socket);
var channel = new StreamPipeChannel <TextPackageInfo>(stream, socket.RemoteEndPoint, socket.LocalEndPoint, new LinePipelineFilter(), new ChannelOptions
{
Logger = logger,
ReadAsDemand = true
});
channel.Start();
var msg = Guid.NewGuid().ToString();
await channel.SendAsync(Utf8Encoding.GetBytes(msg + "\r\n"));
var round = 0;
await foreach (var package in channel.RunAsync())
{
Assert.NotNull(package);
Assert.Equal("PRE-" + msg, package.Text);
round++;
if (round >= 10)
{
break;
}
msg = Guid.NewGuid().ToString();
await channel.SendAsync(Utf8Encoding.GetBytes(msg + "\r\n"));
}
OutputHelper.WriteLine("Before DetachAsync");
await channel.DetachAsync();
// the connection is still alive in the server
Assert.Equal(1, server.SessionCount);
// socket.Connected is is still connected
Assert.True(socket.Connected);
var ns = stream as DerivedNetworkStream;
Assert.True(ns.Socket.Connected);
// the stream is still usable
using (var streamReader = new StreamReader(stream, Utf8Encoding, true))
using (var streamWriter = new StreamWriter(stream, Utf8Encoding, 1024 * 1024 * 4))
{
for (var i = 0; i < 10; i++)
{
var txt = Guid.NewGuid().ToString();
await streamWriter.WriteAsync(txt + "\r\n");
await streamWriter.FlushAsync();
var line = await streamReader.ReadLineAsync();
Assert.Equal("PRE-" + txt, line);
}
}
await server.StopAsync();
}
}
public async Task TestCommandLine(Type hostConfiguratorType)
{
var hostConfigurator = CreateObject <IHostConfigurator>(hostConfiguratorType);
using (var server = CreateSocketServerBuilder <StringPackageInfo, CommandLinePipelineFilter>(hostConfigurator)
.UseCommand((options) =>
{
options.AddCommand <SORT>();
}).BuildAsServer())
{
Assert.Equal("TestServer", server.Name);
Assert.True(await server.StartAsync());
OutputHelper.WriteLine("Server started.");
IEasyClient <StringPackageInfo> client;
var services = new ServiceCollection();
services.AddLogging();
services.Configure <ILoggingBuilder>((loggingBuilder) =>
{
loggingBuilder.AddConsole();
});
var sp = services.BuildServiceProvider();
var loggerFactory = sp.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger("Client");
var pipelineFilter = new CommandLinePipelineFilter
{
Decoder = new DefaultStringPackageDecoder()
};
if (hostConfigurator.IsSecure)
{
client = (new SecureEasyClient <StringPackageInfo>(pipelineFilter, logger)).AsClient();
}
else
{
client = new EasyClient <StringPackageInfo>(pipelineFilter, logger).AsClient();
}
StringPackageInfo package = null;
client.PackageHandler += (s, p) =>
{
package = p;
};
var connected = await client.ConnectAsync(new IPEndPoint(IPAddress.Loopback, hostConfigurator.Listener.Port));
Assert.True(connected);
client.StartReceive();
await client.SendAsync(Utf8Encoding.GetBytes("SORT 10 7 3 8 6 43 23\r\n"));
await Task.Delay(1000);
Assert.NotNull(package);
Assert.Equal("SORT", package.Key);
Assert.Equal("3 6 7 8 10 23 43", package.Body);
await client.CloseAsync();
await server.StopAsync();
}
}