/// <summary>
/// Initializes a new instance of the <see cref="ApolloClientMessageReceivedLogEntry"/> class.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="message">The message.</param>
public ApolloClientMessageReceivedLogEntry(ISubscriptionClientProxy client, ApolloMessage message)
: base(ApolloLogEventIds.ClientMessageReceived)
{
this.ClientId = client.Id;
this.MessageType = message.Type.ToString();
this.MessageId = message.Id;
}
/// <summary>
/// Initializes a new instance of the <see cref="ApolloClientSubscriptionCreatedLogEntry" /> class.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="subscription">The subscription that was created.</param>
public ApolloClientSubscriptionCreatedLogEntry(ISubscriptionClientProxy client, ISubscription subscription)
: base(ApolloLogEventIds.ClientSubscriptionStarted)
{
this.ClientId = client.Id;
this.SubscriptionId = subscription.Id;
this.Route = subscription.Route.Path;
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionClientDroppedLogEntry"/> class.
/// </summary>
/// <param name="client">The client.</param>
public SubscriptionClientDroppedLogEntry(ISubscriptionClientProxy client)
: base(SubscriptionLogEventIds.SubscriptionClientDropped)
{
_clientTypeShortName = client.GetType().FriendlyName();
this.ClientTypeName = client.GetType().FriendlyName(true);
this.ClientId = client.Id;
}
/// <summary>
/// Recorded when a subscription client is no longer connected or otherwise dropped
/// by ASP.NET. The server will process no more messages from the client.
/// </summary>
/// <param name="logger">The logger doing the logging.</param>
/// <param name="client">The client that was dropped and is being cleaned up.</param>
public static void SubscriptionClientDropped(
this IGraphEventLogger logger,
ISubscriptionClientProxy client)
{
logger.Log(
LogLevel.Debug,
() => new SubscriptionClientDroppedLogEntry(client));
}
/// <summary>
/// Recorded when a new client is registered against a subscription server and
/// the graphql server begins monitoring it for messages.
/// </summary>
/// <typeparam name="TSchema">The type of the schema the client was registered for.</typeparam>
/// <param name="logger">The logger doing the logging.</param>
/// <param name="server">The server which created the client.</param>
/// <param name="client">The client that was created.</param>
public static void SubscriptionClientRegistered <TSchema>(
this IGraphEventLogger logger,
ISubscriptionServer <TSchema> server,
ISubscriptionClientProxy client)
where TSchema : class, ISchema
{
logger.Log(
LogLevel.Debug,
() => new SubscriptionClientRegisteredLogEntry <TSchema>(server, client));
}
/// <summary>
/// Initializes a new instance of the <see cref="SubcriptionExecutionContext" /> class.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="request">The request to be processed through the query pipeline.</param>
/// <param name="subscriptionId">The unique id to assign to the created subscription, when one is made.</param>
/// <param name="metrics">The metrics package to profile this request, if any.</param>
/// <param name="logger">The logger instance to record events related to this context.</param>
/// <param name="items">A key/value pair collection for random access data.</param>
public SubcriptionExecutionContext(
ISubscriptionClientProxy client,
IGraphOperationRequest request,
string subscriptionId,
IGraphQueryExecutionMetrics metrics = null,
IGraphEventLogger logger = null,
MetaDataCollection items = null)
: base(request, client?.ServiceProvider, client?.User, metrics, logger, items)
{
this.Client = Validation.ThrowIfNullOrReturn(client, nameof(client));
this.SubscriptionId = Validation.ThrowIfNullWhiteSpaceOrReturn(subscriptionId, nameof(subscriptionId));
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionClientRegisteredLogEntry{TSchema}" /> class.
/// </summary>
/// <param name="server">The server which created teh client.</param>
/// <param name="client">The client that was created.</param>
public SubscriptionClientRegisteredLogEntry(
ISubscriptionServer <TSchema> server,
ISubscriptionClientProxy client)
: base(SubscriptionLogEventIds.SubscriptionClientRegistered)
{
_clientTypeShortName = client.GetType().FriendlyName();
_schemaTypeShortName = typeof(TSchema).FriendlyName();
this.SchemaTypeName = typeof(TSchema).FriendlyName(true);
this.ClientTypeName = client.GetType().FriendlyName(true);
this.ServerTypeName = server.GetType().FriendlyName(true);
this.ClientId = client.Id;
this.ServerId = server.Id;
}
/// <summary>
/// Initializes a new instance of the <see cref="SubscriptionContextBuilder" /> class.
/// </summary>
/// <param name="client">The client.</param>
public SubscriptionContextBuilder(ISubscriptionClientProxy client)
{
_client = client;
_mockRequest = new Mock <IGraphOperationRequest>();
_sourceData = new List <KeyValuePair <GraphFieldPath, object> >();
_mockRequest.Setup(x => x.ToDataPackage()).Returns(
new AspNet.GraphQueryData()
{
Query = _mockRequest.Object.QueryText,
Variables = new InputVariableCollection(_mockRequest.Object.VariableData),
OperationName = _mockRequest.Object.OperationName,
});
}
private async Task ExecuteSubscriptionEvent(
ISubscriptionClientProxy client,
GraphFieldPath route,
object data,
CancellationToken cancelToken = default)
{
try
{
// execute the request through the runtime
await _eventSendSemaphore.WaitAsync().ConfigureAwait(false);
await client.ReceiveEvent(route, data, cancelToken).ConfigureAwait(false);
}
finally
{
_eventSendSemaphore.Release();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ApolloClientConnectionKeepAliveMonitor"/> class.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="interval">The interval.</param>
public ApolloClientConnectionKeepAliveMonitor(ISubscriptionClientProxy connection, TimeSpan interval)
{
_connection = Validation.ThrowIfNullOrReturn(connection, nameof(connection));
_interval = interval;
}
/// <summary>
/// Initializes a new instance of the <see cref="ClientSubscription{TSchema}" /> class.
/// </summary>
/// <param name="clientProxy">The client proxy that will own this subscription.</param>
/// <param name="originalQuerydata">The original querydata that generated this subscription.</param>
/// <param name="queryPlan">The query plan.</param>
/// <param name="selectedOperation">The selected operation from the query plan
/// from which to generate the subscription.</param>
/// <param name="subscriptionid">A unique id to assign to this subscription. A guid id
/// will be generated if this value is not supplied.</param>
public ClientSubscription(
ISubscriptionClientProxy clientProxy,
GraphQueryData originalQuerydata,
IGraphQueryPlan queryPlan,
IGraphFieldExecutableOperation selectedOperation,
string subscriptionid = null)
{
this.Client = Validation.ThrowIfNullOrReturn(clientProxy, nameof(clientProxy));
this.QueryData = Validation.ThrowIfNullOrReturn(originalQuerydata, nameof(originalQuerydata));
this.QueryOperation = Validation.ThrowIfNullOrReturn(selectedOperation, nameof(selectedOperation));
this.QueryPlan = Validation.ThrowIfNullOrReturn(queryPlan, nameof(queryPlan));
this.Messages = this.QueryPlan?.Messages ?? new GraphMessageCollection();
this.Id = string.IsNullOrWhiteSpace(subscriptionid)
? Guid.NewGuid().ToString("N")
: subscriptionid.Trim();
this.IsValid = false;
// parsing the query plan will garuntee that if the document contains
// a subscription that it contains only one operation and
// that a top level field will be a subscription-ready field.
//
// However, ensure that the operation that will be executed
// does in fact represent a subscription being harnesssed
if (this.QueryOperation.OperationType != GraphCollection.Subscription)
{
this.Messages.Critical(
$"The chosen operation is not a subscription operation.",
Constants.ErrorCodes.BAD_REQUEST);
return;
}
var currentContext = this.QueryOperation.FieldContexts[0];
// find the first non-virtual field referenced, it should be a controller
// its garunteed to exist via the document generation rule engine
// but it could be deep, walk down the subscirption tree to find it
while (currentContext?.Field != null)
{
// when pointing at a subscription field we're done
if (!currentContext.Field.IsVirtual)
{
this.Field = currentContext.Field as ISubscriptionGraphField;
break;
}
currentContext = currentContext?.ChildContexts.Count == 1 ? currentContext.ChildContexts?[0] : null;
}
// just in case it wasn't found...
// this is theoretically not possible but just in case
// the user swaps out some DI components incorrectly or by mistake...
if (this.Field == null)
{
this.Messages.Add(
GraphMessageSeverity.Critical,
"An eventable field could not found in the subscription operation. Ensure you include a field declared " +
"as a subscription field.",
Constants.ErrorCodes.BAD_REQUEST);
}
this.IsValid = this.Messages.IsSucessful && this.QueryOperation != null && this.Field != null;
}