public static Client Build()
{
#pragma warning disable 1998
var handler = new ManagedHandler(async(string host, int port, CancellationToken cancellationToken) =>
#pragma warning restore 1998
{
#if UNITY_EDITOR_WIN
var pipe = new NamedPipeClientStream(".", "docker_engine", PipeDirection.InOut, PipeOptions.Asynchronous);
try
{
pipe.Connect(5000);
}
catch (Exception e)
{
throw new DockerConnectException(e);
}
return(new DockerPipeStream(pipe));
#else
var sock = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
try {
await SocketTaskExtensions.ConnectAsync(sock, new UnixDomainSocketEndPoint("/var/run/docker.sock"));
}
catch (Exception e)
{
throw new DockerConnectException(e);
}
return(sock);
#endif
});
var httpClient = new HttpClient(handler);
var docker = new Client("http://docker_engine", httpClient);
return(docker);
}
public static Task <int> ReceiveAsync(this Socket socket, Memory <byte> memory, SocketFlags socketFlags)
{
if (!MemoryMarshal.TryGetArray((ReadOnlyMemory <byte>)memory, out var segment))
{
throw new InvalidOperationException("Buffer backed by array was expected.");
}
return(SocketTaskExtensions.ReceiveAsync(socket, segment, socketFlags));
}
public static async ValueTask <int> SendAsync(this Socket socket, ReadOnlyMemory <byte> buffer, SocketFlags socketFlags)
{
if (MemoryMarshal.TryGetArray(buffer, out var segment))
{
return(await SocketTaskExtensions.SendAsync(socket, segment, socketFlags));
}
using (var rentedBuffer = new RentedBuffer <byte>(buffer.Length))
{
buffer.CopyTo(rentedBuffer);
return(await SocketTaskExtensions.SendAsync(socket, rentedBuffer.Segment, socketFlags));
}
}
public async Task EnsureMethodsAreCallable()
{
// The purpose of this test is just to ensure that the now-hidden extension methods in SocketTaskExtensions are
// properly invoking the underlying instance methods, and not accidentally binding to themselves, causing infinite recursion.
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint badEndPoint = new IPEndPoint(IPAddress.None, 0);
string badHostName = "nosuchhost.invalid";
byte[] buffer = new byte[1];
await Assert.ThrowsAsync <InvalidOperationException>(async() => await SocketTaskExtensions.AcceptAsync(s));
await Assert.ThrowsAsync <InvalidOperationException>(async() => await SocketTaskExtensions.AcceptAsync(s, null));
await Assert.ThrowsAsync <InvalidOperationException>(async() => await SocketTaskExtensions.ReceiveFromAsync(s, new ArraySegment <byte>(buffer), SocketFlags.None, badEndPoint));
await Assert.ThrowsAsync <InvalidOperationException>(async() => await SocketTaskExtensions.ReceiveMessageFromAsync(s, new ArraySegment <byte>(buffer), SocketFlags.None, badEndPoint));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ConnectAsync(s, badEndPoint));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ConnectAsync(s, badEndPoint, CancellationToken.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ConnectAsync(s, badEndPoint.Address, badEndPoint.Port));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ConnectAsync(s, badEndPoint.Address, badEndPoint.Port, CancellationToken.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ConnectAsync(s, new IPAddress[] { badEndPoint.Address, badEndPoint.Address }, badEndPoint.Port));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ConnectAsync(s, new IPAddress[] { badEndPoint.Address, badEndPoint.Address }, badEndPoint.Port, CancellationToken.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ConnectAsync(s, badHostName, badEndPoint.Port));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ConnectAsync(s, badHostName, badEndPoint.Port, CancellationToken.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ReceiveAsync(s, new ArraySegment <byte>(buffer), SocketFlags.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ReceiveAsync(s, buffer.AsMemory(), SocketFlags.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.ReceiveAsync(s, new ArraySegment <byte>[] { new ArraySegment <byte>(buffer) }, SocketFlags.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.SendAsync(s, new ArraySegment <byte>(buffer), SocketFlags.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.SendAsync(s, buffer.AsMemory(), SocketFlags.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.SendAsync(s, new ArraySegment <byte>[] { new ArraySegment <byte>(buffer) }, SocketFlags.None));
await Assert.ThrowsAsync <SocketException>(async() => await SocketTaskExtensions.SendToAsync(s, new ArraySegment <byte>(buffer), SocketFlags.None, badEndPoint));
}
//写入循环
private async Task FillPipeAsync(Socket socket, PipeWriter writer)
{
//数据流量比较大，用8k作为buffer
const int minimumBufferSize = 1024 * 8;
while (running)
{
try
{
//从writer中，获得一段不少于指定大小的内存空间
Memory <byte> memory = writer.GetMemory(minimumBufferSize);
await socket.ReceiveAsync(memory, SocketFlags.None);
//将内存空间变成ArraySegment，提供给socket使用
if (!MemoryMarshal.TryGetArray((ReadOnlyMemory <byte>)memory, out ArraySegment <byte> arraySegment))
{
throw new InvalidOperationException("Buffer backed by array was expected");
}
//接受数据
int bytesRead = await SocketTaskExtensions.ReceiveAsync(socket, arraySegment, SocketFlags.None);
if (bytesRead == 0)
{
break;
}
//一次接受完毕，数据已经在pipe中，告诉pipe已经给它写了多少数据。
writer.Advance(bytesRead);
}
catch
{
break;
}
// 提示reader可以进行读取数据，reader可以继续执行readAsync()方法
FlushResult result = await writer.FlushAsync();
if (result.IsCompleted)
{
break;
}
}
// 告诉pipe完事了
writer.Complete();
}
public static async Task <int> SendBuffersAsync(this Socket socket, IEnumerable <ReadOnlyMemory <byte> > buffers, SocketFlags socketFlags, CancellationToken token)
{
socket.Required(nameof(socket));
var total = 0;
foreach (var buffer in buffers.Required(nameof(buffers)))
{
var expected = buffer.Length;
var sent = await SocketTaskExtensions.SendAsync(socket, buffer, socketFlags, token);
total += sent;
if (sent < expected)
{
break;
}
}
return(total);
}
private void ProcessLine(ReadOnlySequence <byte> seq)
{
var str = Encoding.UTF8.GetString(seq.ToArray());
Console.WriteLine($"{str}");
var reader = new SequenceReader <byte>(seq);
var command = new ReadOnlySpan <byte>();
var pingCommand = Encoding.ASCII.GetBytes("PING");
var pongCommand = Encoding.ASCII.GetBytes("PONG ");
var crLf = new byte[] { 13, 10 };
if (reader.TryReadTo(out command, 32, advancePastDelimiter: true))
{
if (command.SequenceEqual(pingCommand))
{
var buffers = new ArraySegment <byte>[] { pongCommand, seq.Slice(reader.Position).ToArray(), crLf };
SocketTaskExtensions.SendAsync(_socket, buffers, SocketFlags.None);
}
}
}
static Func <IPEndPoint, CancellationToken, Task> ConnectAsyncHelper(Socket socket) => (e, ct) => SocketTaskExtensions.ConnectAsync(socket, e, ct).AsTask();
public static Task <int> ReceiveAsync(this Socket socket, Memory <byte> memory, SocketFlags socketFlags)
{
var arraySegment = GetArray(memory);
return(SocketTaskExtensions.ReceiveAsync(socket, arraySegment, socketFlags));
}
public static ValueTask <int> SendAsync(this Socket socket, ReadOnlyMemory <byte> buffer, SocketFlags socketFlags, CancellationToken token) => SocketTaskExtensions.SendAsync(socket, buffer, socketFlags, token);
public static ValueTask <int> ReceiveAsync(this Socket socket, Memory <byte> memory, SocketFlags socketFlags, CancellationToken token) => SocketTaskExtensions.ReceiveAsync(socket, memory, socketFlags, token);
