public void TestPipeServerClient()
{
Until((port, done) =>
{
var server = new AsyncSocket();
var socketA = new AsyncSocket();
var socketB = new AsyncSocket();
var portA = port;
var portB = portA + 1;
server.Listen(portA, socket => socket.Read(text =>
{
Assert.AreEqual("Hello", text);
socket.Write("world!");
}));
socketB.Listen(portB, socket =>
{
var c = new AsyncSocket();
c.Connect(Host, portB, () => SocketPipe.PipeSockets(socket, c));
});
socketA.Read(text =>
{
Assert.AreEqual("world!", text);
done();
});
socketA.Connect(Host, portA, () => socketA.Write("Hello"));
});
}
public void TestPipeClients()
{
Until((port, done) =>
{
var serverA = new AsyncSocket();
var serverB = new AsyncSocket();
var socketA = new AsyncSocket();
var socketB = new AsyncSocket();
serverA.Listen(port, socket => socket.Read(text =>
{
Assert.AreEqual("Hello", text);
socket.Write("world!");
}));
socketA.Connect(Host, port);
serverB.Listen(port + 1, socket =>
{
socket.Read(text =>
{
Assert.AreEqual("world!", text);
done();
});
socket.Write("Hello");
});
socketB.Connect(Host, port + 1, () => { });
SocketPipe.PipeSockets(socketA, socketB);
});
}
public async ValueTask<StorageResponse> SendRequest<TRequest>(TRequest request)
where TRequest : IStorageRequest
{
if (!_client.IsConnected)
{
_pipe = await SocketPipe.ConnectAsync(_host, _port).ConfigureAwait(false);
_pipe.Log = Log;
_client = new PipeHttpClient(_pipe);
}
request.Client = this;
StorageResponse response = await _client.SendRequest<TRequest, StorageResponse>(request).ConfigureAwait(false);
if (request.ConsumeBody) await ConsumeResponseBody(response.Body);
return response;
}
private async Task ConnectAsync(CancellationToken cancellationToken)
{
if (IsConnected)
{
return;
}
LastAction = "Waiting for Connecting lock to be free";
var wait = _connectSemaphoreSlim.WaitAsync(cancellationToken);
if (!wait.IsCompletedSuccessfully())
{
await wait.ConfigureAwait(false);
}
try
{
if (IsConnected)
{
return;
}
LastAction = "Connecting";
Interlocked.Increment(ref _reconnectAttempts);
_socket = new RedisSocket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
SendTimeout = ClientConfig.SendTimeoutMillis,
ReceiveTimeout = ClientConfig.ReceiveTimeoutMillis
};
OptimiseSocket();
if (IPAddress.TryParse(ClientConfig.Host, out var ip))
{
await _socket.ConnectAsync(ip, ClientConfig.Port).ConfigureAwait(false);
}
else
{
var addresses = await Dns.GetHostAddressesAsync(ClientConfig.Host);
await _socket.ConnectAsync(
addresses.FirstOrDefault(a => a.AddressFamily == AddressFamily.InterNetwork),
ClientConfig.Port).ConfigureAwait(false);
}
if (!_socket.Connected)
{
Log.Debug("Socket Connect failed");
_socket.Close();
_socket = null;
return;
}
Log.Debug("Socket Connected");
Stream networkStream = new NetworkStream(_socket);
var redisPipeOptions = GetPipeOptions();
if (ClientConfig.Ssl)
{
_sslStream = new SslStream(networkStream,
false,
ClientConfig.CertificateValidationCallback,
ClientConfig.CertificateSelectionCallback,
EncryptionPolicy.RequireEncryption);
LastAction = "Authenticating SSL Stream as Client";
await _sslStream.AuthenticateAsClientAsync(ClientConfig.Host).ConfigureAwait(false);
if (!_sslStream.IsEncrypted)
{
Dispose();
throw new SecurityException($"Could not establish an encrypted connection to Redis - {ClientConfig.Host}");
}
LastAction = "Creating SSL Stream Pipe";
_pipe = StreamPipe.GetDuplexPipe(_sslStream, redisPipeOptions.SendOptions, redisPipeOptions.ReceiveOptions);
}
else
{
LastAction = "Creating Socket Pipe";
_pipe = SocketPipe.GetDuplexPipe(_socket, redisPipeOptions.SendOptions, redisPipeOptions.ReceiveOptions);
}
IsConnected = true;
if (!string.IsNullOrEmpty(ClientConfig.Password))
{
LastAction = "Authorizing";
await Authorize(cancellationToken);
}
if (ClientConfig.Db != 0)
{
LastAction = "Selecting Database";
await SelectDb(cancellationToken);
}
if (ClientConfig.ClientName != null)
{
LastAction = "Setting Client Name";
await SetClientNameAsync(cancellationToken);
}
}
finally
{
_connectSemaphoreSlim.Release();
}
}
