Ejemplo n.º 1
0
 public async Task ConnectToNonExistentServer_Throws_TimeoutException()
 {
     using (NamedPipeClientStream client = new NamedPipeClientStream(".", "notthere"))
     {
         var ctx = new CancellationTokenSource();
         Assert.Throws<TimeoutException>(() => client.Connect(60));  // 60 to be over internal 50 interval
         await Assert.ThrowsAsync<TimeoutException>(() => client.ConnectAsync(50));
         await Assert.ThrowsAsync<TimeoutException>(() => client.ConnectAsync(60, ctx.Token)); // testing Token overload; ctx is not canceled in this test
     }
 }
Ejemplo n.º 2
0
        public async Task CancelConnectToNonExistentServer_Throws_OperationCanceledException()
        {
            using (NamedPipeClientStream client = new NamedPipeClientStream(".", "notthere"))
            {
                var ctx = new CancellationTokenSource();

                Task clientConnectToken = client.ConnectAsync(ctx.Token);
                ctx.Cancel();
                await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientConnectToken);

                ctx.Cancel();
                await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.ConnectAsync(ctx.Token));
            }
        }
Ejemplo n.º 3
0
 public async Task CancelConnectToNonExistentServer_Throws_OperationCanceledException()
 {
     using (NamedPipeClientStream client = new NamedPipeClientStream(".", "notthere"))
     {
         var ctx = new CancellationTokenSource();
         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - Unix implementation currently ignores timeout and cancellation token once the operation has been initiated
         {
             Task clientConnectToken = client.ConnectAsync(ctx.Token);
             ctx.Cancel();
             await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientConnectToken);
         }
         ctx.Cancel();
         await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.ConnectAsync(ctx.Token));
     }
 }
        public async Task PingPong_Async()
        {
            // Create names for two pipes
            string outName = Path.GetRandomFileName();
            string inName = Path.GetRandomFileName();

            // Create the two named pipes, one for each direction, then create
            // another process with which to communicate
            using (var outbound = new NamedPipeServerStream(outName, PipeDirection.Out))
            using (var inbound = new NamedPipeClientStream(".", inName, PipeDirection.In))
            using (RemoteInvoke(PingPong_OtherProcess, outName, inName))
            {
                // Wait for both pipes to be connected
                await Task.WhenAll(outbound.WaitForConnectionAsync(), inbound.ConnectAsync());

                // Repeatedly write then read a byte to and from the other process
                var data = new byte[1];
                for (byte i = 0; i < 10; i++)
                {
                    data[0] = i;
                    await outbound.WriteAsync(data, 0, data.Length);
                    data[0] = 0;
                    int received = await inbound.ReadAsync(data, 0, data.Length);
                    Assert.Equal(1, received);
                    Assert.Equal(i, data[0]);
                }
            }
        }
Ejemplo n.º 5
0
 public void InvalidConnectTimeout_Throws_ArgumentOutOfRangeException()
 {
     using (NamedPipeClientStream client = new NamedPipeClientStream("client1"))
     {
         Assert.Throws<ArgumentOutOfRangeException>("timeout", () => client.Connect(-111));
         Assert.Throws<ArgumentOutOfRangeException>("timeout", () => { client.ConnectAsync(-111); });
     }
 }
        protected override ServerClientPair CreateServerClientPair()
        {
            ServerClientPair ret = new ServerClientPair();
            string pipeName = GetUniquePipeName();
            var writeablePipe = new NamedPipeServerStream(pipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
            var readablePipe = new NamedPipeClientStream(".", pipeName, PipeDirection.In, PipeOptions.Asynchronous);

            Task clientConnect = readablePipe.ConnectAsync();
            writeablePipe.WaitForConnection();
            clientConnect.Wait();

            ret.readablePipe = readablePipe;
            ret.writeablePipe = writeablePipe;
            return ret;
        }
Ejemplo n.º 7
0
        public async Task <TIn> RequestAsync(TOut request, int timeout, CancellationToken cancellationToken)
        {
            using (Logger.BeginScope($"{nameof(RequestAsync)}"))
            {
                using (var stream = new NamedPipeClientStream(ServerName, PipeName))
                {
                    Logger.LogInformation($"Try connect to pipe server.\r\n{ConnectionLogString}");
                    await stream.ConnectAsync(timeout, cancellationToken);

                    Logger.LogDebug($"Connected to pipe server.");

                    return(GetResponse(stream, request));
                }
            }
        }
Ejemplo n.º 8
0
        public async Task RunClient(string args)
        {
            using (var client = new NamedPipeClientStream(".", _name, PipeDirection.Out))
            {
                await client.ConnectAsync(ClientConnectTimeoutSeconds * 1000);

                using (var sw = new StreamWriter(client)
                {
                    AutoFlush = true
                })
                {
                    await sw.WriteAsync(args);
                }
            }
        }
Ejemplo n.º 9
0
        public async Task Send(string message)
        {
            using (var client = new NamedPipeClientStream(Server.Id))
            {
                using (var writer = new StreamWriter(client))
                {
#if NET40
                    client.Connect();
#else
                    await client.ConnectAsync().ConfigureAwait(false);
#endif
                    await writer.WriteLineAsync(message).ConfigureAwait(false);
                }
            }
        }
Ejemplo n.º 10
0
        public void InvalidReadMode_Throws_ArgumentOutOfRangeException(PipeDirection serverDirection, PipeDirection clientDirection)
        {
            string pipeName = GetUniquePipeName();

            using (var server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
                using (var client = new NamedPipeClientStream(".", pipeName, clientDirection))
                {
                    Task clientConnect = client.ConnectAsync();
                    server.WaitForConnection();
                    clientConnect.Wait();

                    Assert.Throws <ArgumentOutOfRangeException>(() => server.ReadMode = (PipeTransmissionMode)999);
                    Assert.Throws <ArgumentOutOfRangeException>(() => client.ReadMode = (PipeTransmissionMode)999);
                }
        }
Ejemplo n.º 11
0
        static async Task MainAsync()
        {
            Console.WriteLine("Connecting to server...");
            using (var stream = new NamedPipeClientStream(".", "StreamJsonRpcSamplePipe", PipeDirection.InOut, PipeOptions.Asynchronous))
            {
                await stream.ConnectAsync();

                Console.WriteLine("Connected. Sending request...");
                var jsonRpc = JsonRpc.Attach(stream);
                int sum     = await jsonRpc.InvokeAsync <int>("Add", 3, 5);

                Console.WriteLine($"3 + 5 = {sum}");
                Console.WriteLine("Terminating stream...");
            }
        }
Ejemplo n.º 12
0
        public async void StartClient(string pipeName, string monitorSocketAddress, CancellationToken cancellationToken)
        {
            if (pipeName != null && !_configured)
            {
                Trace.Info("Connecting to named pipe {0}", pipeName);
                _outClient = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, PipeOptions.Asynchronous);
                await _outClient.ConnectAsync(cancellationToken);

                _writeStream = new StreamWriter(_outClient, Encoding.UTF8);
                _configured  = true;
                Trace.Info("Connection successful to named pipe {0}", pipeName);
            }

            ConnectMonitor(monitorSocketAddress);
        }
        public async Task DisposedClientPipe_Throws_ObjectDisposedException()
        {
            using (NamedPipePair pair = CreateNamedPipePair())
            {
                pair.Connect();
                NamedPipeClientStream pipe = pair.clientStream;
                pipe.Dispose();
                byte[] buffer = new byte[] { 0, 0, 0, 0 };

                Assert.Throws <ObjectDisposedException>(() => pipe.Connect());
                await Assert.ThrowsAsync <ObjectDisposedException>(() => pipe.ConnectAsync());

                Assert.Throws <ObjectDisposedException>(() => pipe.NumberOfServerInstances);
            }
        }
Ejemplo n.º 14
0
        protected override async Task <RpcResponseMessage> SendAsync(RpcRequestMessage request, string route = null)
        {
            RpcLogger          rpcLogger = new RpcLogger(_log);
            RpcResponseMessage rpcResponseMessage;

            try
            {
                var cancellationTokenSource = new CancellationTokenSource();
                cancellationTokenSource.CancelAfter(ConnectionTimeout);

                using (var pipeStream = new NamedPipeClientStream(IpcPath))
                {
                    await pipeStream.ConnectAsync(cancellationTokenSource.Token);

                    string str   = JsonConvert.SerializeObject(request, JsonSerializerSettings);
                    byte[] bytes = Encoding.UTF8.GetBytes(str);
                    rpcLogger.LogRequest(str);
                    await pipeStream.WriteAsync(bytes, 0, bytes.Length, cancellationTokenSource.Token);

                    using (MemoryStream fullResponse = await ReceiveFullResponseAsync(pipeStream, cancellationTokenSource.Token))
                    {
                        fullResponse.Position = 0L;
                        using (StreamReader streamReader = new StreamReader(fullResponse))
                        {
                            using (JsonTextReader jsonTextReader = new JsonTextReader(streamReader))
                            {
                                RpcResponseMessage responseMessage = JsonSerializer.Create(JsonSerializerSettings).Deserialize <RpcResponseMessage>(jsonTextReader);
                                rpcLogger.LogResponse(responseMessage);
                                rpcResponseMessage = responseMessage;
                            }
                        }
                    }
                }
            }
            catch (TaskCanceledException ex)
            {
                var exception = new RpcClientTimeoutException($"Rpc timeout after {ConnectionTimeout.TotalMilliseconds} milliseconds", ex);
                rpcLogger.LogException(exception);
                throw exception;
            }
            catch (Exception ex)
            {
                var unknownException = new RpcClientUnknownException("Error occurred when trying to send ipc requests(s)", ex);
                rpcLogger.LogException(unknownException);
                throw unknownException;
            }
            return(rpcResponseMessage);
        }
Ejemplo n.º 15
0
        private async Task RunAsync()
        {
            var host          = BuildServiceHost();
            var serverHandler = new StreamRpcServerHandler(host);
            var clientHandler = new StreamRpcClientHandler();
            var client        = new JsonRpcClient(clientHandler);

            using (var pipe = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous))
            {
                var connectTask = pipe.ConnectAsync();
                hostingClient = BuildHostingClient(client);
                serverHandler.DefaultFeatures.Set(this);
                var reader = new ByLineTextMessageReader(pipe)
                {
                    LeaveReaderOpen = true
                };
                var writer = new ByLineTextMessageWriter(pipe)
                {
                    LeaveWriterOpen = true
                };

                Ambient = new SandboxAmbient(hostingClient, SandboxId);

                await connectTask;
                using (reader)
                    using (writer)
                        using (serverHandler.Attach(reader, writer))
                            using (clientHandler.Attach(reader, writer))
                            {
                                // Started up
                                hostingClient.NotifyStarted();
                                // Wait for disposal
                                await disposalTcs.Task;
                            }
            }
            // Dispose
            if (_ClientModule != null)
            {
                if (_ClientModule is IDisposable d)
                {
                    d.Dispose();
                }
                _ClientModule = null;
            }
            // Final cleanup.
            // The owner will unload appdomain so a ThreadAbortException should be thrown here.
            hostCallback.NotifySandboxDisposed(SandboxId);
        }
Ejemplo n.º 16
0
        public async Task ConnectAsync(string pipeName)
        {
            if (_clientStream != null)
            {
                _clientStream.Close();
            }

            _pipeName = pipeName;

            var clientStream = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.Asynchronous, TokenImpersonationLevel.Impersonation);
            await clientStream.ConnectAsync();

            clientStream.ReadMode = PipeTransmissionMode.Message;
            _clientStream         = clientStream;
            RegisterForDisposal(clientStream);
        }
Ejemplo n.º 17
0
            async public Task SendAsync(Event e)
            {
                Debug.WriteLine("Event sent: {0}", (object)e.name);
                using (var pipe = new NamedPipeClientStream(".", "NextDNS", PipeDirection.Out, PipeOptions.None))
                {
                    await pipe.ConnectAsync(1000).ConfigureAwait(false);

                    var ms  = new MemoryStream();
                    var ser = new DataContractJsonSerializer(typeof(Event));
                    ser.WriteObject(ms, e);
                    ms.WriteByte(Convert.ToByte('\n'));
                    byte[] json = ms.ToArray();
                    ms.Close();
                    await pipe.WriteAsync(json, 0, json.Length).ConfigureAwait(false);
                }
            }
Ejemplo n.º 18
0
        public void SetAccessControl_NamedPipeStream()
        {
            string pipeName = GetUniquePipeName();
            var    server   = new NamedPipeServerStream(pipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
            var    client   = new NamedPipeClientStream(".", pipeName, PipeDirection.In, PipeOptions.Asynchronous);

            Task clientConnect = client.ConnectAsync();

            server.WaitForConnection();
            clientConnect.Wait();

            Assert.NotNull(server.GetAccessControl());
            server.SetAccessControl(new PipeSecurity());
            Assert.NotNull(client.GetAccessControl());
            client.SetAccessControl(new PipeSecurity());
        }
Ejemplo n.º 19
0
        protected override ServerClientPair CreateServerClientPair()
        {
            ServerClientPair ret      = new ServerClientPair();
            string           pipeName = GetUniquePipeName();
            var writeablePipe         = new NamedPipeServerStream(pipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
            var readablePipe          = new NamedPipeClientStream(".", pipeName, PipeDirection.In, PipeOptions.Asynchronous);

            Task clientConnect = readablePipe.ConnectAsync();

            writeablePipe.WaitForConnection();
            clientConnect.Wait();

            ret.readablePipe  = readablePipe;
            ret.writeablePipe = writeablePipe;
            return(ret);
        }
#pragma warning disable 1998 // Because in the NET451 code path, there's nothing to await
        public override async Task <Stream> Open(string address)
        {
            _namedPipeClientStream = new NamedPipeClientStream(
                ".",
                address,
                PipeDirection.InOut,
                PipeOptions.Asynchronous);

#if NET451
            _namedPipeClientStream.Connect();
#else
            await _namedPipeClientStream.ConnectAsync().ConfigureAwait(false);
#endif

            return(_namedPipeClientStream);
        }
Ejemplo n.º 21
0
        public static void OSX_BufferSizeNotSupported()
        {
            int    desiredBufferSize = 10;
            string pipeName          = GetUniquePipeName();

            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, desiredBufferSize, desiredBufferSize))
                using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.Out))
                {
                    Task clientConnect = client.ConnectAsync();
                    server.WaitForConnection();
                    clientConnect.Wait();

                    Assert.Throws <PlatformNotSupportedException>(() => server.InBufferSize);
                    Assert.Throws <PlatformNotSupportedException>(() => client.OutBufferSize);
                }
        }
Ejemplo n.º 22
0
        public async Task <bool> ConnectAsync(int timeout)
        {
            _namedPipeClient = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.Asynchronous);
            try
            {
                await _namedPipeClient.ConnectAsync(timeout);

                stream = _namedPipeClient;
                _timer.Start();
                return(true);
            }
            catch (TimeoutException)
            {
                return(false);
            }
        }
Ejemplo n.º 23
0
        public async ValueTask <Stream> ConnectAsync(SocketsHttpConnectionContext _,
                                                     CancellationToken cancellationToken = default)
        {
            var namedPipe = new NamedPipeClientStream(".", endPoint, PipeDirection.InOut, PipeOptions.Asynchronous,
                                                      TokenImpersonationLevel.Identification);

            try {
                await namedPipe.ConnectAsync(cancellationToken).ConfigureAwait(false);

                return(namedPipe);
            }
            catch {
                namedPipe.Dispose();
                throw;
            }
        }
        public void Subscribe(EventHandler <TResponse> value)
        {
            OnData += value;
            Task.Run(async() => {
                using NamedPipeClientStream stream = new NamedPipeClientStream(pipeName);
                using StreamReader reader          = new StreamReader(stream);
                using StreamWriter writer          = new StreamWriter(stream);

                await stream.ConnectAsync(5000, _externCancellationToken).ConfigureAwait(false);

                await writer.WriteLineAsync(request.ToJson()).ConfigureAwait(false);
                await writer.FlushAsync().ConfigureAwait(false);
                stream.WaitForPipeDrain();

                while (!_externCancellationToken.IsCancellationRequested && !unsubscribeToken.IsCancellationRequested)
                {
                    string responsJson             = await reader.ReadLineAsync().ConfigureAwait(false);
                    StreamlabsOBSResponse response = JsonConvert.DeserializeObject <StreamlabsOBSResponse>(responsJson);
                    response.JsonResponse          = responsJson;

                    if (response.Results.Value <string>("_type").Equals("SUBSCRIPTION"))
                    {
                        OnBegin?.Invoke(this, response);
                    }
                    else
                    if (response.Results.Value <string>("_type").Equals("EVENT"))
                    {
                        StreamlabsOBSEvent eventData = response.GetResultFirstOrDefault <StreamlabsOBSEvent>();

                        OnEvent?.Invoke(this, eventData);
                        if (typeof(TResponse).IsAssignableFrom(typeof(StreamlabsOBSEvent)))
                        {
                            OnData?.Invoke(this, eventData as TResponse);
                        }
                        else
                        {
                            OnData?.Invoke(this, eventData.GetDataFirstOrDefault <TResponse>());
                        }
                    }
                    else
                    {
                        OnUnsupported?.Invoke(this, responsJson);
                    }
                }
            },
                     _externCancellationToken);
        }
Ejemplo n.º 25
0
        public override async Task ConnectAsync(TimeSpan timeout = default)
        {
            timeout = timeout == default ? Timeout.InfiniteTimeSpan : timeout;
            _logger?.LogDebug($"Connecting to pipe '{_pipeName}' with timeout '{timeout}'.");
            var stream = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.Asynchronous,
                                                   _tokenImpersonationLevel);

            _channel = new NamedPipeTransportChannel(this, stream);
            await stream.ConnectAsync((int)timeout.TotalMilliseconds);

            _logger?.LogDebug($"Connected to pipe '{_pipeName}'. Starting message loop.");

            RegisterMessageCallback(_channel, HandleReceivedData, false);
            RunReaderLoop(_channel, () => OnDisconnected(new ChannelConnectedEventArgs <NamedPipeTransportChannel>(_channel)));

            _logger?.LogDebug($"Message loop running.");
        }
Ejemplo n.º 26
0
        protected override async Task <StreamPair> CreateConnectedStreamsAsync()
        {
            string name = FileSystemTest.GetNamedPipeServerStreamName();

            var server = new NamedPipeServerStream(name, PipeDirection.In);
            var client = new NamedPipeClientStream(".", name, PipeDirection.Out);

            await WhenAllOrAnyFailed(server.WaitForConnectionAsync(), client.ConnectAsync());

            var fs1 = new FileStream(new SafeFileHandle(server.SafePipeHandle.DangerousGetHandle(), true), FileAccess.Read);
            var fs2 = new FileStream(new SafeFileHandle(client.SafePipeHandle.DangerousGetHandle(), true), FileAccess.Write);

            server.SafePipeHandle.SetHandleAsInvalid();
            client.SafePipeHandle.SetHandleAsInvalid();

            return(fs1, fs2);
        }
Ejemplo n.º 27
0
        public async Task CreateConnection(string pipeName)
        {
            Logger?.LogDebug($"Attempting to connect to: {pipeName}");
            try
            {
                client = new NamedPipeClientStream(".", pipeName, PipeDirection.Out, PipeOptions.Asynchronous);
                //await client.ConnectAsync(30000);
                await client.ConnectAsync(30000).ConfigureAwait(false);

                stream = new StreamWriter(client);
                Logger?.LogDebug($"Connection established to: {pipeName}");
            }
            catch (Exception exception)
            {
                Logger?.LogError(exception.Message);
            }
        }
Ejemplo n.º 28
0
        public async Task InitializeCodeSearchServiceAsync()
        {
            if (_jsonRpc != null)
            {
                return;
            }

            string clientPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "AzDevOpsInteractiveClient.exe");

            string pipeName = $"AzDevOpsClientPipe-{Process.GetCurrentProcess().Id}";

            _clientProcess           = new Process();
            _clientProcess.StartInfo = new ProcessStartInfo(clientPath)
            {
                Arguments =
                    $@"--RootDir ""{_repoInfo.RootDir}"" " +
                    $@"--ProjectUri {_repoInfo.ProjectUri} " +
                    $@"--ProjectName ""{_repoInfo.ProjectName}"" " +
                    $@"--RepoName ""{_repoInfo.RepoName}"" " +
                    $@"--RpcPipeName ""{pipeName}"" ",
                UseShellExecute = false,
                CreateNoWindow  = true,
            };

            _logger.LogDebug($"FastCodeNav: Launching {clientPath} with arguments '{_clientProcess.StartInfo.Arguments}'");
            if (!_clientProcess.Start())
            {
                _logger.LogError($"FastCodeNav: Failed to launch {clientPath}");
                return;
            }

            _logger.LogDebug($"FastCodeNav: Connecting to search service client with PID {_clientProcess.Id}");
            var stream = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous);
            await stream.ConnectAsync();

            _logger.LogDebug($"FastCodeNav: Connected to search service client.");

            var jsonRpc      = new JsonRpc(stream);
            var jsonRpcProxy = jsonRpc.Attach <ICodeSearchService>();

            jsonRpc.StartListening();
            _jsonRpc = jsonRpc;

            _logger.LogDebug($"FastCodeNav: Issuing a warmup RPC request");
            _jsonRpc.InvokeAsync("WarmUpAsync").FireAndForget(_logger);
        }
        protected override async Task <IDuplexPipe> ConnectPipelineAsync(int sendMaxMessageSize, int receiveMaxMessageSize, CancellationToken cancellationToken)
        {
            // TODO: The URL should be parsed in RpConnectionInfo constructor .
            // If invalid an ArgumentException should be thrown there.

            if (this.ConnectionInfo.HostUrl is Uri url)
            {
#pragma warning disable CA2000 // Dispose objects before losing scope
                string pipeName = PipeUri.LookupPipeName(url);
                if (string.IsNullOrEmpty(pipeName))
                {
                    throw new RpcCommunicationException(RpcCommunicationStatus.Unavailable, $"Failed to connect to named pipe at '{url}'");
                }

                NamedPipeClientStream?pipeClientStream = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, System.IO.Pipes.PipeOptions.Asynchronous);

                try
                {
                    await pipeClientStream.ConnectAsync(cancellationToken).ContextFree();

                    var sendOptions = new System.IO.Pipelines.PipeOptions(
                        pauseWriterThreshold: sendMaxMessageSize * 2, resumeWriterThreshold: sendMaxMessageSize,
                        readerScheduler: System.IO.Pipelines.PipeScheduler.Inline,
                        useSynchronizationContext: false);
                    var receiveOptions = new System.IO.Pipelines.PipeOptions(
                        pauseWriterThreshold: receiveMaxMessageSize * 2, resumeWriterThreshold: receiveMaxMessageSize,
                        readerScheduler: System.IO.Pipelines.PipeScheduler.Inline,
                        useSynchronizationContext: false);

                    var connection = new StreamDuplexPipe(pipeClientStream); //, sendOptions, receiveOptions);

                    pipeClientStream = null;                                 // Prevent disposal

                    return(connection);
                }
                finally
                {
                    pipeClientStream?.Dispose();
                }
#pragma warning restore CA2000 // Dispose objects before losing scope
            }
            else
            {
                throw new InvalidOperationException("Missing connection URL.");
            }
        }
Ejemplo n.º 30
0
        private async Task Connect(ApiClient <T> oldApi = null)
        {
            pipe = new NamedPipeClientStream(ServerName, PipeName, PipeDirection.InOut, PipeOptions.Asynchronous);
            await pipe.ConnectAsync(cancellationToken.Token);

            if (cancellationToken.IsCancellationRequested)
            {
                return;
            }
            client = new ApiClient <T>(pipe, pipe, oldApi);
            client.Disconnected += Client_Disconnected;
            if (oldApi == null)
            {
                SetupApi?.Invoke(client.Api);
            }
            client.Start();
        }
Ejemplo n.º 31
0
        public async Task Connect(TimeSpan timeout)
        {
            var stream = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.Asynchronous);

            try
            {
                await stream.ConnectAsync((int)timeout.TotalMilliseconds).ConfigureAwait(false);
            }
            catch
            {
                stream.Dispose();
                throw;
            }

            _stream = stream;
            _rpc    = JsonRpc.Attach(stream, this);
        }
Ejemplo n.º 32
0
        private static async Task RunAsync(string[] args, CancellationToken token, ManualResetEvent mre)
        {
            try
            {
                using (var pipeStream = new NamedPipeClientStream(".", Constants.PipeName, PipeDirection.InOut, PipeOptions.Asynchronous))
                {
                    await pipeStream.ConnectAsync(token).ConfigureAwait(true);

                    Console.WriteLine("Connected to server; writing args.");

                    using (var reader = new StreamReader(pipeStream))
                        using (var writer = new StreamWriter(pipeStream))
                        {
                            writer.WriteLine("Client Args (ProcessId = {0}):", System.Diagnostics.Process.GetCurrentProcess().Id);

                            for (var i = 0; i < args.Length; i++)
                            {
                                var arg = args[i];
                                writer.WriteLine("\targs[{0}] = {1}", i, arg);
                            }

                            writer.WriteLine();

                            await writer.FlushAsync().ConfigureAwait(true);

                            Console.WriteLine("Reading full arg set.");

                            while (!reader.EndOfStream)
                            {
                                var line = reader.ReadLine();

                                if (line == string.Empty)
                                {
                                    break;
                                }

                                Console.WriteLine(line);
                            }
                        }
                }
            }
            finally
            {
                mre.Set();
            }
        }
Ejemplo n.º 33
0
        public override async Task <Kernel> CreateKernelAsync(NamedPipeConnectionOptions options, KernelInvocationContext context)
        {
            var clientStream = new NamedPipeClientStream(
                ".",
                options.PipeName,
                PipeDirection.InOut,
                PipeOptions.Asynchronous, TokenImpersonationLevel.Impersonation);

            await clientStream.ConnectAsync();

            clientStream.ReadMode = PipeTransmissionMode.Message;


            var proxyKernel = CreateProxyKernel(options, clientStream);

            return(proxyKernel);
        }
        private static void PingPong_OtherProcess(string inName, string outName)
        {
            // Create pipes with the supplied names
            using (var inbound = new NamedPipeClientStream(".", inName, PipeDirection.In))
                using (var outbound = new NamedPipeServerStream(outName, PipeDirection.Out))
                {
                    // Wait for the connections to be established
                    Task.WaitAll(inbound.ConnectAsync(), outbound.WaitForConnectionAsync());

                    // Repeatedly read then write bytes from and to the other process
                    for (int i = 0; i < 10; i++)
                    {
                        int b = inbound.ReadByte();
                        outbound.WriteByte((byte)b);
                    }
                }
        }
Ejemplo n.º 35
0
        public static async Task ServerDisconnectedPipeThrows()
        {
            using (NamedPipeServerStream server = new NamedPipeServerStream("testServer3", PipeDirection.In))
                using (NamedPipeClientStream client = new NamedPipeClientStream(".", "testServer3", PipeDirection.Out))
                {
                    byte[] buffer = new byte[] { 0, 0, 0, 0 };

                    Task clientConnect1 = client.ConnectAsync();
                    server.WaitForConnection();
                    await clientConnect1;

                    Assert.True(client.IsConnected);
                    Assert.True(server.IsConnected);

                    server.Dispose();

                    Assert.Throws <IOException>(() => client.Write(buffer, 0, buffer.Length));
                    Assert.Throws <IOException>(() => client.WriteByte(123));
                    Assert.Throws <IOException>(() => client.Flush());
                }

            if (Interop.IsWindows) // Unix implementation of InOut doesn't fail on server.Write/Read when client disconnects due to allowing for additional connections
            {
                using (NamedPipeServerStream server = new NamedPipeServerStream("testServer3", PipeDirection.InOut))
                    using (NamedPipeClientStream client = new NamedPipeClientStream("testServer3"))
                    {
                        byte[] buffer = new byte[] { 0, 0, 0, 0 };

                        Task clientConnect1 = client.ConnectAsync();
                        server.WaitForConnection();
                        await clientConnect1;

                        Assert.True(client.IsConnected);
                        Assert.True(server.IsConnected);

                        server.Dispose();

                        Assert.Throws <IOException>(() => client.Write(buffer, 0, buffer.Length));
                        Assert.Throws <IOException>(() => client.WriteByte(123));
                        Assert.Throws <IOException>(() => client.Flush());
                        int length = client.Read(buffer, 0, buffer.Length);
                        Assert.Equal(0, length);
                        int byt = client.ReadByte();
                    }
            }
        }
Ejemplo n.º 36
0
        private static int PingPong_OtherProcess(string inName, string outName)
        {
            // Create pipes with the supplied names
            using (var inbound = new NamedPipeClientStream(".", inName, PipeDirection.In))
            using (var outbound = new NamedPipeServerStream(outName, PipeDirection.Out))
            {
                // Wait for the connections to be established
                Task.WaitAll(inbound.ConnectAsync(), outbound.WaitForConnectionAsync());

                // Repeatedly read then write bytes from and to the other process
                for (int i = 0; i < 10; i++)
                {
                    int b = inbound.ReadByte();
                    outbound.WriteByte((byte)b);
                }
            }
            return SuccessExitCode;
        }
        public async Task <Stream> GetBidirectionalStreamAsync(CancellationToken token)
        {
            NamedPipeClientStream pipeStream = null;

            try
            {
                pipeStream = new NamedPipeClientStream(_serverName, _pipeName, PipeDirection.InOut, _pipeOptions);
                await pipeStream.ConnectAsync(_timeoutMs, token).ConfigureAwait(false);

                return(pipeStream);
            }
            catch (Exception ex)
            {
                Log.Error(ex, "There was a problem connecting to the named pipe");
                pipeStream?.Dispose();
                throw;
            }
        }
        public void GetAccessControl_NamedPipeServerStream_Broken()
        {
            string pipeName = GetUniquePipeName();
            var server = new NamedPipeServerStream(pipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
            var client = new NamedPipeClientStream(".", pipeName, PipeDirection.In, PipeOptions.Asynchronous);

            Task clientConnect = client.ConnectAsync();
            server.WaitForConnection();
            clientConnect.Wait();

            Assert.NotNull(server.GetAccessControl());
            server.SetAccessControl(new PipeSecurity());
            Assert.NotNull(client.GetAccessControl());
            client.SetAccessControl(new PipeSecurity());

            client.Dispose();
            Assert.Throws<IOException>(() => server.Write(new byte[] { 0 }, 0, 1)); // Sets the servers PipeState to Broken
            server.SetAccessControl(new PipeSecurity());
        }
Ejemplo n.º 39
0
        public void PingPong_Sync()
        {
            // Create names for two pipes
            string outName = Path.GetRandomFileName();
            string inName = Path.GetRandomFileName();

            // Create the two named pipes, one for each direction, then create
            // another process with which to communicate
            using (var outbound = new NamedPipeServerStream(outName, PipeDirection.Out))
            using (var inbound = new NamedPipeClientStream(".", inName, PipeDirection.In))
            using (RemoteInvoke(PingPong_OtherProcess, outName, inName))
            {
                // Wait for both pipes to be connected
                Task.WaitAll(outbound.WaitForConnectionAsync(), inbound.ConnectAsync());

                // Repeatedly write then read a byte to and from the other process
                for (byte i = 0; i < 10; i++)
                {
                    outbound.WriteByte(i);
                    int received = inbound.ReadByte();
                    Assert.Equal(i, received);
                }
            }
        }
Ejemplo n.º 40
0
        public static async Task ClientTryConnectedThrows()
        {
            using (NamedPipeClientStream client = new NamedPipeClientStream(".", "notthere"))
            {
                var ctx = new CancellationTokenSource();

                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - Unix implementation currently ignores timeout and cancellation token once the operation has been initiated
                {
                    Assert.Throws<TimeoutException>(() => client.Connect(60));  // 60 to be over internal 50 interval
                    await Assert.ThrowsAsync<TimeoutException>(() => client.ConnectAsync(50));
                    await Assert.ThrowsAsync<TimeoutException>(() => client.ConnectAsync(60, ctx.Token));

                    Task clientConnectToken = client.ConnectAsync(ctx.Token);
                    ctx.Cancel();
                    await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientConnectToken);
                }

                ctx.Cancel();
                await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.ConnectAsync(ctx.Token));
            }
        }
Ejemplo n.º 41
0
        public static void OSX_BufferSizeNotSupported()
        {
            int desiredBufferSize = 10;
            string pipeName = GetUniquePipeName();
            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, desiredBufferSize, desiredBufferSize))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.Out))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                Assert.Throws<PlatformNotSupportedException>(() => server.InBufferSize);
                Assert.Throws<PlatformNotSupportedException>(() => client.OutBufferSize);
            }
        }
Ejemplo n.º 42
0
        public void Unix_MultipleServerDisposal_DoesntDeletePipe()
        {
            // Test for when multiple servers are created and linked to the same FIFO. The original ServerStream
            // that created the FIFO is disposed. The other servers should still be valid and useable.
            string serverName = GetUniquePipeName();

            var server1 = new NamedPipeServerStream(serverName, PipeDirection.In); // Creates the FIFO
            var server2 = new NamedPipeServerStream(serverName, PipeDirection.In);
            var client1 = new NamedPipeClientStream(".", serverName, PipeDirection.Out);
            var client2 = new NamedPipeClientStream(".", serverName, PipeDirection.Out);

            Task server1Task = server1.WaitForConnectionAsync(); // Opens a handle to the FIFO
            Task server2Task = server2.WaitForConnectionAsync(); // Opens a handle to the same FIFO as server1

            Task client1Task = client1.ConnectAsync();
            Task.WaitAll(server1Task, server2Task, client1Task); // client1 connects to server1 AND server2

            Assert.True(server1.IsConnected);
            Assert.True(server2.IsConnected);

            // Get rid of client1/server1 and make sure server2 isn't connected (so that it can connect to client2)
            server1.Dispose();
            client1.Dispose();
            server2.Disconnect();
            Assert.False(server2.IsConnected);

            server2Task = server2.WaitForConnectionAsync(); // Opens a handle to the same FIFO
            Task client2Task = client2.ConnectAsync(); 
            Task.WaitAll(server2Task, client2Task); // Should not block!
            Assert.True(server2.IsConnected);
        }
Ejemplo n.º 43
0
        public static void ClientUnsupportedOperationThrows()
        {
            using (NamedPipeServerStream server = new NamedPipeServerStream("unique4", PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (NamedPipeClientStream client = new NamedPipeClientStream(".", "unique4", PipeDirection.Out))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                ConnectedPipeUnsupportedOperationThrows(client);
            }
        }
Ejemplo n.º 44
0
        public static async Task ClientAllReadyConnectedThrows()
        {
            using (NamedPipeServerStream server = new NamedPipeServerStream("testServer1", PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (NamedPipeClientStream client = new NamedPipeClientStream(".", "testServer1", PipeDirection.InOut, PipeOptions.Asynchronous))
            {
                byte[] buffer = new byte[] { 0, 0, 0, 0 };

                Task clientConnect1 = client.ConnectAsync();
                server.WaitForConnection();
                await clientConnect1;

                Assert.True(client.IsConnected);
                Assert.True(server.IsConnected);

                Assert.Throws<InvalidOperationException>(() => client.Connect());

                var ctx = new CancellationTokenSource();
                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - the cancellation token is ignored after the operation is initiated, due to base Stream's implementation
                {
                    Task clientReadToken = client.ReadAsync(buffer, 0, buffer.Length, ctx.Token);
                    ctx.Cancel();
                    await Assert.ThrowsAnyAsync<OperationCanceledException>(() => clientReadToken);
                }
                ctx.Cancel();
                Assert.True(client.ReadAsync(buffer, 0, buffer.Length, ctx.Token).IsCanceled);

                var ctx1 = new CancellationTokenSource();
                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // [ActiveIssue(812, PlatformID.AnyUnix)] - the cancellation token is ignored after the operation is initiated, due to base Stream's implementation
                {
                    Task serverReadToken = server.ReadAsync(buffer, 0, buffer.Length, ctx1.Token);
                    ctx1.Cancel();
                    await Assert.ThrowsAnyAsync<OperationCanceledException>(() => serverReadToken);
                }
                ctx1.Cancel();
                Assert.True(server.ReadAsync(buffer, 0, buffer.Length, ctx1.Token).IsCanceled);
            }
        }
Ejemplo n.º 45
0
        public static async Task ServerDisconnectedPipeThrows()
        {
            using (NamedPipeServerStream server = new NamedPipeServerStream("testServer3", PipeDirection.In))
            using (NamedPipeClientStream client = new NamedPipeClientStream(".", "testServer3", PipeDirection.Out))
            {
                byte[] buffer = new byte[] { 0, 0, 0, 0 };

                Task clientConnect1 = client.ConnectAsync();
                server.WaitForConnection();
                await clientConnect1;

                Assert.True(client.IsConnected);
                Assert.True(server.IsConnected);

                server.Dispose();

                Assert.Throws<IOException>(() => client.Write(buffer, 0, buffer.Length));
                Assert.Throws<IOException>(() => client.WriteByte(123));
                Assert.Throws<IOException>(() => client.Flush());
            }

            if (Interop.IsWindows) // Unix implementation of InOut doesn't fail on server.Write/Read when client disconnects due to allowing for additional connections
            {
                using (NamedPipeServerStream server = new NamedPipeServerStream("testServer3", PipeDirection.InOut))
                using (NamedPipeClientStream client = new NamedPipeClientStream("testServer3"))
                {
                    byte[] buffer = new byte[] { 0, 0, 0, 0 };

                    Task clientConnect1 = client.ConnectAsync();
                    server.WaitForConnection();
                    await clientConnect1;

                    Assert.True(client.IsConnected);
                    Assert.True(server.IsConnected);

                    server.Dispose();

                    Assert.Throws<IOException>(() => client.Write(buffer, 0, buffer.Length));
                    Assert.Throws<IOException>(() => client.WriteByte(123));
                    Assert.Throws<IOException>(() => client.Flush());
                    int length = client.Read(buffer, 0, buffer.Length);
                    Assert.Equal(0, length);
                    int byt = client.ReadByte();
                }
            }

        }
Ejemplo n.º 46
0
        public void InvalidReadMode_Throws_ArgumentOutOfRangeException(PipeDirection serverDirection, PipeDirection clientDirection)
        {
            string pipeName = GetUniquePipeName();
            using (var server = new NamedPipeServerStream(pipeName, serverDirection, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (var client = new NamedPipeClientStream(".", pipeName, clientDirection))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                Assert.Throws<ArgumentOutOfRangeException>(() => server.ReadMode = (PipeTransmissionMode)999);
                Assert.Throws<ArgumentOutOfRangeException>(() => client.ReadMode = (PipeTransmissionMode)999);
            }
        }
Ejemplo n.º 47
0
        public static async Task ServerDisconnectedPipeThrows()
        {
            using (NamedPipeServerStream server = new NamedPipeServerStream("testServer3", PipeDirection.In))
            using (NamedPipeClientStream client = new NamedPipeClientStream(".", "testServer3", PipeDirection.Out))
            {
                byte[] buffer = new byte[] { 0, 0, 0, 0 };

                Task clientConnect1 = client.ConnectAsync();
                server.WaitForConnection();
                await clientConnect1;

                Assert.True(client.IsConnected);
                Assert.True(server.IsConnected);

                server.Dispose();

                OtherSidePipeDisconnectWriteThrows(client);
            }

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // Unix implementation of InOut doesn't fail on server.Write/Read when client disconnects due to allowing for additional connections
            {
                using (NamedPipeServerStream server = new NamedPipeServerStream("testServer3", PipeDirection.InOut))
                using (NamedPipeClientStream client = new NamedPipeClientStream("testServer3"))
                {
                    byte[] buffer = new byte[] { 0, 0, 0, 0 };

                    Task clientConnect1 = client.ConnectAsync();
                    server.WaitForConnection();
                    await clientConnect1;

                    Assert.True(client.IsConnected);
                    Assert.True(server.IsConnected);

                    server.Dispose();

                    OtherSidePipeDisconnectWriteThrows(client);
                    OtherSidePipeDisconnectVerifyRead(client);
                }
            }
        }
Ejemplo n.º 48
0
        public static async Task ServerAfterDisconnectThrows()
        {
            using (NamedPipeServerStream server = new NamedPipeServerStream("unique3", PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (NamedPipeClientStream client = new NamedPipeClientStream(".", "unique3", PipeDirection.In))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                await clientConnect;

                Assert.Throws<InvalidOperationException>(() => server.IsMessageComplete);
                Assert.Throws<InvalidOperationException>(() => server.WaitForConnection());
                await Assert.ThrowsAsync<InvalidOperationException>(() => server.WaitForConnectionAsync());

                server.Disconnect();

                Assert.Throws<InvalidOperationException>(() => server.Disconnect());    // double disconnect

                AfterDisconnectWriteOnlyPipeThrows(server);
            }

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) // on Unix, InOut doesn't result in the same Disconnect-based errors due to allowing for other connections
            {
                using (NamedPipeServerStream server = new NamedPipeServerStream("unique3", PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
                using (NamedPipeClientStream client = new NamedPipeClientStream("unique3"))
                {
                    Task clientConnect = client.ConnectAsync();
                    server.WaitForConnection();
                    await clientConnect;

                    Assert.Throws<InvalidOperationException>(() => server.IsMessageComplete);
                    Assert.Throws<InvalidOperationException>(() => server.WaitForConnection());
                    await Assert.ThrowsAsync<InvalidOperationException>(() => server.WaitForConnectionAsync());

                    server.Disconnect();

                    Assert.Throws<InvalidOperationException>(() => server.Disconnect());    // double disconnect

                    AfterDisconnectReadWritePipeThrows(server);
                }
            }
        }
Ejemplo n.º 49
0
 public static void ClientConnectTimeoutThrows()
 {
     using (NamedPipeClientStream client = new NamedPipeClientStream("client1"))
     {
         Assert.Throws<ArgumentOutOfRangeException>(() => client.Connect(-111));
         Assert.Throws<ArgumentOutOfRangeException>(() => NotReachable(client.ConnectAsync(-111)));
     }
 }
Ejemplo n.º 50
0
        [PlatformSpecific(PlatformID.Windows)] // Unix doesn't currently support message mode
        public void Windows_SetReadModeTo__PipeTransmissionModeByte()
        {
            string pipeName = GetUniquePipeName();
            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.Out))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                // Throws regardless of connection status for the pipe that is set to PipeDirection.In
                Assert.Throws<UnauthorizedAccessException>(() => server.ReadMode = PipeTransmissionMode.Byte);
                client.ReadMode = PipeTransmissionMode.Byte;
            }

            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.In))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                // Throws regardless of connection status for the pipe that is set to PipeDirection.In
                Assert.Throws<UnauthorizedAccessException>(() => client.ReadMode = PipeTransmissionMode.Byte);
                server.ReadMode = PipeTransmissionMode.Byte;
            }

            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                server.ReadMode = PipeTransmissionMode.Byte;
                client.ReadMode = PipeTransmissionMode.Byte;
            }
        }
Ejemplo n.º 51
0
        public static void Unix_BufferSizeRoundtripping(PipeDirection direction)
        {
            int desiredBufferSize = 0;
            string pipeName = GetUniquePipeName();
            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, desiredBufferSize, desiredBufferSize))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                desiredBufferSize = server.OutBufferSize * 2;
            }

            using (var server = new NamedPipeServerStream(pipeName, direction, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, desiredBufferSize, desiredBufferSize))
            using (var client = new NamedPipeClientStream(".", pipeName, direction == PipeDirection.In ? PipeDirection.Out : PipeDirection.In))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                if ((direction & PipeDirection.Out) != 0)
                {
                    Assert.InRange(server.OutBufferSize, desiredBufferSize, int.MaxValue);
                }

                if ((direction & PipeDirection.In) != 0)
                {
                    Assert.InRange(server.InBufferSize, desiredBufferSize, int.MaxValue);
                }
            }
        }
Ejemplo n.º 52
0
        public void Unix_SetReadModeTo__PipeTransmissionModeByte()
        {
            string pipeName = GetUniquePipeName();
            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.Out))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                server.ReadMode = PipeTransmissionMode.Byte;
                client.ReadMode = PipeTransmissionMode.Byte;
            }

            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.In))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                client.ReadMode = PipeTransmissionMode.Byte;
                server.ReadMode = PipeTransmissionMode.Byte;
            }

            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                server.ReadMode = PipeTransmissionMode.Byte;
                client.ReadMode = PipeTransmissionMode.Byte;
            }
        }
Ejemplo n.º 53
0
        public static void Windows_BufferSizeRoundtripping()
        {
            int desiredBufferSize = 10;
            string pipeName = GetUniquePipeName();
            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.Out, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, desiredBufferSize, desiredBufferSize))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.In))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                Assert.Equal(desiredBufferSize, server.OutBufferSize);
                Assert.Equal(desiredBufferSize, client.InBufferSize);
            }

            using (var server = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, desiredBufferSize, desiredBufferSize))
            using (var client = new NamedPipeClientStream(".", pipeName, PipeDirection.Out))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                Assert.Equal(desiredBufferSize, server.InBufferSize);
                Assert.Equal(0, client.OutBufferSize);
            }
        }
Ejemplo n.º 54
0
        public static void ServerReadOnlyThrows()
        {
            using (NamedPipeServerStream server = new NamedPipeServerStream("unique3", PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
            using (NamedPipeClientStream client = new NamedPipeClientStream(".", "unique3", PipeDirection.Out))
            {
                Task clientConnect = client.ConnectAsync();
                server.WaitForConnection();
                clientConnect.Wait();

                ConnectedPipeReadOnlyThrows(server);
            }
        }