/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <WMLS_GetVersion> )
{
HandleResponseMessage(request as EtpMessage <WMLS_GetVersion>, message, OnWMLS_GetVersionResponse, HandleWMLS_GetVersionResponse);
}
else if (request is EtpMessage <WMLS_GetCap> )
{
HandleResponseMessage(request as EtpMessage <WMLS_GetCap>, message, OnWMLS_GetCapResponse, HandleWMLS_GetCapResponse);
}
else if (request is EtpMessage <WMLS_GetBaseMsg> )
{
HandleResponseMessage(request as EtpMessage <WMLS_GetBaseMsg>, message, OnWMLS_GetBaseMsgResponse, HandleWMLS_GetBaseMsgResponse);
}
else if (request is EtpMessage <WMLS_GetFromStore> )
{
HandleResponseMessage(request as EtpMessage <WMLS_GetFromStore>, message, OnWMLS_GetFromStoreResponse, HandleWMLS_GetFromStoreResponse);
}
else if (request is EtpMessage <WMLS_AddToStore> )
{
HandleResponseMessage(request as EtpMessage <WMLS_AddToStore>, message, OnWMLS_AddToStoreResponse, HandleWMLS_AddToStoreResponse);
}
else if (request is EtpMessage <WMLS_UpdateInStore> )
{
HandleResponseMessage(request as EtpMessage <WMLS_UpdateInStore>, message, OnWMLS_UpdateInStoreResponse, HandleWMLS_UpdateInStoreResponse);
}
else if (request is EtpMessage <WMLS_DeleteFromStore> )
{
HandleResponseMessage(request as EtpMessage <WMLS_DeleteFromStore>, message, OnWMLS_DeleteFromStoreResponse, HandleWMLS_DeleteFromStoreResponse);
}
}
/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <Start> )
{
HandleResponseMessage(request as EtpMessage <Start>, message, OnStartException, HandleStartException);
}
else if (request is EtpMessage <ChannelStreamingStart> )
{
HandleResponseMessage(request as EtpMessage <ChannelStreamingStart>, message, OnChannelStreamingStartException, HandleChannelStreamingStartException);
}
else if (request is EtpMessage <ChannelStreamingStop> )
{
HandleResponseMessage(request as EtpMessage <ChannelStreamingStop>, message, OnChannelStreamingStopException, HandleChannelStreamingStopException);
}
else if (request is EtpMessage <ChannelDescribe> )
{
HandleResponseMessage(request as EtpMessage <ChannelDescribe>, message, OnBasicStreamerChannelMetadata, HandleBasicStreamerChannelMetadata);
}
else if (request is EtpMessage <ChannelRangeRequest> )
{
HandleResponseMessage(request as EtpMessage <ChannelRangeRequest>, message, OnChannelRangeRequestChannelData, HandleChannelRangeRequestChannelData);
}
}
/// <summary>
/// Handles the Chunk message from a store.
/// </summary>
/// <param name="message">The Chunk message.</param>
protected virtual void HandleChunk(EtpMessage <Chunk> message)
{
var notification = TryGetCorrelatedMessage <ObjectChanged>(message);
var subscription = notification == null ? null : TryGetSubscription <SubscriptionInfo>(notification.Body);
HandleNotificationMessage(subscription, notification, OnObjectChangedChunk, HandleObjectChangedChunk,
args: new NotificationWithDataEventArgs <SubscriptionInfo, ObjectChanged, Chunk>(subscription, notification, message));
}
/// <summary>
/// Handles the Chunk message from a customer.
/// </summary>
/// <param name="message">The Chunk message.</param>
protected virtual void HandleChunk(EtpMessage <Chunk> message)
{
var request = TryGetCorrelatedMessage <PutDataObjects>(message);
HandleRequestMessage(request, OnPutDataObjectsChunk, HandlePutDataObjectsChunk,
args: new MapRequestWithDataEventArgs <PutDataObjects, Chunk, PutResponse>(request, message),
responseMethod: (args) => PutDataObjectsResponse(args.Request?.Header, args.ResponseMap, isFinalPart: !args.HasErrors, extension: args.ResponseMapExtension));
}
/// <summary>
/// Handles the ReplaceRange message from a customer.
/// </summary>
/// <param name="message">The ReplaceRange message.</param>
protected virtual void HandleReplaceRange(EtpMessage <ReplaceRange> message)
{
HandleRequestMessage(message, OnReplaceRange, HandleReplaceRange,
responseMethod: (args) => { if (!args.HasErrors)
{
ReplaceRangeResponse(args.Request?.Header, args.Response, extension: args.ResponseExtension);
}
});
}
/// <summary>
/// Handles the ChannelMetadata message from a producer.
/// </summary>
/// <param name="message">The ChannelMetadata message.</param>
protected virtual void HandleChannelMetadata(EtpMessage <ChannelMetadata> message)
{
foreach (var channel in message.Body.Channels)
{
ChannelMetadataRecords.Add(channel);
}
HandleFireAndForgetMessage(message, OnChannelMetadata, HandleChannelMetadata);
}
/// <summary>
/// Handles the PutDataObjects message from a customer.
/// </summary>
/// <param name="message">The PutDataObjects message.</param>
protected virtual void HandlePutDataObjects(EtpMessage <PutDataObjects> message)
{
if (!message.Header.IsFinalPart())
{
TryRegisterMessage(message);
}
HandleRequestMessage(message, OnPutDataObjects, HandlePutDataObjects,
responseMethod: (args) => PutDataObjectsResponse(args.Request?.Header, args.ResponseMap, isFinalPart: !args.HasErrors, extension: args.ResponseMapExtension));
}
/// <summary>
/// Handles the CancelNotification message from a customer.
/// </summary>
/// <param name="message">The CancelNotification message.</param>
protected virtual void HandleCancelNotification(EtpMessage <CancelNotification> message)
{
var error = TryUnregisterSubscription(message.Body, nameof(message.Body.RequestUuid), message);
HandleRequestMessage(message, OnCancelNotification, HandleCancelNotification,
args: new VoidRequestEventArgs <CancelNotification>(message)
{
FinalError = error
});
}
/// <summary>
/// Handles the NotificationRequest message from a customer.
/// </summary>
/// <param name="message">The NotificationRequest message.</param>
protected virtual void HandleNotificationRequest(EtpMessage <NotificationRequest> message)
{
var error = TryRegisterSubscription(message.Body.Request, nameof(message.Body.Request.Uuid), message, message.Body.Request);
HandleRequestMessage(message, OnNotificationRequest, HandleNotificationRequest,
args: new VoidRequestEventArgs <NotificationRequest>(message)
{
FinalError = error
});
}
/// <summary>
/// Handles the GetRanges message from a customer.
/// </summary>
/// <param name="message">The GetRanges message.</param>
protected virtual void HandleGetRanges(EtpMessage <GetRanges> message)
{
var error = TryRegisterRequest(message.Body, nameof(message.Body.RequestUuid), message);
HandleRequestMessage(message, OnGetRanges, HandleGetRanges,
args: new ListRequestEventArgs <GetRanges, DataItem>(message)
{
FinalError = error
},
responseMethod: (args) => GetRangesResponse(args.Request?.Header, message.Body.RequestUuid, args.Responses, isFinalPart: !args.HasErrors, unregisterRequest: true, extension: args.ResponseExtension));
}
/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <RenewSecurityToken> )
{
HandleResponseMessage(request as EtpMessage <RenewSecurityToken>, message, OnRenewSecurityTokenException, HandleRenewSecurityTokenException);
}
}
/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage <GetResources>(message);
if (request != null)
{
HandleResponseMessage(request, message, OnGetResourcesResponse, HandleGetResourcesResponse);
}
}
/// <summary>
/// Handles the ObjectChanged message from a store.
/// </summary>
/// <param name="message">The ObjectChanged message.</param>
protected virtual void HandleObjectChanged(EtpMessage <ObjectChanged> message)
{
var subscription = TryGetSubscription <SubscriptionInfo>(message.Body);
if (!message.Header.IsFinalPart())
{
TryRegisterMessage(message);
}
HandleNotificationMessage(subscription, message, OnObjectChanged, HandleObjectChanged);
}
/// <summary>
/// Handles the GetChannelMetadataResponse message from a store.
/// </summary>
/// <param name="message">The GetChannelMetadataResponse message.</param>
protected virtual void HandleGetChannelMetadataResponse(EtpMessage <GetChannelMetadataResponse> message)
{
foreach (var channel in message.Body.Metadata.Values)
{
ChannelMetadataRecords.Add(channel);
}
var request = TryGetCorrelatedMessage <GetChannelMetadata>(message);
HandleResponseMessage(request, message, OnGetChannelMetadataResponse, HandleGetChannelMetadataResponse);
}
/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <RequestChannelData> )
{
HandleResponseMessage(request as EtpMessage <RequestChannelData>, message, OnRequestChannelDataResponse, HandleRequestChannelDataResponse);
}
}
/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <FindParts> )
{
HandleResponseMessage(request as EtpMessage <FindParts>, message, OnFindPartsResponse, HandleFindPartsResponse);
}
}
/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <Authorize> )
{
HandleResponseMessage(request as EtpMessage <Authorize>, message, OnAuthorizeResponse, HandleAuthorizeResponse);
}
}
/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <GetSupportedTypes> )
{
HandleResponseMessage(request as EtpMessage <GetSupportedTypes>, message, OnGetSupportedTypesResponse, HandleGetSupportedTypesResponse);
}
}
/// <summary>
/// Handles the GetFrame message from a customer.
/// </summary>
/// <param name="message">The GetFrame message.</param>
protected virtual void HandleGetFrame(EtpMessage <GetFrame> message)
{
var error = TryRegisterRequest(message.Body, nameof(message.Body.RequestUuid), message);
HandleRequestMessage(message, OnGetFrame, HandleGetFrame,
args: new SingleAndListRequestEventArgs <GetFrame, FrameHeader, FrameRow>(message)
{
FinalError = error
},
responseMethod: (args) => GetFrameResponse(args.Request?.Header, message.Body.RequestUuid, args.Response1.Indexes, args.Response1.ChannelUris, args.Responses2, setFinalPart: !args.HasErrors, unregisterRequest: true, headerExtension: args.Response1Extension, rowsExtension: args.Response2Extension));
}
/// <summary>
/// Handles the CancelGetFrame message from a customer.
/// </summary>
/// <param name="message">The CancelGetFrame message.</param>
protected virtual void HandleCancelGetFrame(EtpMessage <CancelGetFrame> message)
{
EtpMessage <GetFrame> request;
var error = TryGetRequest(message.Body, nameof(message.Body.RequestUuid), message, out request);
HandleCancellationMessage(request, message, OnCancelGetFrame, HandleCancelGetFrame,
args: new CancellationRequestEventArgs <GetFrame, CancelGetFrame>(request, message)
{
FinalError = error
});
}
/// <summary>
/// Handles the UnsolicitedPartNotifications message from a store.
/// </summary>
/// <param name="message">The UnsolicitedPartNotifications message.</param>
protected virtual void HandleUnsolicitedPartNotifications(EtpMessage <UnsolicitedPartNotifications> message)
{
if (message.Body.Subscriptions?.Count > 0)
{
foreach (var subscription in message.Body.Subscriptions)
{
TryRegisterSubscription(subscription, nameof(subscription.RequestUuid), message, subscription);
}
}
HandleFireAndForgetMessage(message, OnUnsolicitedPartNotifications, HandleUnsolicitedPartNotifications);
}
/// <summary>
/// Handles the SubscribePartNotifications message from a customer.
/// </summary>
/// <param name="message">The SubscribePartNotifications message.</param>
protected virtual void HandleSubscribePartNotifications(EtpMessage <SubscribePartNotifications> message)
{
var errors = TryRegisterSubscriptions(message, message.Body.Request, nameof(message.Body.Request));
HandleRequestMessage(message, OnSubscribePartNotifications, HandleSubscribePartNotifications,
args: new MapRequestEventArgs <SubscribePartNotifications, string>(message)
{
ErrorMap = errors
},
responseMethod: (args) => SubscribePartNotificationsResponse(args.Request?.Header, args.ResponseMap, isFinalPart: !args.HasErrors, extension: args.ResponseMapExtension));
}
/// <summary>
/// Handles the ChannelsClosed message from a stor.
/// </summary>
/// <param name="message">The ChannelsClosed message.</param>
protected virtual void HandleChannelsClosed(EtpMessage <ChannelsClosed> message)
{
if (message.Header.CorrelationId == 0)
{
HandleFireAndForgetMessage(message, OnNotificationChannelsClosed, HandleNotificationChannelsClosed);
}
else
{
var request = TryGetCorrelatedMessage <CloseChannels>(message);
HandleResponseMessage(request, message, OnResponseChannelsClosed, HandleResponseChannelsClosed);
}
}
/// <summary>
/// Handles the SubscriptionsStopped message from a store.
/// </summary>
/// <param name="message">The SubscriptionsStopped message.</param>
protected virtual void HandleSubscriptionsStopped(EtpMessage <SubscriptionsStopped> message)
{
if (message.Header.CorrelationId == 0)
{
HandleFireAndForgetMessage(message, OnNotificationSubscriptionsStopped, HandleNotificationSubscriptionsStopped);
}
else
{
var request = TryGetCorrelatedMessage <UnsubscribeChannels>(message);
HandleResponseMessage(request, message, OnResponseSubscriptionsStopped, HandleResponseSubscriptionsStopped);
}
}
/// <summary>
/// Handles the ChannelData message from a producer.
/// </summary>
/// <param name="message">The ChannelData message.</param>
protected virtual void HandleChannelData(EtpMessage <ChannelData> message)
{
if (message.Header.CorrelationId == 0)
{
HandleFireAndForgetMessage(message, OnStreamingChannelData, HandleStreamingChannelData);
}
else
{
var request = TryGetCorrelatedMessage <ChannelRangeRequest>(message);
HandleResponseMessage(request, message, OnChannelRangeRequestChannelData, HandleChannelRangeRequestChannelData);
}
}
/// <summary>
/// Handles the PartSubscriptionEnded message from a store.
/// </summary>
/// <param name="message">The PartSubscriptionEnded message.</param>
protected virtual void HandlePartSubscriptionEnded(EtpMessage <PartSubscriptionEnded> message)
{
if (message.Header.CorrelationId == 0)
{
var subscription = TryGetSubscription <SubscriptionInfo>(message.Body);
HandleNotificationMessage(subscription, message, OnNotificationPartSubscriptionEnded, HandleNotificationPartSubscriptionEnded);
}
else
{
var request = TryGetCorrelatedMessage <UnsubscribePartNotification>(message);
HandleResponseMessage(request, message, OnResponsePartSubscriptionEnded, HandleResponsePartSubscriptionEnded);
}
}
/// <summary>
/// Handles the ObjectFragment message from a store.
/// </summary>
/// <param name="message">The ObjectFragment message.</param>
protected virtual void HandleObjectFragment(EtpMessage <ObjectFragment> message)
{
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <GrowingObjectGet> )
{
HandleResponseMessage(request as EtpMessage <GrowingObjectGet>, message, OnGrowingObjectGetObjectFragment, HandleGrowingObjectGetObjectFragment);
}
else if (request is EtpMessage <GrowingObjectGetRange> )
{
HandleResponseMessage(request as EtpMessage <GrowingObjectGetRange>, message, OnGrowingObjectGetRangeObjectFragment, HandleGrowingObjectGetRangeObjectFragment);
}
}
/// <summary>
/// Handles the DataArray message from a store.
/// </summary>
/// <param name="header">The message header.</param>
protected virtual void HandleDataArray(EtpMessage <DataArray> message)
{
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <GetDataArray> )
{
HandleResponseMessage(request as EtpMessage <GetDataArray>, message, OnGetDataArrayDataArray, HandleGetDataArrayDataArray);
}
else if (request is EtpMessage <GetDataArraySlice> )
{
HandleResponseMessage(request as EtpMessage <GetDataArraySlice>, message, OnGetDataArraySliceDataArray, HandleGetDataArraySliceDataArray);
}
}
/// <summary>
/// Handles the ProtocolException message.
/// </summary>
/// <param name="message">The message.</param>
protected override void HandleProtocolException(EtpMessage <IProtocolException> message)
{
base.HandleProtocolException(message);
var request = TryGetCorrelatedMessage(message);
if (request is EtpMessage <SubscribePartNotifications> )
{
HandleResponseMessage(request as EtpMessage <SubscribePartNotifications>, message, OnSubscribePartNotificationsResponse, HandleSubscribePartNotificationsResponse);
}
else if (request is EtpMessage <UnsubscribePartNotification> )
{
HandleResponseMessage(request as EtpMessage <UnsubscribePartNotification>, message, OnResponsePartSubscriptionEnded, HandleResponsePartSubscriptionEnded);
}
}
/// <summary>
/// Handles the UnsubscribePartNotification message from a customer.
/// </summary>
/// <param name="message">The UnsubscribePartNotification message.</param>
protected virtual void HandleUnsubscribePartNotification(EtpMessage <UnsubscribePartNotification> message)
{
var error = TryUnregisterSubscription(message.Body, nameof(message.Body.RequestUuid), message);
HandleRequestMessage(message, OnUnsubscribePartNotification, HandleUnsubscribePartNotification,
args: new RequestWithContextEventArgs <UnsubscribePartNotification, Guid, PartSubscriptionEndedReason>(message)
{
FinalError = error
},
responseMethod: (args) => { if (!args.HasErrors)
{
ResponsePartSubscriptionEnded(args.Request?.Header, args.Response, args.Context.Reason, extension: args.ResponseExtension);
}
});
}