public ReadWriteStream( string name ) { if (string.IsNullOrWhiteSpace (name)) throw new ArgumentException ("SelectiveStream name argument be a non-empty string"); _name = name; _inStream = new ProducerConsumerStream (BufSize); _outStream = new ProducerConsumerStream (BufSize); }
public ReadWriteStream( string name, int bufSize ) : this(name) { if (bufSize < 1) throw new ArgumentException ("Buffer size must be greater 0"); _inStream = new ProducerConsumerStream (bufSize); _outStream = new ProducerConsumerStream (bufSize); }
public IActionResult Get(ObjectId archiveId) { _logger.LogInformation("Grabbing archive {0} for judge node {1}", archiveId, HttpContext.Connection.RemoteIpAddress); var(producer, consumer) = ProducerConsumerStream.Create(); _repo.Problems.DownloadTestDataArchive(archiveId, producer).ConfigureAwait(false); return(File(consumer, "application/zip")); }
public Py(Bot bot) { this.bot = bot; engine = Python.CreateEngine(); scope = engine.CreateScope(); scope.SetVariable("tools", new PythonTools()); var outputStream = new ProducerConsumerStream(); var outputStreamWriter = new StreamWriter(outputStream); outputStreamReader = new StreamReader(outputStream); engine.Runtime.IO.SetOutput(outputStream, outputStreamWriter); }
public Py() { engine = Python.CreateEngine(); scope = engine.CreateScope(); scope.SetVariable("tools", new PythonTools()); var outputStream = new ProducerConsumerStream(); var outputStreamWriter = new StreamWriter(outputStream); outputStreamReader = new StreamReader(outputStream); engine.Runtime.IO.SetOutput(outputStream, outputStreamWriter); }
private void Connector_ActivityReceived(object sender, ActivityReceivedEventArgs e) { var json = e.Activity; var activity = JsonConvert.DeserializeObject <Activity>(json); if (e.HasAudio) { var audio = e.Audio; var stream = new ProducerConsumerStream(); Task.Run(() => { var buffer = new byte[800]; uint bytesRead = 0; while ((bytesRead = audio.Read(buffer)) > 0) { stream.Write(buffer, 0, (int)bytesRead); } }); var channelData = activity.GetChannelData <SpeechChannelData>(); var id = channelData?.ConversationalAiData?.RequestInfo?.InteractionId; if (!string.IsNullOrEmpty(id)) { System.Diagnostics.Debug.WriteLine($"Expecting TTS stream {id}"); } var wavStream = new RawSourceWaveStream(stream, new WaveFormat(16000, 16, 1)); playbackStreams.Enqueue(new WavQueueEntry(id, false, stream, wavStream)); if (player.PlaybackState != PlaybackState.Playing) { Task.Run(() => PlayFromAudioQueue()); } } var cardsToBeRendered = new List <AdaptiveCard>(); if (activity.Attachments?.Any() is true) { cardsToBeRendered = activity.Attachments .Where(x => x.ContentType == AdaptiveCard.ContentType) .Select(x => { var parseResult = AdaptiveCard.FromJson(x.Content.ToString()); return(parseResult.Card); }) .Where(x => x != null) .ToList(); } activities.Add(new ActivityRecord(json, activity, Sender.Bot)); messages.Add(new MessageRecord(activity.Text, Sender.Bot)); }
public async Task <Stream> GetContentAsync(RootName root, FileId source) { var context = await RequireContextAsync(root); var stream = new ProducerConsumerStream(); var retryPolicyWithAction = Policy.Handle <pCloudException>().WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, ts) => stream.Reset()); await retryPolicyWithAction.ExecuteAsync(() => context.Client.DownloadFileAsync(ToId(source), stream, CancellationToken.None)); stream.Flush(); return(stream); }
public async Task <Stream> GetContentAsync(RootName root, FileId source) { var context = await RequireContextAsync(root); var stream = new ProducerConsumerStream(); var retryPolicyWithAction = Policy.Handle <GoogleApiException>().WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, ts) => stream.Reset()); await retryPolicyWithAction.ExecuteAsync(() => context.Service.Files.Get(source.Value).DownloadAsync(stream)); stream.Flush(); return(stream); }
/// <summary> /// Opens a file on the specified <see cref="FileSystemPath"/>. /// </summary> public Stream OpenFile(FileSystemPath path, FileAccess access) { if (access == FileAccess.Write) { throw new NotSupportedException(); } Stream s = new ProducerConsumerStream(); ThreadPool.QueueUserWorkItem(delegate { _extractor.ExtractFile(GetSevenZipPath(path), s); s.Close(); }); return(s); }
static void Main(string[] args) { Console.WriteLine("TextBytes contains {0:N0} bytes.", TextBytes.Length); using (var pcStream = new ProducerConsumerStream(TestBufferSize)) { Thread ProducerThread = new Thread(ProducerThreadProc); Thread ConsumerThread = new Thread(ConsumerThreadProc); ProducerThread.Start(pcStream); Thread.Sleep(2000); ConsumerThread.Start(pcStream); ProducerThread.Join(); ConsumerThread.Join(); } Console.Write("Done. Press Enter."); Console.ReadLine(); }
/// <summary> /// Default the Songs as Nill; /// </summary> public AudioControlViewModel() { ms = new ProducerConsumerStream(); SongTitle = ""; ArtistName = ""; EventAggregator.EventAggregator.Instance.RegisterListener <SongChangeEvent>((songEvt) => { SongTitle = songEvt.Song.SongTitle; ArtistName = songEvt.Song.ArtistName; this.FirePropertyChanged("SongTitle"); this.FirePropertyChanged("ArtistName"); //Request a packet with this song. PacketManager.sharedInstance().SendPacket( new Packet(PacketType.TRACK, Marshal.SizeOf(songEvt.Song), Song.Serialize(songEvt.Song)), GetSongData); }); }
async public Task ReadLineAsyncLatencyIssuesTest() { ThreadPool.SetMaxThreads(1, 1); var MemoryStream = new ProducerConsumerStream(new ProducerConsumer<byte>()); var StreamWriter = new StreamWriter(MemoryStream) { AutoFlush = true }; StreamWriter.Write("line1\r"); var Task2 = Task.Run(async () => { await Task.Delay(2); StreamWriter.Write("\n"); StreamWriter.Write("line2\r\n"); }); var Stream = new NodeBufferedStream(MemoryStream, 3); Assert.AreEqual("line1", await Stream.ReadLineAsync(Encoding.UTF8)); Assert.AreEqual("line2", await Stream.ReadLineAsync(Encoding.UTF8)); await Task2; }
public IActionResult Get(string fileId) { Guid fileGuid; try { fileGuid = new Guid(fileId); } catch (FormatException) { return(NotFound()); } DbFileInfo fileInfo = _databaseInterface.GetFileInfo(fileGuid); if (fileInfo == null) { return(NotFound()); } var fileCrypto = new ChaChaFileCrypto() { Key = fileInfo.Key, Iv = fileInfo.Iv }; var dloadStream = new ProducerConsumerStream(1048576); _googleDriveInterface.DownloadFileAsync(fileId, dloadStream); var outStream = fileCrypto.BcDecryptStream(dloadStream); return(new FileCallbackResult(new MediaTypeHeaderValue("application/octet-stream"), async(outputStream, _) => { await outStream.CopyToAsync(outputStream); await outputStream.FlushAsync(); }) { FileDownloadName = fileInfo.FileName }); }
private static async Task <FileReaderViewModel <FileInfo> > RunTest(Func <StreamWriter, Task> streamWriterAsyncAction) { var uiPlatformServiceMock = new Mock <IUIPlatformService <FileInfo> >(); var systemPlatformServiceMock = new Mock <ISystemPlatformService <FileInfo> >(); Stream fileStreamMock = new ProducerConsumerStream(); systemPlatformServiceMock .Setup(x => x.OpenFileAsStream(It.IsAny <FileInfo>())) .ReturnsAsync(fileStreamMock); var vm = new FileReaderViewModel <FileInfo>( uiPlatformServiceMock.Object, systemPlatformServiceMock.Object); await vm.OpenAndWatchFileAsync(new FileInfo("DummyPath")); using (var streamWriter = new StreamWriter(fileStreamMock, Encoding.UTF8, 1024, true)) await streamWriterAsyncAction(streamWriter); return(vm); }
public bool PerformDownload(byte[] result, Action <ProducerConsumerStream> resetAction, Func <ProducerConsumerStream, byte[], int, int, Task> writeAction) { using (var localStream = new ProducerConsumerStream()) { var readTask = Task.Run(async() => { var offset = 0; while (offset < result.Length) { offset += await localStream.ReadAsync(result, offset, CHUNK_SIZE, CancellationToken.None); } return(offset); }); var remoteStream = default(Stream); try { remoteStream = GetRemoteStream(); var sut = GetWaitAndRetryPolicy((ex, ts) => { remoteStream.Dispose(); remoteStream = GetRemoteStream(); resetAction(localStream); }); sut.ExecuteAsync(async() => { var buffer = new byte[CHUNK_SIZE]; for (int offset = 0; offset < result.Length; offset += CHUNK_SIZE) { var bytesRead = await remoteStream.ReadAsync(buffer, 0, CHUNK_SIZE, CancellationToken.None); await writeAction(localStream, buffer, 0, bytesRead); } return(Task.CompletedTask); }).Wait(); } finally { remoteStream?.Dispose(); } return(readTask.Wait(TimeSpan.FromMilliseconds(100))); } }
public void DownloadFileAsync(string fileName, ProducerConsumerStream outStream) { DriveService driveService = _service; FilesResource.ListRequest listRequest = _service.Files.List(); listRequest.PageSize = 10; listRequest.Fields = "nextPageToken, files(id, name)"; listRequest.Q = $"'{_driveFolder}' in parents and name = '{fileName}'"; // List files. IList <Google.Apis.Drive.v3.Data.File> files = listRequest.Execute().Files; string gFileId = files[0].Id; var request = driveService.Files.Get(gFileId); request.MediaDownloader.ProgressChanged += progress => { if (progress.Status == DownloadStatus.Completed) { outStream.CompleteAdding(); } }; request.DownloadAsync(outStream); }
public void Initialize() { sut = Fixture.CreateStream(); }
// Methods overidden from WebRequest public override WebResponse GetResponse() { Stream responseStream = new ProducerConsumerStream(8192) { Blocking = true, ReadTimeout = Timeout, WriteTimeout = Timeout, }; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; Task curlTask = Task.Factory.StartNew(() => { try { GlobalInit(); using (CurlEasyHandle easyHandle = LibCurl.EasyInit()) using (SList headers = new SList()) using (MemoryStream requestStream = new MemoryStream(GetRequestStream(validateMethod: false).ToArray())) { LibCurl.EasySetOpt(easyHandle, CurlOption.Url, base.RequestUri.AbsoluteUri); LibCurl.EasySetOpt(easyHandle, CurlOption.FollowLocation, AllowAutoRedirect ? 1 : 0); LibCurl.EasySetOpt(easyHandle, CurlOption.MaxRedirs, MaximumAutomaticRedirections); LibCurl.EasySetOpt(easyHandle, CurlOption.Timeout, base.Timeout); if (AutomaticDecompression != DecompressionMethods.None) { LibCurl.EasySetOpt(easyHandle, CurlOption.AcceptEncoding, GetAcceptEncoding()); } if (File.Exists(options.CABundlePath)) { LibCurl.EasySetOpt(easyHandle, CurlOption.CAInfo, options.CABundlePath); } SetCertificateValidationEnabled(easyHandle); SetCookies(easyHandle); SetCredentials(easyHandle); SetHeaders(easyHandle, headers); SetHttpVersion(easyHandle); SetKeepAlive(easyHandle); SetMethod(easyHandle); SetProxy(easyHandle); // Execute the request. using (ICurlDataCopier dataCopier = new CurlDataCopier(requestStream, responseStream, cancellationToken)) { LibCurl.EasySetOpt(easyHandle, CurlOption.HeaderFunction, dataCopier.Header); LibCurl.EasySetOpt(easyHandle, CurlOption.ReadFunction, dataCopier.Read); LibCurl.EasySetOpt(easyHandle, CurlOption.WriteFunction, dataCopier.Write); LibCurl.EasySetOpt(easyHandle, CurlOption.ProgessFunction, dataCopier.Progress); CurlCode resultCode = LibCurl.EasyPerform(easyHandle); if (resultCode != CurlCode.OK) { throw new CurlException(resultCode); } } } } finally { // Close the stream to indicate that we're done writing to it, unblocking readers. responseStream.Close(); GlobalCleanup(); } }, cancellationToken); HaveResponse = true; return(new CurlHttpWebResponse(this, responseStream, curlTask, cancellationTokenSource)); }
public WavQueueEntry(string id, bool playInitiated, ProducerConsumerStream stream, RawSourceWaveStream reader) => (this.Id, this.PlayInitiated, this.Stream, this.Reader) = (id, playInitiated, stream, reader);
public async Task SendBytesBackAndForthBetweenClientAndServer_Success() { using (HttpClient client = CreateHttpClient()) using (var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { listener.Bind(new IPEndPoint(IPAddress.Loopback, 0)); listener.Listen(1); var ep = (IPEndPoint)listener.LocalEndPoint; var clientToServerStream = new ProducerConsumerStream(); clientToServerStream.WriteByte(0); var reqMsg = new HttpRequestMessage { RequestUri = new Uri($"http://{ep.Address}:{ep.Port}/"), Content = new StreamContent(clientToServerStream), }; Task <HttpResponseMessage> req = client.SendAsync(reqMsg, HttpCompletionOption.ResponseHeadersRead); using (Socket server = await listener.AcceptAsync()) using (var serverStream = new NetworkStream(server, ownsSocket: false)) { // Skip request headers. while (true) { if (serverStream.ReadByte() == '\r') { serverStream.ReadByte(); break; } while (serverStream.ReadByte() != '\r') { } serverStream.ReadByte(); } // Send response headers. await server.SendAsync( new ArraySegment <byte>(Encoding.ASCII.GetBytes($"HTTP/1.1 200 OK\r\nConnection: close\r\nDate: {DateTimeOffset.UtcNow:R}\r\n\r\n")), SocketFlags.None); HttpResponseMessage resp = await req; Stream serverToClientStream = await resp.Content.ReadAsStreamAsync(); // Communication should now be open between the client and server. // Ping pong bytes back and forth. for (byte i = 0; i < 100; i++) { // Send a byte from the client to the server. The server will receive // the byte as a chunk. if (i > 0) { clientToServerStream.WriteByte(i); // 0 was already seeded when the stream was created above } Assert.Equal('1', serverStream.ReadByte()); Assert.Equal('\r', serverStream.ReadByte()); Assert.Equal('\n', serverStream.ReadByte()); Assert.Equal(i, serverStream.ReadByte()); Assert.Equal('\r', serverStream.ReadByte()); Assert.Equal('\n', serverStream.ReadByte()); // Send a byte from the server to the client. The client will receive // the byte on its own, with HttpClient stripping away the chunk encoding. serverStream.WriteByte(i); Assert.Equal(i, serverToClientStream.ReadByte()); } clientToServerStream.DoneWriting(); server.Shutdown(SocketShutdown.Send); Assert.Equal(-1, clientToServerStream.ReadByte()); } } }