public static void ServerWriteNegativeOffsetThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Assert.Throws <ArgumentOutOfRangeException>(() => server.Write(new byte[5], -1, 1)); // array is checked first Assert.Throws <ArgumentNullException>(() => server.Write(null, -1, 1)); } }
/// <summary> /// Send an object to the specified anonymous out pipe. /// </summary> /// <param name="pipeWriter">The pipe to write to.</param> /// <param name="obj">The object to send.</param> public static void SendObjectToPipe(AnonymousPipeServerStream pipeWriter, object obj) { var objStream = ReflectionUtilities.BinarySerialise(obj) as MemoryStream; // Write the number of bytes var numBytes = Convert.ToInt32(objStream.Length); var intBuffer = BitConverter.GetBytes(numBytes); pipeWriter.Write(intBuffer, 0, 4); // Write the objStream. pipeWriter.Write(objStream.ToArray(), 0, numBytes); }
public void ForNonSeekable(string input, params string[] lines) { using (var s = new AnonymousPipeServerStream()) using (var c = new AnonymousPipeClientStream(s.GetClientHandleAsString())) { var bytes = Encoding.ASCII.GetBytes(input); s.Write(bytes, 0, bytes.Length); s.Close(); var skipLF = false; foreach (var line in lines) { Assert.Equal(line, c.ReadProtocolLineWithEnd(skipLF)); skipLF = (line.Last() == '\r'); } } using (var s = new AnonymousPipeServerStream()) using (var c = new AnonymousPipeClientStream(s.GetClientHandleAsString())) { var bytes = Encoding.ASCII.GetBytes(input); s.Write(bytes, 0, bytes.Length); s.Close(); var skipLF = false; foreach (var line in lines) { Assert.Equal(line.TrimEnd(LineEnds), c.ReadProtocolLine(skipLF)); skipLF = (line.Last() == '\r'); } } }
private void Encoder_Data_Available(object sender, VideoEventArgs e) { frame++; framebytes = e.payload.outbytes; lastframe = e.payload.uncompressedFrame; lastframestride = e.payload.stride; lastframeheight = e.payload.height; lastframewidth = e.payload.width; if (isConnected) { VideoStream.Write(e.payload.result, 0, e.payload.outbytes); VideoStream.Flush(); VideoStream.WaitForPipeDrain(); video.ReturnWork(e.payload); } if (enableWriteToFile && binaryVideoWriter != null) { binaryVideoWriter.Write(e.payload.result, 0, e.payload.outbytes); binaryVideoWriter.Flush(); } }
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 static void ServerWriteBufferNullThrows() { // force different constructor path using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None)) { Assert.Throws <ArgumentNullException>(() => server.Write(null, 0, 1)); } }
public void Write(byte[] buffer, int offset, int count) { if (!m_Started) { return; } m_Server.Write(buffer, offset, count); }
public static void ServerWriteBufferNullThrows() { // force different constructor path using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None)) { Assert.Throws<ArgumentNullException>(() => server.Write(null, 0, 1)); Assert.Throws<ArgumentNullException>(() => NotReachable(server.WriteAsync(null, 0, 1))); } }
public static void ServerWriteNegativeCountThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Assert.Throws <ArgumentOutOfRangeException>(() => server.Write(new byte[5], 0, -1)); // offset is checked before count Assert.Throws <ArgumentOutOfRangeException>(() => server.Write(new byte[1], -1, -1)); // array is checked first Assert.Throws <ArgumentNullException>(() => server.Write(null, -1, -1)); Assert.Throws <ArgumentOutOfRangeException>(() => NotReachable(server.WriteAsync(new byte[5], 0, -1))); // offset is checked before count Assert.Throws <ArgumentOutOfRangeException>(() => NotReachable(server.WriteAsync(new byte[1], -1, -1))); // array is checked first Assert.Throws <ArgumentNullException>(() => NotReachable(server.WriteAsync(null, -1, -1))); } }
public static void ServerReadOnlyThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Assert.Throws <NotSupportedException>(() => server.Write(new byte[5], 0, 5)); Assert.Throws <NotSupportedException>(() => server.WriteByte(123)); Assert.Throws <NotSupportedException>(() => server.Flush()); Assert.Throws <NotSupportedException>(() => server.OutBufferSize); Assert.Throws <NotSupportedException>(() => server.WaitForPipeDrain()); } }
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]); } }
//Fonction permettant l'écriture vers la couche Réseau public void ecrire_vers_reseau(string str) { //Affichage de la primitive à envoyer Utility.AfficherDansConsole("Transport vers Reseau : " + str, Constantes.TRANSPORT_RESEAU_COLOR); str += Constantes.FIN_PRIMITIVE; try{ pipe_sem.WaitOne(); //Transformation de la chaîne de caractère en tableau de Bytes byte[] bytes = Encoding.UTF8.GetBytes(str); //Envoie du tableau dans le Pipe vers la couche Réseau transportOut.Write(bytes, 0, str.Length); }catch (IOException e) { //Affichage du message d'erreur, s'il y en a un Utility.AfficherDansConsole(e.Message, Constantes.ERREUR_COLOR); }finally{ pipe_sem.Release(); } }
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 ServerPInvokeChecks() { // calling every API related to server and client to detect any bad PInvokes using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Task clientTask = Task.Run(() => StartClient(PipeDirection.In, server.ClientSafePipeHandle)); Assert.False(server.CanRead); Assert.False(server.CanSeek); Assert.False(server.CanTimeout); Assert.True(server.CanWrite); Assert.False(string.IsNullOrWhiteSpace(server.GetClientHandleAsString())); Assert.False(server.IsAsync); Assert.True(server.IsConnected); Assert.Equal(0, server.OutBufferSize); Assert.Equal(PipeTransmissionMode.Byte, server.ReadMode); Assert.NotNull(server.SafePipeHandle); Assert.Equal(PipeTransmissionMode.Byte, server.TransmissionMode); server.Write(new byte[] { 123 }, 0, 1); server.WriteAsync(new byte[] { 124 }, 0, 1).Wait(); server.Flush(); server.WaitForPipeDrain(); clientTask.Wait(); server.DisposeLocalCopyOfClientHandle(); } using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Task clientTask = Task.Run(() => StartClient(PipeDirection.Out, server.ClientSafePipeHandle)); Assert.Equal(4096, server.InBufferSize); byte[] readData = new byte[] { 0, 1 }; Assert.Equal(1, server.Read(readData, 0, 1)); Assert.Equal(1, server.ReadAsync(readData, 1, 1).Result); Assert.Equal(123, readData[0]); Assert.Equal(124, readData[1]); clientTask.Wait(); } }
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)); } }
//Focntion permettant l'écriture d'une chaîne de caractère vers la couche transport public void ecrire_vers_transport(string str) { //Affichage de la chaîne à écrire Utility.AfficherDansConsole("Reseau vers Transport : " + str, Constantes.TRANSPORT_RESEAU_COLOR); str += Constantes.FIN_PRIMITIVE; try { pipe_sem.WaitOne(); byte[] bytes = Encoding.UTF8.GetBytes(str); //Transformartion de la chaîne en tableau de Bytes reseauOut.Write(bytes, 0, str.Length); //Écriture du tableau dans le pipe vers transport } catch (IOException e) { //Affichage du message d'erreur, s'il y a lieu Utility.AfficherDansConsole(e.Message, Constantes.ERREUR_COLOR); }finally{ pipe_sem.Release(); } }
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]); } } } }
public static void ServerWriteArrayOutOfBoundsThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { // offset out of bounds Assert.Throws <ArgumentException>(null, () => server.Write(new byte[1], 1, 1)); // offset out of bounds for 0 count read Assert.Throws <ArgumentException>(null, () => server.Write(new byte[1], 2, 0)); // offset out of bounds even for 0 length buffer Assert.Throws <ArgumentException>(null, () => server.Write(new byte[0], 1, 0)); // combination offset and count out of bounds Assert.Throws <ArgumentException>(null, () => server.Write(new byte[2], 1, 2)); // edges Assert.Throws <ArgumentException>(null, () => server.Write(new byte[0], int.MaxValue, 0)); Assert.Throws <ArgumentException>(null, () => server.Write(new byte[0], int.MaxValue, int.MaxValue)); Assert.Throws <ArgumentException>(() => server.Write(new byte[5], 3, 4)); // offset out of bounds Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[1], 1, 1))); // offset out of bounds for 0 count read Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[1], 2, 0))); // offset out of bounds even for 0 length buffer Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], 1, 0))); // combination offset and count out of bounds Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[2], 1, 2))); // edges Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], int.MaxValue, 0))); Assert.Throws <ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], int.MaxValue, int.MaxValue))); Assert.Throws <ArgumentException>(() => NotReachable(server.WriteAsync(new byte[5], 3, 4))); } }
public static void ServerPInvokeChecks() { // calling every API related to server and client to detect any bad PInvokes using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Task clientTask = StartClientAsync(PipeDirection.In, server.ClientSafePipeHandle); Console.WriteLine("server.CanRead = {0}", server.CanRead); Console.WriteLine("server.CanSeek = {0}", server.CanSeek); Console.WriteLine("server.CanTimeout = {0}", server.CanTimeout); Console.WriteLine("server.CanWrite = {0}", server.CanWrite); Console.WriteLine("server.GetClientHandleAsString() = {0}", server.GetClientHandleAsString()); Console.WriteLine("server.IsAsync = {0}", server.IsAsync); Console.WriteLine("server.IsConnected = {0}", server.IsConnected); Console.WriteLine("server.OutBufferSize = {0}", server.OutBufferSize); Console.WriteLine("server.ReadMode = {0}", server.ReadMode); Console.WriteLine("server.SafePipeHandle = {0}", server.SafePipeHandle); Console.WriteLine("server.TransmissionMode = {0}", server.TransmissionMode); server.Write(new byte[] { 123 }, 0, 1); server.WriteAsync(new byte[] { 124 }, 0, 1).Wait(); server.Flush(); Console.WriteLine("Waiting for Pipe Drain."); server.WaitForPipeDrain(); clientTask.Wait(); server.DisposeLocalCopyOfClientHandle(); } using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Task clientTask = StartClientAsync(PipeDirection.Out, server.ClientSafePipeHandle); Console.WriteLine("server.InBufferSize = {0}", server.InBufferSize); byte[] readData = new byte[] { 0, 1 }; server.Read(readData, 0, 1); server.ReadAsync(readData, 1, 1).Wait(); Assert.Equal(123, readData[0]); Assert.Equal(124, readData[1]); } }
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)); } } }
private void Audio_DataAvailable(object sender, WaveInEventArgs e) { if (e.BytesRecorded == 0) { return; } var buffer = e.Buffer; if (!recording) { return; } sourceProvider.AddSamples(e.Buffer, 0, e.BytesRecorded); //using (var str = new RawSourceWaveStream(buffer, 0, e.BytesRecorded, audio.WaveFormat))//need to preserve this? //{ //var six = new WaveFloatTo16Provider(sourceProvider); byte[] output = new byte[e.BytesRecorded / 2]; //var volout = new StereoToMonoProvider16(six); monovolumeprovider.LeftVolume = (1f - videorecordingsettings.audioBalance) * videorecordingsettings.leftVolume * 2; monovolumeprovider.RightVolume = (videorecordingsettings.audioBalance) * videorecordingsettings.rightVolume * 2; //var formatconv = new WaveFormatConversionProvider(new WaveFormat(24000, 16, 1), volout); //byte[] output = new byte[bytesread / 2]; var bytesread = formatconv.Read(output, 0, e.BytesRecorded); int control = 0; if (audioframe == 0) { control = 1; } audioframe++; if (isConnected) { AudioStream.Write(BitConverter.GetBytes(control), 0, sizeof(int)); AudioStream.Write(BitConverter.GetBytes(bytesread), 0, sizeof(int)); AudioStream.Write(BitConverter.GetBytes(formatconv.WaveFormat.SampleRate), 0, sizeof(int)); //volout AudioStream.Write(BitConverter.GetBytes(formatconv.WaveFormat.AverageBytesPerSecond), 0, sizeof(int)); AudioStream.Write(output, 0, bytesread); AudioStream.Flush(); AudioStream.WaitForPipeDrain(); } if (enableWriteToFile && binaryAudioWriter != null) { binaryAudioWriter.Write(BitConverter.GetBytes(control), 0, sizeof(int)); binaryAudioWriter.Write(BitConverter.GetBytes(bytesread), 0, sizeof(int)); binaryAudioWriter.Write(BitConverter.GetBytes(formatconv.WaveFormat.SampleRate), 0, sizeof(int)); binaryAudioWriter.Write(BitConverter.GetBytes(formatconv.WaveFormat.AverageBytesPerSecond), 0, sizeof(int)); //AudioStream.Write(BitConverter.GetBytes(volout.WaveFormat.SampleRate), 0, sizeof(int)); //AudioStream.Write(BitConverter.GetBytes(volout.WaveFormat.AverageBytesPerSecond), 0, sizeof(int)); binaryAudioWriter.Write(output, 0, bytesread); binaryAudioWriter.Flush(); } audiolengthmonitor = bytesread; //} }
public static void ServerWriteNegativeCountThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { Assert.Throws<ArgumentOutOfRangeException>(() => server.Write(new byte[5], 0, -1)); // offset is checked before count Assert.Throws<ArgumentOutOfRangeException>(() => server.Write(new byte[1], -1, -1)); // array is checked first Assert.Throws<ArgumentNullException>(() => server.Write(null, -1, -1)); Assert.Throws<ArgumentOutOfRangeException>(() => NotReachable(server.WriteAsync(new byte[5], 0, -1))); // offset is checked before count Assert.Throws<ArgumentOutOfRangeException>(() => NotReachable(server.WriteAsync(new byte[1], -1, -1))); // array is checked first Assert.Throws<ArgumentNullException>(() => NotReachable(server.WriteAsync(null, -1, -1))); } }
public static void ServerReadOnlyThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Assert.Throws<NotSupportedException>(() => server.Write(new byte[5], 0, 5)); Assert.Throws<NotSupportedException>(() => server.WriteByte(123)); Assert.Throws<NotSupportedException>(() => server.Flush()); Assert.Throws<NotSupportedException>(() => server.OutBufferSize); Assert.Throws<NotSupportedException>(() => server.WaitForPipeDrain()); Assert.Throws<NotSupportedException>(() => NotReachable(server.WriteAsync(new byte[5], 0, 5))); } }
public static void ServerWriteArrayOutOfBoundsThrows() { using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out)) { // offset out of bounds Assert.Throws<ArgumentException>(null, () => server.Write(new byte[1], 1, 1)); // offset out of bounds for 0 count read Assert.Throws<ArgumentException>(null, () => server.Write(new byte[1], 2, 0)); // offset out of bounds even for 0 length buffer Assert.Throws<ArgumentException>(null, () => server.Write(new byte[0], 1, 0)); // combination offset and count out of bounds Assert.Throws<ArgumentException>(null, () => server.Write(new byte[2], 1, 2)); // edges Assert.Throws<ArgumentException>(null, () => server.Write(new byte[0], int.MaxValue, 0)); Assert.Throws<ArgumentException>(null, () => server.Write(new byte[0], int.MaxValue, int.MaxValue)); Assert.Throws<ArgumentException>(() => server.Write(new byte[5], 3, 4)); // offset out of bounds Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[1], 1, 1))); // offset out of bounds for 0 count read Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[1], 2, 0))); // offset out of bounds even for 0 length buffer Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], 1, 0))); // combination offset and count out of bounds Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[2], 1, 2))); // edges Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], int.MaxValue, 0))); Assert.Throws<ArgumentException>(null, () => NotReachable(server.WriteAsync(new byte[0], int.MaxValue, int.MaxValue))); Assert.Throws<ArgumentException>(() => NotReachable(server.WriteAsync(new byte[5], 3, 4))); } }
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); }
public void SendMessage(ReadOnlySpan <byte> bytes) { _pipeServer.Write(bytes); }
public static async Task ServerPInvokeChecks() { // calling every API related to server and client to detect any bad PInvokes using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.None, 4096)) { Task clientTask = Task.Run(() => StartClient(PipeDirection.In, server.ClientSafePipeHandle)); Assert.False(server.CanRead); Assert.False(server.CanSeek); Assert.False(server.CanTimeout); Assert.True(server.CanWrite); Assert.False(string.IsNullOrWhiteSpace(server.GetClientHandleAsString())); Assert.False(server.IsAsync); Assert.True(server.IsConnected); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Assert.True(server.OutBufferSize > 0); } else { Assert.Throws <PlatformNotSupportedException>(() => server.OutBufferSize); } Assert.Equal(PipeTransmissionMode.Byte, server.ReadMode); Assert.NotNull(server.SafePipeHandle); Assert.Equal(PipeTransmissionMode.Byte, server.TransmissionMode); server.Write(new byte[] { 123 }, 0, 1); await server.WriteAsync(new byte[] { 124 }, 0, 1); server.Flush(); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { server.WaitForPipeDrain(); } else { Assert.Throws <PlatformNotSupportedException>(() => server.WaitForPipeDrain()); } await clientTask; server.DisposeLocalCopyOfClientHandle(); } using (AnonymousPipeServerStream server = new AnonymousPipeServerStream(PipeDirection.In)) { Task clientTask = Task.Run(() => StartClient(PipeDirection.Out, server.ClientSafePipeHandle)); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Assert.Equal(4096, server.InBufferSize); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Assert.True(server.InBufferSize > 0); } else { Assert.Throws <PlatformNotSupportedException>(() => server.InBufferSize); } byte[] readData = new byte[] { 0, 1 }; Assert.Equal(1, server.Read(readData, 0, 1)); Assert.Equal(1, server.ReadAsync(readData, 1, 1).Result); Assert.Equal(123, readData[0]); Assert.Equal(124, readData[1]); await clientTask; } }
/// <summary> /// Creates a child domain. /// </summary> public ChildDomain AddChildDomain(ProcessStartInfo startInfo, IAmASerializer serializer = null, IGenerateProxies proxyGenerator = null) { //if the path is missing then if (startInfo == null) { throw new ArgumentNullException(nameof(startInfo)); } var childProcess = new Process { StartInfo = startInfo }; proxyGenerator = proxyGenerator ?? DefaultProxyFactory.Instance; serializer = serializer ?? DefaultSerializer.Instance; var debuggerEnabled = Debugger.IsAttached && DebuggingSupported; var read = new AnonymousPipeServerStream(PipeDirection.Out, HandleInheritability.Inheritable); var write = new AnonymousPipeServerStream(PipeDirection.In, HandleInheritability.Inheritable); startInfo.Environment[connectionStringVarName] = $"pid={Current.Process.Id}&" + $"write={write.GetClientHandleAsString()}&" + $"read={read.GetClientHandleAsString()}&" + $"debug={(debuggerEnabled ? 1 : 0)}&" + $"serializer={HttpUtility.UrlEncode(serializer.Name)}&" + $"proxyGenerator={HttpUtility.UrlEncode(proxyGenerator.Name)}"; startInfo.UseShellExecute = false; childProcess.EnableRaisingEvents = true; childProcess.Start(); read.DisposeLocalCopyOfClientHandle(); write.DisposeLocalCopyOfClientHandle(); if (debuggerEnabled) { if (!TryToAttachDebugger(childProcess.Id)) { debuggerEnabled = false; } //signal to the child process to continue now that the debugger is attached read.Write(new byte[1], 0, 1); } //NOTE: the read and write streams are switched for the server side var child = new ChildDomain(childProcess, debuggerEnabled, new Connection(this, serializer, proxyGenerator, write, read)); children[childProcess.Id] = child; child.Process.Exited += (sender, eventArgs) => children.TryRemove(childProcess.Id, out _); if (child.Process.HasExited) { children.TryRemove(childProcess.Id, out _); } return(child); }