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());
}
}
}
