/// <summary>
/// Invokes the Publish service.
/// </summary>
public virtual ResponseHeader Publish(
RequestHeader requestHeader,
SubscriptionAcknowledgementCollection subscriptionAcknowledgements,
out uint subscriptionId,
out UInt32Collection availableSequenceNumbers,
out bool moreNotifications,
out NotificationMessage notificationMessage,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
subscriptionId = 0;
availableSequenceNumbers = null;
moreNotifications = false;
notificationMessage = null;
results = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
/// <summary>
/// Invokes the Republish service.
/// </summary>
public virtual ResponseHeader Republish(
RequestHeader requestHeader,
uint subscriptionId,
uint retransmitSequenceNumber,
out NotificationMessage notificationMessage)
{
notificationMessage = null;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
/// <summary>
/// Finishes an asynchronous invocation of the Republish service.
/// </summary>
public ResponseHeader EndRepublish(
IAsyncResult result,
out NotificationMessage notificationMessage)
{
RepublishResponse response = null;
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.EndSendRequest(result);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (RepublishResponse)genericResponse;
}
else
{
RepublishResponseMessage responseMessage = InnerChannel.EndRepublish(result);
if (responseMessage == null || responseMessage.RepublishResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.RepublishResponse;
ValidateResponse(response.ResponseHeader);
}
notificationMessage = response.NotificationMessage;
}
finally
{
RequestCompleted(null, response, "Republish");
}
return response.ResponseHeader;
}
/// <summary>
/// Invokes the Republish service.
/// </summary>
public virtual ResponseHeader Republish(
RequestHeader requestHeader,
uint subscriptionId,
uint retransmitSequenceNumber,
out NotificationMessage notificationMessage)
{
RepublishRequest request = new RepublishRequest();
RepublishResponse response = null;
request.RequestHeader = requestHeader;
request.SubscriptionId = subscriptionId;
request.RetransmitSequenceNumber = retransmitSequenceNumber;
UpdateRequestHeader(request, requestHeader == null, "Republish");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (RepublishResponse)genericResponse;
}
else
{
RepublishResponseMessage responseMessage = InnerChannel.Republish(new RepublishMessage(request));
if (responseMessage == null || responseMessage.RepublishResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.RepublishResponse;
ValidateResponse(response.ResponseHeader);
}
notificationMessage = response.NotificationMessage;
}
finally
{
RequestCompleted(request, response, "Republish");
}
return response.ResponseHeader;
}
/// <summary>
/// Finishes an asynchronous invocation of the Publish service.
/// </summary>
public ResponseHeader EndPublish(
IAsyncResult result,
out uint subscriptionId,
out UInt32Collection availableSequenceNumbers,
out bool moreNotifications,
out NotificationMessage notificationMessage,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
PublishResponse response = null;
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.EndSendRequest(result);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (PublishResponse)genericResponse;
}
else
{
PublishResponseMessage responseMessage = InnerChannel.EndPublish(result);
if (responseMessage == null || responseMessage.PublishResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.PublishResponse;
ValidateResponse(response.ResponseHeader);
}
subscriptionId = response.SubscriptionId;
availableSequenceNumbers = response.AvailableSequenceNumbers;
moreNotifications = response.MoreNotifications;
notificationMessage = response.NotificationMessage;
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(null, response, "Publish");
}
return response.ResponseHeader;
}
/// <summary>
/// Invokes the Publish service.
/// </summary>
public virtual ResponseHeader Publish(
RequestHeader requestHeader,
SubscriptionAcknowledgementCollection subscriptionAcknowledgements,
out uint subscriptionId,
out UInt32Collection availableSequenceNumbers,
out bool moreNotifications,
out NotificationMessage notificationMessage,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
PublishRequest request = new PublishRequest();
PublishResponse response = null;
request.RequestHeader = requestHeader;
request.SubscriptionAcknowledgements = subscriptionAcknowledgements;
UpdateRequestHeader(request, requestHeader == null, "Publish");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (PublishResponse)genericResponse;
}
else
{
PublishResponseMessage responseMessage = InnerChannel.Publish(new PublishMessage(request));
if (responseMessage == null || responseMessage.PublishResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.PublishResponse;
ValidateResponse(response.ResponseHeader);
}
subscriptionId = response.SubscriptionId;
availableSequenceNumbers = response.AvailableSequenceNumbers;
moreNotifications = response.MoreNotifications;
notificationMessage = response.NotificationMessage;
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(request, response, "Publish");
}
return response.ResponseHeader;
}
/// <summary>
/// Dispatches a notification message produced by a subscription.
/// </summary>
private void DispatchMessage(Subscription subscription, NotificationMessage notification)
{
lock (m_messages)
{
for (LinkedListNode<QueuedRequest> node = m_requests.First; node != null; node = node.Next)
{
// wake up timed out requests and force them to return a fault.
if (node.Value.Timeout < DateTime.UtcNow)
{
node.Value.Signal.Set();
m_requests.Remove(node);
continue;
}
// check for a request that matches the session.
if (Object.ReferenceEquals(subscription.Session, node.Value.Session))
{
// pass the message to the request and wake up the request thread.
node.Value.SubscriptionId = subscription.Id;
node.Value.Message = notification;
node.Value.Signal.Set();
m_requests.Remove(node);
return;
}
}
// messages only go on the publish queue if no threads are waiting.
QueuedMessage message = new QueuedMessage();
message.Session = subscription.Session;
message.Subscription = subscription;
message.Message = notification;
m_messages.AddLast(message);
// ensure queue does not grow too large.
while (m_messages.Count > 50)
{
m_messages.RemoveFirst();
}
}
}
