/// <summary>
/// 监听命令
/// </summary>
public void CommandListen()
{
using (AnonymousPipeClientStream pipe = new AnonymousPipeClientStream(PipeDirection.In, _commandPipeHandle))
{
byte[] commandByte = new byte[1024];
while (true)
{
int count = pipe.Read(commandByte, 0, commandByte.Length);
string command = Encoding.UTF8.GetString(commandByte, 0, count);
if (command == "quit")
{
_runner.Running = false;
}
try
{
SendLog(new LogInfo {
TaskId = AppId, Level = LogLevel.Info, Message = "【执行命令】" + command
});
_runner.Command(command);
}
catch (Exception ex)
{
SendLog(new LogInfo {
TaskId = AppId, Level = LogLevel.Error, Message = "【执行命令出错】" + ex.Message + ex.StackTrace
});
}
}
}
}
/// <summary>
/// Get an object from the specified anonymous in pipe.
/// </summary>
/// <param name="pipeReader">The pipe to read from.</param>
/// <returns>The object or null if no object read.</returns>
public static object GetObjectFromPipe(AnonymousPipeClientStream pipeReader)
{
// Read number of bytes.
var intBuffer = new byte[4];
pipeReader.Read(intBuffer, 0, 4);
var numBytes = BitConverter.ToInt32(intBuffer, 0);
if (numBytes > 0)
{
// Read bytes for object.
var buffer = new byte[numBytes];
pipeReader.Read(buffer, 0, numBytes);
// Convert bytes to object.
return(ReflectionUtilities.BinaryDeserialise(new MemoryStream(buffer)));
}
return(null);
}
public static void ClonedClient_ActsAsOriginalClient()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
using (AnonymousPipeClientStream clientBase = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle))
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, clientBase.SafePipeHandle))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
server.Write(sent, 0, 1);
Assert.Equal(1, client.Read(received, 0, 1));
Assert.Equal(sent[0], received[0]);
}
}
public static void ClientPInvokeChecks()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.Out, server.ClientSafePipeHandle))
{
Task serverTask = Task.Run(() => DoStreamOperations(server));
Assert.False(client.CanRead);
Assert.False(client.CanSeek);
Assert.False(client.CanTimeout);
Assert.True(client.CanWrite);
Assert.False(client.IsAsync);
Assert.True(client.IsConnected);
Assert.Equal(0, client.OutBufferSize);
Assert.Equal(PipeTransmissionMode.Byte, client.ReadMode);
Assert.NotNull(client.SafePipeHandle);
Assert.Equal(PipeTransmissionMode.Byte, client.TransmissionMode);
client.Write(new byte[] { 123 }, 0, 1);
client.WriteAsync(new byte[] { 124 }, 0, 1).Wait();
client.WaitForPipeDrain();
client.Flush();
serverTask.Wait();
}
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle))
{
Task serverTask = Task.Run(() => DoStreamOperations(server));
Assert.Equal(4096, client.InBufferSize);
byte[] readData = new byte[] { 0, 1 };
Assert.Equal(1, client.Read(readData, 0, 1));
Assert.Equal(1, client.ReadAsync(readData, 1, 1).Result);
Assert.Equal(123, readData[0]);
Assert.Equal(124, readData[1]);
serverTask.Wait();
}
}
}
public static void ClientPInvokeChecks()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In))
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.Out, server.ClientSafePipeHandle))
{
Task serverTask = DoServerOperationsAsync(server);
Console.WriteLine("client.CanRead = {0}", client.CanRead);
Console.WriteLine("client.CanSeek = {0}", client.CanSeek);
Console.WriteLine("client.CanTimeout = {0}", client.CanTimeout);
Console.WriteLine("client.CanWrite = {0}", client.CanWrite);
Console.WriteLine("client.IsAsync = {0}", client.IsAsync);
Console.WriteLine("client.IsConnected = {0}", client.IsConnected);
Console.WriteLine("client.OutBufferSize = {0}", client.OutBufferSize);
Console.WriteLine("client.ReadMode = {0}", client.ReadMode);
Console.WriteLine("client.SafePipeHandle = {0}", client.SafePipeHandle);
Console.WriteLine("client.TransmissionMode = {0}", client.TransmissionMode);
client.Write(new byte[] { 123 }, 0, 1);
client.WriteAsync(new byte[] { 124 }, 0, 1).Wait();
client.WaitForPipeDrain();
client.Flush();
serverTask.Wait();
}
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle))
{
Task serverTask = DoServerOperationsAsync(server);
Console.WriteLine("client.InBufferSize = {0}", client.InBufferSize);
byte[] readData = new byte[] { 0, 1 };
client.Read(readData, 0, 1);
client.ReadAsync(readData, 1, 1).Wait();
Assert.Equal(123, readData[0]);
Assert.Equal(124, readData[1]);
serverTask.Wait();
}
}
}
public static void ServerSendsByteClientReceives()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.True(server.IsConnected);
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
server.Write(sent, 0, 1);
Assert.Equal(1, client.Read(received, 0, 1));
Assert.Equal(sent[0], received[0]);
}
}
}
public static void ServerSendsByteClientReceives()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
Assert.True(server.IsConnected);
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString()))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
server.Write(sent, 0, 1);
Assert.Equal(1, client.Read(received, 0, 1));
Assert.Equal(sent[0], received[0]);
}
Assert.Throws <System.IO.IOException>(() => server.WriteByte(5));
}
}
public int Read(byte[] buffer, int offset, int count)
{
if (!m_Started)
{
return(0);
}
int read = 0;
try
{
read = m_Client.Read(buffer, offset, count);
}
catch (NullReferenceException)
{
//Somtimes a nullreference occures when closing down application
}
return(read);
}
public static void ClonedClient_ActsAsOriginalClient()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
using (AnonymousPipeClientStream clientBase = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString()))
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, clientBase.SafePipeHandle))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
server.Write(sent, 0, 1);
Assert.Equal(1, client.Read(received, 0, 1));
Assert.Equal(sent[0], received[0]);
}
}
}
}
internal CurrentDomain(Process current)
{
Process = current;
var parentConnectionString = Regex.Match(Environment.GetEnvironmentVariable(connectionStringVarName) ?? "",
@"^pid=(?<pid>\d+)&write=(?<write>\d+)&read=(?<read>\d+)&debug=(?<debug>[01])&serializer=(?<serializer>[^&]+)&proxyGenerator=(?<proxyGenerator>[^&]+)$", RegexOptions.IgnoreCase);
if (!parentConnectionString.Success)
{
if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable(connectionStringVarName)))
{
throw new InvalidOperationException($"Invalid connection string from parent: {Environment.GetEnvironmentVariable(connectionStringVarName)}");
}
return;
}
var parent = Process.GetProcessById(Convert.ToInt32(parentConnectionString.Groups["pid"].Value));
parent.EnableRaisingEvents = true;
parent.Exited += (sender, eventArgs) => Environment.Exit(0);
var serializerName = HttpUtility.HtmlDecode(parentConnectionString.Groups["serializer"].Value);
var proxyGeneratorName = HttpUtility.HtmlDecode(parentConnectionString.Groups["proxyGenerator"].Value);
var reader = new AnonymousPipeClientStream(PipeDirection.In, parentConnectionString.Groups["read"].Value);
if (parentConnectionString.Groups["debug"].Value == "1")
{
//wait for a signal from the parent process to proceed
reader.Read(new byte[1], 0, 1);
}
Channels = new Connection(this,
DomainConfiguration.SerializerResolver(serializerName) ?? throw new InvalidOperationException($"Invalid serializer from parent: {serializerName}"),
DomainConfiguration.Resolver(proxyGeneratorName) ?? throw new InvalidOperationException($"Invalid proxy generator from parent: {proxyGeneratorName}"),
reader,
new AnonymousPipeClientStream(PipeDirection.Out, parentConnectionString.Groups["write"].Value));
}
public static void ClonedServer_ActsAsOriginalServer()
{
using (AnonymousPipeServerStream serverBase = new AnonymousPipeServerStream(PipeDirection.Out))
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, serverBase.SafePipeHandle, serverBase.ClientSafePipeHandle))
{
Assert.True(server.IsConnected);
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.GetClientHandleAsString()))
{
Assert.True(server.IsConnected);
Assert.True(client.IsConnected);
byte[] sent = new byte[] { 123 };
byte[] received = new byte[] { 0 };
server.Write(sent, 0, 1);
Assert.Equal(1, client.Read(received, 0, 1));
Assert.Equal(sent[0], received[0]);
}
Assert.Throws <IOException>(() => server.WriteByte(5));
}
}
}
public static async Task ClientPInvokeChecks()
{
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In, System.IO.HandleInheritability.None, 4096))
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.Out, server.ClientSafePipeHandle))
{
Task serverTask = Task.Run(() => DoStreamOperations(server));
Assert.False(client.CanRead);
Assert.False(client.CanSeek);
Assert.False(client.CanTimeout);
Assert.True(client.CanWrite);
Assert.False(client.IsAsync);
Assert.True(client.IsConnected);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Assert.Equal(0, client.OutBufferSize);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
Assert.True(client.OutBufferSize > 0);
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => client.OutBufferSize);
}
Assert.Equal(PipeTransmissionMode.Byte, client.ReadMode);
Assert.NotNull(client.SafePipeHandle);
Assert.Equal(PipeTransmissionMode.Byte, client.TransmissionMode);
client.Write(new byte[] { 123 }, 0, 1);
await client.WriteAsync(new byte[] { 124 }, 0, 1);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
client.WaitForPipeDrain();
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => client.WaitForPipeDrain());
}
client.Flush();
await serverTask;
}
}
using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out))
{
using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle))
{
Task serverTask = Task.Run(() => DoStreamOperations(server));
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Assert.Equal(4096, client.InBufferSize);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
Assert.True(client.InBufferSize > 0);
}
else
{
Assert.Throws <PlatformNotSupportedException>(() => client.InBufferSize);
}
byte[] readData = new byte[] { 0, 1 };
Assert.Equal(1, client.Read(readData, 0, 1));
Assert.Equal(1, client.ReadAsync(readData, 1, 1).Result);
Assert.Equal(123, readData[0]);
Assert.Equal(124, readData[1]);
await serverTask;
}
}
}