public void Stop() { m_Server.WaitForPipeDrain(); m_Server.Close(); m_Client.Close(); m_Client.Dispose(); m_Client = null; m_Server.Dispose(); m_Server = null; }
public void Close() { if (!_disposed) { lock (this) if (!_disposed) { _server.WaitForPipeDrain(); _server.Dispose(); _client.Dispose(); _disposed = true; } } }
private void SignalConsensusServerShutdown() { if (Interlocked.Exchange(ref _consensusServerStopped, 1) == 0) { _outPipe.Dispose(); } }
private void Dispose(bool disposing) { if (!_isDisposed) { lock (_sync) { if (!_isDisposed) { _isDisposed = true; _timer.Change(Timeout.Infinite, Timeout.Infinite); _timer.Dispose(); flush(null); try { SetStdHandle(STD_OUTPUT_HANDLE, _stdout); } catch (Exception) { } _outClient.Dispose(); _outServer.Dispose(); if (_forceConsoleRedirection) { ResetConsoleOutStream(); //Calls to Console.Write/WriteLine will now get redirected to the original stdout stream } } } } }
public void Dispose() { _OutPipe.Dispose(); _TarStream.Dispose(); _LogStream?.Close(); _LogStream = null; }
// ReSharper disable InconsistentNaming // ReSharper disable UnusedParameter.Local // ReSharper disable EmptyGeneralCatchClause private void Dispose(bool disposing) { if (!_isDisposed) { lock (_sync) { if (!_isDisposed) { _isDisposed = true; _timer.Change(Timeout.Infinite, Timeout.Infinite); _timer.Dispose(); flush(null); try { SetStdHandle(STD_OUTPUT_HANDLE, _stdout); } catch (Exception) { } _outClient.Dispose(); _outServer.Dispose(); try { SetStdHandle(STD_ERROR_HANDLE, _stderr); } catch (Exception) { } _errClient.Dispose(); _errServer.Dispose(); } } } }
public async Task AnonymousPipeViaFileStream_AllDataCopied(int writeSize, int numWrites) { long totalLength = writeSize * numWrites; var expectedData = new byte[totalLength]; new Random(42).NextBytes(expectedData); var results = new MemoryStream(); using (var server = new AnonymousPipeServerStream(PipeDirection.Out)) { Task serverTask = Task.Run(async() => { for (int i = 0; i < numWrites; i++) { await server.WriteAsync(expectedData, i * writeSize, writeSize); } }); using (var client = new FileStream(new SafeFileHandle(server.ClientSafePipeHandle.DangerousGetHandle(), false), FileAccess.Read, bufferSize: 3)) { Task copyTask = client.CopyToAsync(results, writeSize); await await Task.WhenAny(serverTask, copyTask); server.Dispose(); await copyTask; } } byte[] actualData = results.ToArray(); Assert.Equal(expectedData.Length, actualData.Length); Assert.Equal <byte>(expectedData, actualData); }
public void ServerClosesPipe_ClientReceivesEof() { using (var pipe = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable)) using (var remote = RemoteExecutor.Invoke(new Action <string>(ChildFunc), pipe.GetClientHandleAsString())) { pipe.DisposeLocalCopyOfClientHandle(); pipe.Write(new byte[] { 1, 2, 3, 4, 5 }, 0, 5); pipe.Dispose(); Assert.True(remote.Process.WaitForExit(30_000)); } void ChildFunc(string clientHandle) { using (var pipe = new AnonymousPipeClientStream(PipeDirection.In, clientHandle)) { for (int i = 1; i <= 5; i++) { Assert.Equal(i, pipe.ReadByte()); } Assert.Equal(-1, pipe.ReadByte()); } } }
public void Dispose() { _streamIn.Dispose(); _streamOut.Dispose(); _pipeIn.Dispose(); _pipeOut.Dispose(); _coreProcess.WaitForExit(EXIT_MAXWAIT); }
/// <summary> /// Waits for the termination of the internal thread and closes the pipe. /// Even if this can be called immediately, you should first call <see cref="WaitEnd(bool)"/> /// before calling Dispose. /// </summary> public void Dispose() { if (_endFlag == LogReceiverEndStatus.None) { _thread.Join(); } _reader.Dispose(); _server.Dispose(); }
public void Dispose() { Logger.LogInfo($"Server {PipeReadHandle}-{PipeWriteHandle} disposing"); _workProcess?.Close(); _ewh.Dispose(); _pipeRead?.Dispose(); _pipeWrite.Dispose(); Logger.Flush(); }
public static void ServerWriteOnlyDisconnectedPipeThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle)) { server.Dispose(); OtherSidePipeDisconnectVerifyRead(client); } }
private void Dispose(bool disposing) { if (disposing) { _inServer?.Dispose(); _outServer?.Dispose(); _inClient?.Dispose(); _outClient?.Dispose(); } }
/// <summary> /// Erzeugt eine neue Implementierung. /// </summary> internal OutOfProcessCardServer() { // Streams to use AnonymousPipeServerStream writer = null, reader = null; try { // Create streams writer = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable); reader = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable); // Create start information ProcessStartInfo info = new ProcessStartInfo(); // Configure info.Arguments = string.Format("\"{0}\" \"{1}\"", writer.GetClientHandleAsString().Replace("\"", "\"\""), reader.GetClientHandleAsString().Replace("\"", "\"\"")); info.FileName = Path.Combine(RunTimeLoader.ServerDirectory.FullName, "JMS.DVB.CardServer.exe"); info.UseShellExecute = false; info.LoadUserProfile = true; // With cleanup try { // Create the process Process.Start(info); } finally { // Destroy temporary data writer.DisposeLocalCopyOfClientHandle(); reader.DisposeLocalCopyOfClientHandle(); } // Remember m_RequestStream = writer; m_ResponseStream = reader; // Avoid cleanup writer = null; reader = null; } finally { // Cleanup all if (null != writer) { writer.Dispose(); } if (null != reader) { reader.Dispose(); } } }
/// <summary> /// Cleans up resources. /// </summary> public void Dispose() { if (childProcess != null) { childProcess.Dispose(); childProcess = null; inPipe.Dispose(); inPipe = null; outPipe.Dispose(); outPipe = null; } }
public void KillTestRunner() { try { _runnerProcess.Kill(); runnerStreamIn.Dispose(); runnerStreamOut.Dispose(); _runnerPipeIn.Dispose(); _runnerPipeOut.Dispose(); } catch { } }
override public void Dispose() { base.Dispose(); PipeToClient.Dispose(); PipeFromClient.Dispose(); try { Client.Kill(); } catch (Exception) { // don't care } Client.Close(); }
public void Dispose() { if (!_disposed) { lock (this) if (!_disposed) { _server.Dispose(); _client.Dispose(); _disposed = true; } } }
public void Dispose() { CommandExchanger.SendData(_streamCmd, CommandExchanger.Commands.STOP); _streamIn.Dispose(); _streamOut.Dispose(); _streamCmd.Dispose(); _pipeIn.Dispose(); _pipeOut.Dispose(); _pipeCmd.Dispose(); _coreProcess.WaitForExit(EXIT_MAXWAIT); }
/// <summary> /// Beendet die Nutzung dieser Instanz endgültig. /// </summary> protected override void OnDispose() { // Forward to base base.OnDispose(); // Check streams if (null != m_ResponseStream) { try { // Forward m_ResponseStream.Dispose(); } catch { // Ignore any error } finally { // Forget m_ResponseStream = null; } } if (null != m_RequestStream) { try { // Forward m_RequestStream.Dispose(); } catch { // Ignore any error } finally { // Forget m_RequestStream = null; } } // Wait for thread to finish if (null != m_Worker) { // Synchronize m_Worker.Join(); // Forget m_Worker = null; } }
private static void Exit(object sender, EventArgs e) { sw.WriteLine("TERMINATED"); sw?.Close(); serverStream?.Dispose(); chooser.KinectChanged -= KinectUpdate; chooser?.Stop(); beatSaber?.Dispose(); if (sensor != null) { sensor.SkeletonFrameReady -= SkeletonFrameReady; sensor.Stop(); } }
public void StartSessionMuter(uint sessId) { // test if we already have the session data if (_MuterSessions.ContainsKey(sessId)) { var pipes = _MuterSessions[sessId]; // ensure the pipe is working try { pipes.Item1.WriteByte((byte)SessionMuter.Commands.PING); pipes.Item2.ReadByte(); // do nothing if success return; } catch (Exception) { // very likely broken pipe. erase this pipe and create new child. CloseSessionMuter(sessId); } } // create new anon pipes AnonymousPipeServerStream pipeServerOut = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable); AnonymousPipeServerStream pipeServerIn = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable); // open process bool success = false; try { success = SpawnInSession.StartProcessInSession(Assembly.GetExecutingAssembly().Location, sessId, $"ProcessName.exe startsessionmuter {Process.GetCurrentProcess().Id} {pipeServerOut.GetClientHandleAsString()} {pipeServerIn.GetClientHandleAsString()}"); } catch (Exception) { success = false; } pipeServerIn.DisposeLocalCopyOfClientHandle(); pipeServerOut.DisposeLocalCopyOfClientHandle(); if (success) { _MuterSessions[sessId] = new Tuple <PipeStream, PipeStream>(pipeServerOut, pipeServerIn); } else { pipeServerOut.Dispose(); pipeServerIn.Dispose(); } }
public void Dispose() { isDisposed = true; Core.LoggingService.Debug("Telling worker process to exit"); hostToWorkerPipe.Dispose(); // send "end-of-stream" to worker if (Thread.CurrentThread != readerThread) { // don't deadlock when disposing from within ReaderThread event Core.LoggingService.Debug("Waiting for thread-join"); if (!readerThread.Join(3000)) { Core.LoggingService.Debug("Thread-join failed. Killing worker process."); Kill(); Core.LoggingService.Debug("Waiting for thread-join"); readerThread.Join(); } Core.LoggingService.Debug("Joined!"); } workerToHostPipe.Dispose(); process.Dispose(); }
private bool WaitForConnectionFromProcess(AnonymousPipeServerStream clientToServerStream, AnonymousPipeServerStream serverToClientStream, int nodeProcessId, long hostHandshake, long clientHandshake) { try { CommunicationsUtilities.Trace("Attempting to handshake with PID {0}", nodeProcessId); CommunicationsUtilities.Trace("Writing handshake to pipe"); serverToClientStream.WriteLongForHandshake(hostHandshake); CommunicationsUtilities.Trace("Reading handshake from pipe"); long handshake = clientToServerStream.ReadLongForHandshake(); if (handshake != clientHandshake) { CommunicationsUtilities.Trace("Handshake failed. Received {0} from client not {1}. Probably the client is a different MSBuild build.", handshake, clientHandshake); throw new InvalidOperationException(); } // We got a connection. CommunicationsUtilities.Trace("Successfully connected got connection from PID {0}...!", nodeProcessId); return(true); } catch (Exception ex) { if (ExceptionHandling.IsCriticalException(ex)) { throw; } CommunicationsUtilities.Trace("Failed to get connection from PID {0}. {1}", nodeProcessId, ex.ToString()); clientToServerStream.Dispose(); serverToClientStream.Dispose(); return(false); } }
public void StartListeningOn(params string[] prefixes) { if (!HttpListener.IsSupported) { Console.WriteLine("Windows XP SP2 or Server 2003 is required to use the HttpListener class."); return; } // URI prefixes are required, // for example "http://contoso.com:8080/index/". if (prefixes == null || prefixes.Length == 0) { throw new ArgumentException("prefixes"); } // Create a listener. HttpListener listener = new HttpListener(); // Add the prefixes. foreach (string s in prefixes) { listener.Prefixes.Add(s); } listener.Start(); while (true) { Console.WriteLine("Listening..."); // Note: The GetContext method blocks while waiting for a request. var context = listener.GetContext(); var request = context.Request; var response = context.Response; var serializedRequest = new System. pipeServer.Write(context.Request) } pipeClient.WaitForExit(); pipeClient.Close(); Console.WriteLine("[SERVER] Client quit. Server terminating."); pipeServer.Dispose(); listener.Stop(); }
public static void Main() { AnonymousPipeServerStream pipeServer = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable); var clientPipeHandle = pipeServer.GetClientHandleAsString(); Console.WriteLine(clientPipeHandle); Process pipeClient = new Process(); pipeClient.StartInfo.FileName = "client.exe"; pipeClient.StartInfo.Arguments = clientPipeHandle; pipeClient.StartInfo.UseShellExecute = false; pipeClient.Start(); pipeServer.DisposeLocalCopyOfClientHandle(); pipeServer.WriteByte(45); pipeServer.Flush(); Console.WriteLine("Press any key to quit"); Console.ReadKey(); pipeServer.Dispose(); }
/// <summary> /// Releases all resources used by the Ghostscript.NET.GhostscriptPipedOutput instance. /// </summary> protected virtual void Dispose(bool disposing) { if (!_disposed) { if (disposing) { if (_pipe != null) { // _pipe.DisposeLocalCopyOfClientHandle(); // for some reason at this point the handle is invalid for real. // DisposeLocalCopyOfClientHandle should be called instead, but it // throws an exception saying that the handle is invalid pointing to // CloseHandle method in the dissasembled code. // this is a workaround, if we don't set the handle as invalid, when // garbage collector tries to dispose this handle, exception is thrown _pipe.ClientSafePipeHandle.SetHandleAsInvalid(); _pipe.Dispose(); _pipe = null; } if (_thread != null) { // check if the thread is still running if (_thread.ThreadState == ThreadState.Running) { // abort the thread _thread.Abort(); } _thread = null; } } _disposed = true; } }
public void Dispose() { pipeServer?.Dispose(); pipeClient?.Dispose(); }
public void Dispose() { _out.Dispose(); _in.Dispose(); }
public R <(string, Thread, TimeSpan?), LocalStr> StreamSongToPipeHandle(string spotifyTrackUri) { var trackId = SpotifyApi.UriToTrackId(spotifyTrackUri); if (!trackId.Ok) { return(new LocalStr("Cannot stream this URI from spotify.")); } if (state == State.NotSetUp) { return(new LocalStr("Spotify API access was not set up correctly. Cannot play from spotify.")); } if (state != State.Idle) { throw new InvalidOperationException( $"Tried to stream spotify song while the system was not idle (current state: {state})." ); } // Launch Librespot. state = State.LaunchingLibrespot; Log.Debug("Launching Librespot..."); var processOption = LaunchLibrespot(); if (!processOption.Ok) { return(processOption.Error); } void Fail(string msg) { Log.Debug("Failed to start song on spotify: " + msg); } TimeSpan duration = default; for (var i = 0; i < SongStartRetries; i++) { Log.Debug($"Starting to play song on spotify, try {i}..."); // Start song. var playResult = api.Request( () => api.Client.Player.ResumePlayback(new PlayerResumePlaybackRequest { DeviceId = deviceId, Uris = new List <string> { spotifyTrackUri } }) ); if (!playResult.Ok) { Fail(playResult.Error.ToString()); continue; } // Check if the song actually started playing. for (var j = 0; j < 2; j++) { if (j == 1) { // Wait before the second check. Thread.Sleep(SongStartRecheckAfter); } var checkResult = api.Request(() => api.Client.Player.GetCurrentPlayback()); if (!checkResult.Ok) { Fail(checkResult.Error.ToString()); continue; } var currentlyPlaying = checkResult.Value; if (currentlyPlaying.CurrentlyPlayingType != "track") { Fail("No track is currently playing."); continue; } var track = (FullTrack)currentlyPlaying.Item; if ( currentlyPlaying.IsPlaying && currentlyPlaying.Device.Id == deviceId && track.Id == trackId.Value ) { duration = TimeSpan.FromMilliseconds(track.DurationMs); state = State.StreamRunning; break; } Fail( $"Song not playing yet on spotify." + $" IsPlaying: {currentlyPlaying.IsPlaying}," + $" DeviceId: {currentlyPlaying.Device.Id} (should be {deviceId})," + $" TrackId: {track.Id} (should be {trackId.Value})." ); } if (state == State.StreamRunning) { Log.Trace("Song is playing on spotify now."); break; } } // Start audio streaming to ffmpeg. Log.Debug("Starting stream..."); var pipeServer = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable); var handle = "pipe:" + pipeServer.GetClientHandleAsString(); var totalBytesSent = 0; void ExitLibrespot(string message, bool stats = true) { pipeServer.Dispose(); if (!process.HasExitedSafe()) { process.Kill(); } process.Close(); state = State.Idle; var msg = message; if (stats) { msg += $" Sent {byteSizeFormatter.Format(totalBytesSent)} bytes in total."; } Log.Debug(msg); } if (state != State.StreamRunning) { var msg = $"Song did not start playing after {SongStartRetries} retries."; ExitLibrespot(msg, false); return(new LocalStr(msg)); } var byteReaderThread = new Thread(() => { var buffer = new byte[BytesPerChunk]; while (true) { int bytesRead; try { bytesRead = process.StandardOutput.BaseStream.Read(buffer, 0, BytesPerChunk); } catch (IOException e) { ExitLibrespot($"Reading from Librespot failed: {e}."); return; } if (bytesRead == 0) { // Librespot exited, no more data coming. ExitLibrespot("All spotify streaming data sent to ffmpeg."); return; } try { pipeServer.Write(buffer, 0, bytesRead); } catch (IOException) { ExitLibrespot("Ffmpeg went away before all spotify stream data was sent."); return; } if (totalBytesSent == 0) { // Necessary to dispose the handle after ffmpeg connected to receive notice when ffmpeg exits. pipeServer.DisposeLocalCopyOfClientHandle(); } totalBytesSent += bytesRead; } }) { IsBackground = true }; return(handle, byteReaderThread, duration); }