public virtual BasicGetResult GetMessage(string queueName, bool noAck)
{
try
{
if (!Queues.Contains(queueName))
{
Channel.RegisterQueueByName(queueName);
Queues = new HashSet <string>(Queues)
{
queueName
};
}
var basicMsg = Channel.BasicGet(queueName, noAck: noAck);
GetMessageFilter?.Invoke(queueName, basicMsg);
return(basicMsg);
}
catch (OperationInterruptedException ex)
{
if (ex.Is404())
{
Channel.RegisterQueueByName(queueName);
return(Channel.BasicGet(queueName, noAck: noAck));
}
throw;
}
}
/// <summary>
/// Used in queries to read information from Twitter API endpoints.
/// </summary>
/// <param name="request">Request with url endpoint and all query parameters</param>
/// <param name="reqProc">Request Processor for Async Results</param>
/// <returns>Respose from Twitter</returns>
public async Task <string> QueryTwitterAsync <T>(Request request, IRequestProcessor <T> reqProc)
{
WriteLog(request.FullUrl, "QueryTwitterAsync");
var req = new HttpRequestMessage(HttpMethod.Get, new Uri(request.FullUrl));
var parms = request.RequestParameters
.ToDictionary(
key => key.Name,
val => val.Value);
var baseFilter = new HttpBaseProtocolFilter();
var handler = new GetMessageFilter(this, parms, request.FullUrl, baseFilter, CancellationToken);
using (var client = new HttpClient(handler))
{
var msg = await client.SendRequestAsync(req);
return(await HandleResponseAsync(msg).ConfigureAwait(false));
}
}
/// <summary>
/// Performs a query on the Twitter Stream.
/// </summary>
/// <param name="request">Request with url endpoint and all query parameters.</param>
/// <returns>
/// Caller expects an JSON formatted string response, but
/// real response(s) with streams is fed to the callback.
/// </returns>
public async Task <string> QueryTwitterStreamAsync(Request request)
{
const int CarriageReturn = 0x0D;
const int LineFeed = 0x0A;
const int EndOfStream = 0xFF;
WriteLog(request.FullUrl, "QueryTwitterStreamAsync");
IDictionary <string, string> reqParams =
request.RequestParameters.ToDictionary(key => key.Name, val => val.Value);
var baseFilter = new HttpBaseProtocolFilter
{
AutomaticDecompression = Authorizer.SupportsCompression,
ProxyCredential = Authorizer.ProxyCredential,
UseProxy = Authorizer.UseProxy
};
var streamFilter = new GetMessageFilter(this, reqParams, request.FullUrl, baseFilter, CancellationToken);
using (StreamingClient = new HttpClient(streamFilter))
{
var httpRequest = new HttpRequestMessage(HttpMethod.Get, new Uri(request.FullUrl));
var response = await StreamingClient.SendRequestAsync(
httpRequest, HttpCompletionOption.ResponseHeadersRead);
await TwitterErrorHandler.ThrowIfErrorAsync(response).ConfigureAwait(false);
var inputStream = await response.Content.ReadAsInputStreamAsync();
Stream stream = inputStream.AsStreamForRead();
var memStr = new MemoryStream();
byte[] readByte;
while (stream.CanRead && !IsStreamClosed)
{
readByte = new byte[1];
await stream.ReadAsync(readByte, 0, 1, CancellationToken).ConfigureAwait(false);
byte nextByte = readByte.SingleOrDefault();
CancellationToken.ThrowIfCancellationRequested();
if (IsStreamClosed)
{
break;
}
// TODO: review end-of-stream protocol
if (nextByte == EndOfStream)
{
break;
}
if (nextByte != CarriageReturn && nextByte != LineFeed)
{
memStr.WriteByte(nextByte);
}
if (nextByte == LineFeed)
{
int byteCount = (int)memStr.Length;
byte[] tweetBytes = new byte[byteCount];
memStr.Position = 0;
await memStr.ReadAsync(tweetBytes, 0, byteCount, CancellationToken).ConfigureAwait(false);
string tweet = Encoding.UTF8.GetString(tweetBytes, 0, byteCount);
var strmContent = new StreamContent(this, tweet);
await StreamingCallbackAsync(strmContent).ConfigureAwait(false);
memStr.Dispose();
memStr = new MemoryStream();
}
}
}
IsStreamClosed = false;
return("{}");
}
