public Subscription(string id, QueryStream queryStream, ChannelWriter <OperationMessage> output,
CancellationTokenSource cancellationTokenSource)
{
ID = id;
QueryStream = queryStream;
Unsubscribe = cancellationTokenSource;
}
public QueryObject GetObject(Query Query)
{
using (var Stream = new QueryStream())
{
Stream.Push(Query);
return(Stream.Pop(this));
}
}
private async Task <QueryStream> SubscribeAsync(
ExecutionOptions options,
CancellationToken cancellationToken)
{
if (!cancellationToken.CanBeCanceled)
{
throw new InvalidOperationException(
"Invalid cancellation token. To unsubscribe the provided cancellation token must be cancellable.");
}
var unsubscribeSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
var result = await Executor.SubscribeAsync(options, unsubscribeSource.Token);
_logger.Subscribed(options.OperationName, options.VariableValues, null);
unsubscribeSource.Token.Register(() =>
{
_logger?.Unsubscribed(
options.OperationName,
options.VariableValues,
null);
});
if (result.Errors != null && result.Errors.Any())
{
if (_logger.IsEnabled(LogLevel.Debug))
{
foreach (var error in result.Errors)
{
_logger.LogError($"GraphQL ERROR: '{error.Message}', Path: '{error.Path}'");
}
}
var channel = Channel.CreateBounded <ExecutionResult>(1);
await channel.Writer.WriteAsync(new ExecutionResult
{
Errors = result.Errors.ToList(),
Extensions = result.Extensions.ToDictionary(kv => kv.Key, kv => kv.Value)
}, CancellationToken.None);
channel.Writer.TryComplete();
// unsubscribe
unsubscribeSource.Cancel();
return(new QueryStream(channel.Reader));
}
var stream = new QueryStream(result.Source);
return(stream);
}
public override async Task <IQueryStream <TElement> > ExecuteQueryStreamedAsync <TElement>(
TableQuery <TElement> query, TableRequestOptions requestOptions = null, OperationContext operationContext = null)
{
if (query.SelectColumns != null)
{
throw new NotImplementedException("select");
}
if (query.TakeCount != null)
{
throw new NotImplementedException("top");
}
var stream = new QueryStream <TElement>(this, query, requestOptions, operationContext);
await stream.StartAsync();
return(stream);
}
public Stack <QueryObject> GetObjects(params Query[] Querys)
{
Stack <QueryObject> Stack = new Stack <QueryObject>();
using (var Stream = new QueryStream())
{
foreach (var Query in Querys)
{
Stream.Push(Query);
}
for (int i = 0; i <= Stream.Querys.Count; i++)
{
Stack.Push(Stream.Pop(this));
}
}
return(Stack);
}
public bool GetCharacter(string Ticket, out Character Character)
{
Character = null;
using (var Stream = new QueryStream("SELECT * FROM characters WHERE auth_ticket = @ticket LIMIT 1"))
{
Stream.AddParameter("ticket", Ticket);
var DataRow = Stream.Excecute<DataRow>();
if (DataRow == default(DataRow))
{
return false;
}
Character = new Character(DataRow);
}
return true;
}
public async Task Stop()
{
/* Given */
var output = Channel.CreateUnbounded <OperationMessage>();
var queryStreamService = Substitute.For <IQueryStreamService>();
var queryStream = Channel.CreateUnbounded <ExecutionResult>();
var queryResult = new QueryStream(queryStream);
queryStreamService.QueryAsync(null, default)
.ReturnsForAnyArgs(ci =>
{
ci.Arg <CancellationToken>().Register(() => queryStream.Writer.Complete());
return(queryResult);
});
var sut = CreateSut(queryStreamService);
var message = new OperationMessage
{
Id = "1",
Type = MessageType.GQL_START,
Payload = new OperationMessageQueryPayload()
};
var context = new MessageContext(message, output);
await sut.Handle(context);
/* When */
await sut.Handle(new MessageContext(new OperationMessage()
{
Id = "1",
Type = MessageType.GQL_STOP
}, output));
/* Then */
var subscription = sut.GetSubscription(message.Id);
Assert.Equal(default, subscription);
private async Task <List <T> > ToListAsync <T>(
QueryStream createStreamQuery,
Query <T> createQuery,
string queryText,
QueryRequestOptions requestOptions)
{
HttpStatusCode expectedStatus = HttpStatusCode.OK;
FeedIterator feedStreamIterator = createStreamQuery(queryText, null, requestOptions);
List <T> streamResults = new List <T>();
while (feedStreamIterator.HasMoreResults)
{
ResponseMessage response = await feedStreamIterator.ReadNextAsync();
response.EnsureSuccessStatusCode();
Assert.AreEqual(expectedStatus, response.StatusCode);
StreamReader sr = new StreamReader(response.Content);
string result = await sr.ReadToEndAsync();
ICollection <T> responseResults;
responseResults = JsonConvert.DeserializeObject <CosmosFeedResponseUtil <T> >(result).Data;
Assert.IsTrue(responseResults.Count <= 1);
streamResults.AddRange(responseResults);
}
string continuationToken = null;
List <T> pagedStreamResults = new List <T>();
do
{
FeedIterator pagedFeedIterator = createStreamQuery(queryText, continuationToken, requestOptions);
ResponseMessage response = await pagedFeedIterator.ReadNextAsync();
response.EnsureSuccessStatusCode();
Assert.AreEqual(expectedStatus, response.StatusCode);
IEnumerable <T> responseResults = TestCommon.SerializerCore.FromStream <CosmosFeedResponseUtil <T> >(response.Content).Data;
Assert.IsTrue(responseResults.Count() <= 1);
pagedStreamResults.AddRange(responseResults);
continuationToken = response.Headers.ContinuationToken;
Assert.AreEqual(response.ContinuationToken, response.Headers.ContinuationToken);
} while (continuationToken != null);
Assert.AreEqual(pagedStreamResults.Count, streamResults.Count);
// Both lists should be the same if not PermssionsProperties. PermissionProperties will have a different ResouceToken in the payload when read.
string streamResultString = JsonConvert.SerializeObject(streamResults);
string streamPagedResultString = JsonConvert.SerializeObject(pagedStreamResults);
if (typeof(T) != typeof(PermissionProperties))
{
Assert.AreEqual(streamPagedResultString, streamResultString);
}
FeedIterator <T> feedIterator = createQuery(queryText, null, requestOptions);
List <T> results = new List <T>();
while (feedIterator.HasMoreResults)
{
FeedResponse <T> response = await feedIterator.ReadNextAsync();
Assert.AreEqual(expectedStatus, response.StatusCode);
Assert.IsTrue(response.Count <= 1);
Assert.IsTrue(response.Resource.Count() <= 1);
results.AddRange(response);
}
continuationToken = null;
List <T> pagedResults = new List <T>();
do
{
FeedIterator <T> pagedFeedIterator = createQuery(queryText, continuationToken, requestOptions);
FeedResponse <T> response = await pagedFeedIterator.ReadNextAsync();
Assert.AreEqual(expectedStatus, response.StatusCode);
Assert.IsTrue(response.Count <= 1);
Assert.IsTrue(response.Resource.Count() <= 1);
pagedResults.AddRange(response);
continuationToken = response.ContinuationToken;
} while (continuationToken != null);
Assert.AreEqual(pagedResults.Count, results.Count);
// Both lists should be the same
string resultString = JsonConvert.SerializeObject(results);
string pagedResultString = JsonConvert.SerializeObject(pagedResults);
if (typeof(T) != typeof(PermissionProperties))
{
Assert.AreEqual(pagedResultString, resultString);
Assert.AreEqual(streamPagedResultString, resultString);
}
return(results);
}
private async Task <List <T> > ToListAsync <T>(
QueryStream createStreamQuery,
Query <T> createQuery,
string queryText,
QueryRequestOptions requestOptions)
{
FeedIterator feedStreamIterator = createStreamQuery(queryText, null, requestOptions);
List <T> streamResults = new List <T>();
while (feedStreamIterator.HasMoreResults)
{
ResponseMessage response = await feedStreamIterator.ReadNextAsync();
response.EnsureSuccessStatusCode();
StreamReader sr = new StreamReader(response.Content);
string result = await sr.ReadToEndAsync();
ICollection <T> responseResults = JsonConvert.DeserializeObject <CosmosFeedResponseUtil <T> >(result).Data;
Assert.IsTrue(responseResults.Count <= 1);
streamResults.AddRange(responseResults);
}
string continuationToken = null;
List <T> pagedStreamResults = new List <T>();
do
{
FeedIterator pagedFeedIterator = createStreamQuery(queryText, continuationToken, requestOptions);
ResponseMessage response = await pagedFeedIterator.ReadNextAsync();
response.EnsureSuccessStatusCode();
ICollection <T> responseResults = TestCommon.Serializer.FromStream <CosmosFeedResponseUtil <T> >(response.Content).Data;
Assert.IsTrue(responseResults.Count <= 1);
pagedStreamResults.AddRange(responseResults);
continuationToken = response.Headers.ContinuationToken;
Assert.AreEqual(response.ContinuationToken, response.Headers.ContinuationToken);
} while (continuationToken != null);
Assert.AreEqual(pagedStreamResults.Count, streamResults.Count);
// Both lists should be the same
string streamResultString = JsonConvert.SerializeObject(streamResults);
string streamPagedResultString = JsonConvert.SerializeObject(pagedStreamResults);
Assert.AreEqual(streamPagedResultString, streamResultString);
FeedIterator <T> feedIterator = createQuery(queryText, null, requestOptions);
List <T> results = new List <T>();
while (feedIterator.HasMoreResults)
{
FeedResponse <T> iterator = await feedIterator.ReadNextAsync();
Assert.IsTrue(iterator.Count <= 1);
Assert.IsTrue(iterator.Resource.Count() <= 1);
results.AddRange(iterator);
}
continuationToken = null;
List <T> pagedResults = new List <T>();
do
{
FeedIterator <T> pagedFeedIterator = createQuery(queryText, continuationToken, requestOptions);
FeedResponse <T> iterator = await pagedFeedIterator.ReadNextAsync();
Assert.IsTrue(iterator.Count <= 1);
Assert.IsTrue(iterator.Resource.Count() <= 1);
pagedResults.AddRange(iterator);
continuationToken = iterator.ContinuationToken;
} while (continuationToken != null);
Assert.AreEqual(pagedResults.Count, results.Count);
// Both lists should be the same
string resultString = JsonConvert.SerializeObject(results);
string pagedResultString = JsonConvert.SerializeObject(pagedResults);
Assert.AreEqual(pagedResultString, resultString);
Assert.AreEqual(streamPagedResultString, resultString);
return(results);
}
internal Subscriber(QueryStream <TElement> outer)
{
this.outer = outer;
}
