private void AddNotUnderstoodHeaders(MessageHeaders headers)
{
for (int i = 0; i < _notUnderstoodHeaders.Count; ++i)
{
headers.Add(new NotUnderstoodHeader(_notUnderstoodHeaders[i].Name, _notUnderstoodHeaders[i].Namespace));
}
}
protected AdwsRequestMsg(string instance)
{
this._messageProperties = new MessageProperties();
this._messageHeaders = new MessageHeaders(this.Version, 7);
this.Headers.Action = this.Action;
this.Headers.Add(MessageHeader.CreateHeader("instance", "http://schemas.microsoft.com/2008/1/ActiveDirectory", instance));
}
public void AddHeaders(MessageHeaders headers)
{
if (headers.MessageVersion.Envelope == EnvelopeVersion.Soap11)
{
headers.Add(new WSAddressing10ProblemHeaderQNameHeader(this.invalidHeaderName));
}
}
public static CreateSequenceInfo ReadMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, ISecureConversationSession securitySession, Message message, MessageHeaders headers)
{
CreateSequenceInfo info;
if (message.IsEmpty)
{
string reason = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion) });
Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason)));
}
using (XmlDictionaryReader reader = message.GetReaderAtBodyContents())
{
info = CreateSequence.Create(messageVersion, reliableMessagingVersion, securitySession, reader);
message.ReadFromBodyContentsToEnd(reader);
}
info.SetMessageId(messageVersion, headers);
info.SetReplyTo(messageVersion, headers);
if (info.AcksTo.Uri != info.ReplyTo.Uri)
{
string str2 = System.ServiceModel.SR.GetString("CSRefusedAcksToMustEqualReplyTo");
Message message3 = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, str2);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(message3, str2, new ProtocolException(str2)));
}
info.to = message.Headers.To;
if ((info.to == null) && (messageVersion.Addressing == AddressingVersion.WSAddressing10))
{
info.to = messageVersion.Addressing.AnonymousUri;
}
return info;
}
public void ApplySecurityAndWriteHeaders(MessageHeaders headers, XmlDictionaryWriter writer, SecurityIdGenerator securityIdGenerator)
{
// There is no way to look through the headers attributes without changing the way
// Headers.WriterStartHeader / headers.writeHeadercontents writes the header
// So i'm using a copy that I can change without worries.
MessageHeaders copyHeaders = new MessageHeaders(headers);
for (int i = 0; i < headers.Count; i++)
{
MessageHeaderInfo header = headers[i];
// We are not supporting another d:Security header, throw if there is already one in the message
if (this.IsSecurityElement(header))
{
throw new ArgumentException("The message already contains a d:security header.");
}
if (this.ShouldProtectHeader(header))
{
string headerId;
bool idInserted;
this.GetHeaderId(copyHeaders.GetReaderAtHeader(i), securityIdGenerator, true, out headerId, out idInserted);
// Add a reference for this header
this.signer.AddReference(headers, i, writer, headerId, idInserted);
}
else
{
headers.WriteHeader(i, writer);
}
}
}
public static bool ExtractActivityAndCorrelationId(MessageHeaders headers, out Guid activityId, out Guid correlationId)
{
if (headers == null) throw new ArgumentNullException(nameof(headers));
activityId = Guid.Empty;
correlationId = Guid.Empty;
try
{
var index = headers.FindHeader("ActivityId", "http://schemas.microsoft.com/2004/09/ServiceModel/Diagnostics");
if (index >= 0)
{
using (var reader = headers.GetReaderAtHeader(index))
{
correlationId = new Guid(reader.GetAttribute("CorrelationId", null));
activityId = reader.ReadElementContentAsGuid();
return true;
}
}
}
catch
{
if (Debugger.IsAttached)
{
throw;
}
}
return false;
}
/// <summary>
/// Constructor.
/// </summary>
protected AmfMessageBase()
{
_properties = new MessageProperties();
//Make sure that there is no wrapping applied to this message
_headers = new MessageHeaders(MessageVersion.None);
}
private void AddNotUnderstoodHeaders(MessageHeaders headers)
{
for (int i = 0; i < this.notUnderstoodHeaders.Count; i++)
{
headers.Add(new NotUnderstoodHeader(this.notUnderstoodHeaders[i].Name, this.notUnderstoodHeaders[i].Namespace));
}
}
internal LocalByRefMessage(MessageVersion version, string action, int id)
: base()
{
this.headers = new MessageHeaders(version);
this.headers.Action = action;
this.data = id;
}
public AddressingProperty(MessageHeaders headers)
{
this.action = headers.Action;
this.to = headers.To;
this.replyTo = headers.ReplyTo;
this.messageId = headers.MessageId;
}
public void ReturnHeaders(MessageHeaders headers)
{
if (headers.CanRecycle)
{
headers.Recycle(this.HeaderInfoCache);
this.recycledHeaders = headers;
}
}
protected void SetMessageId(MessageVersion messageVersion, MessageHeaders headers)
{
this.messageId = headers.MessageId;
if (this.messageId == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(System.ServiceModel.SR.GetString("MissingMessageIdOnWsrmRequest", new object[] { this.RequestName }), messageVersion.Addressing.Namespace, "MessageID", false));
}
}
public void TestConstructor ()
{
MessageHeaders headers = new MessageHeaders (MessageVersion.Soap12WSAddressing10);
Assert.AreEqual (0, headers.Count);
headers = new MessageHeaders (MessageVersion.Default);
Assert.AreEqual (0, headers.Count);
}
internal DefaultMessageBuffer (int maxBufferSize, MessageHeaders headers, MessageProperties properties, BodyWriter body, bool isFault)
{
this.max_buffer_size = maxBufferSize;
this.headers = headers;
this.body = body;
this.closed = false;
this.is_fault = isFault;
this.properties = properties;
}
public AddressingProperty(MessageHeaders headers)
{
Fx.Assert(null != headers, "");
this.action = headers.Action;
this.to = headers.To;
this.replyTo = headers.ReplyTo;
this.messageId = headers.MessageId;
}
public DelegatingHeader(MessageHeaderInfo info, MessageHeaders originalHeaders)
{
Fx.Assert(info != null, "info is required");
Fx.Assert(originalHeaders != null, "originalHeaders is required");
this.info = info;
this.originalHeaders = originalHeaders;
this.index = -1;
}
internal ChunkingMessage(MessageVersion version, string action, ChunkingReader reader, Guid messageId)
{
this.version = version;
this.chunkReader = reader;
this.properties = new MessageProperties();
this.headers = new MessageHeaders(this.version);
this.headers.Action = action;
this.messageId = messageId;
}
public override void Close ()
{
if (closed)
return;
headers = null;
body = null;
closed = true;
}
public static RequestTotalItemsCountEstimate ReadFrom(MessageHeaders messageHeaders)
{
int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace);
if (index < 0)
{
return null;
}
MessageHeaderInfo headerInfo = messageHeaders[index];
return new RequestTotalItemsCountEstimate();
}
/// <summary>
/// Gets the data signature in the given message header collection
/// </summary>
/// <param name="headers">Message headers</param>
/// <returns>Data signature or Guid.Empty</returns>
public static Guid GetDataSignature(MessageHeaders headers)
{
Guid dataSignature = Guid.Empty;
int headerIndex = headers.FindHeader(Header.Name, Header.Namespace);
if (headerIndex != -1)
{
dataSignature = headers.GetHeader<Guid>(headerIndex);
}
return dataSignature;
}
public static Uri GetHeaderUri(MessageHeaders headers, string name, string ns)
{
Uri uri = null;
string uriString = GetHeaderString(headers, name, ns);
if (uriString != null)
{
uri = new Uri(uriString);
}
return uri;
}
public HttpStreamMessage(BodyWriter writer)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
this.bodyWriter = writer;
this.headers = new MessageHeaders(MessageVersion.None, 1);
this.properties = new MessageProperties();
}
public void SerializeWithAllSerializableHeaders()
{
IDictionary<string, object> map = new Dictionary<string, object>();
map.Add("name", "joe");
map.Add("age", 42);
MessageHeaders input = new MessageHeaders(map);
MessageHeaders output = (MessageHeaders) SerializeAndDeserialize(input);
Assert.That(output.Get("name"), Is.EqualTo("joe"));
Assert.That(output.Get("age"), Is.EqualTo(42));
}
public HttpStreamMessage(MessageHeaders headers, MessageProperties properties, BodyWriter bodyWriter)
{
if (bodyWriter == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bodyWriter");
}
this.headers = new MessageHeaders(headers);
this.properties = new MessageProperties(properties);
this.bodyWriter = bodyWriter;
}
/// <summary>
/// Create a new message with the given payload. The id will be generated by
/// the default {@link IdGenerator} strategy. The headers will be populated
/// with the provided header values.
/// </summary>
/// <param name="headers">message headers</param>
/// <param name="payload">the message payload</param>
public Message(object payload, IDictionary<string, object> headers)
{
AssertUtils.ArgumentNotNull(payload, "payload must not be null");
if(headers == null) {
headers = new Dictionary<string, object>();
}
_headers = new MessageHeaders(headers);
_payload = payload;
}
protected void SetReplyTo(MessageVersion messageVersion, MessageHeaders headers)
{
this.replyTo = headers.ReplyTo;
if ((messageVersion.Addressing == AddressingVersion.WSAddressing10) && (this.replyTo == null))
{
this.replyTo = EndpointAddress.AnonymousAddress;
}
if (this.replyTo == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageHeaderException(System.ServiceModel.SR.GetString("MissingReplyToOnWsrmRequest", new object[] { this.RequestName }), messageVersion.Addressing.Namespace, "ReplyTo", false));
}
}
public StreamedMessage(XmlDictionaryReader reader, int maxSizeOfHeaders, MessageVersion desiredVersion)
{
if (reader.NodeType != XmlNodeType.Element)
{
reader.MoveToContent();
}
if (desiredVersion.Envelope == EnvelopeVersion.None)
{
this.reader = reader;
this.headerAttributes = XmlAttributeHolder.emptyArray;
this.headers = new MessageHeaders(desiredVersion);
}
else
{
this.envelopeAttributes = XmlAttributeHolder.ReadAttributes(reader, ref maxSizeOfHeaders);
this.envelopePrefix = reader.Prefix;
EnvelopeVersion envelopeVersion = ReceivedMessage.ReadStartEnvelope(reader);
if (desiredVersion.Envelope != envelopeVersion)
{
Exception innerException = new ArgumentException(System.ServiceModel.SR.GetString("EncoderEnvelopeVersionMismatch", new object[] { envelopeVersion, desiredVersion.Envelope }), "reader");
throw TraceUtility.ThrowHelperError(new CommunicationException(innerException.Message, innerException), this);
}
if (ReceivedMessage.HasHeaderElement(reader, envelopeVersion))
{
this.headerPrefix = reader.Prefix;
this.headerAttributes = XmlAttributeHolder.ReadAttributes(reader, ref maxSizeOfHeaders);
this.headers = new MessageHeaders(desiredVersion, reader, this.envelopeAttributes, this.headerAttributes, ref maxSizeOfHeaders);
}
else
{
this.headerAttributes = XmlAttributeHolder.emptyArray;
this.headers = new MessageHeaders(desiredVersion);
}
if (reader.NodeType != XmlNodeType.Element)
{
reader.MoveToContent();
}
this.bodyPrefix = reader.Prefix;
ReceivedMessage.VerifyStartBody(reader, envelopeVersion);
this.bodyAttributes = XmlAttributeHolder.ReadAttributes(reader, ref maxSizeOfHeaders);
if (base.ReadStartBody(reader))
{
this.reader = reader;
}
else
{
this.quotas = new XmlDictionaryReaderQuotas();
reader.Quotas.CopyTo(this.quotas);
reader.Close();
}
}
}
public override void Close()
{
lock (this.ThisLock)
{
if (!this.closed)
{
this.closed = true;
this.bodyWriter = null;
this.headers = null;
this.properties = null;
}
}
}
public static bool ExtractMessageId(MessageHeaders headers, out Guid messageId)
{
if (headers == null) throw new ArgumentNullException(nameof(headers));
messageId = Guid.Empty;
if (headers.MessageId != null)
{
return headers.MessageId.TryGetGuid(out messageId);
}
return false;
}
public static ulong GetHeaderULong(MessageHeaders headers, int index)
{
ulong maxValue = ulong.MaxValue;
if (index >= 0)
{
using (XmlDictionaryReader reader = headers.GetReaderAtHeader(index))
{
maxValue = XmlConvert.ToUInt64(reader.ReadElementString());
}
headers.UnderstoodHeaders.Add(headers[index]);
}
return maxValue;
}
protected virtual void OnReadHeaders(MessageHeaders Headers)
{
XmlUtility.MarkHeaderAsUnderstood(Headers, "Action", "http://www.w3.org/2005/08/addressing");
int num = Headers.FindHeader("Action", "http://www.w3.org/2005/08/addressing");
XmlDictionaryReader readerAtHeader = Headers.GetReaderAtHeader(num);
string str = readerAtHeader.ReadElementString("Action", "http://www.w3.org/2005/08/addressing");
if (string.Equals(str, this.SupportedAction, StringComparison.Ordinal))
{
num = Headers.FindHeader("objectReferenceProperty", "http://schemas.microsoft.com/2008/1/ActiveDirectory");
if (num >= 0)
{
readerAtHeader = Headers.GetReaderAtHeader(num);
this._objectReference = readerAtHeader.ReadElementString("objectReferenceProperty", "http://schemas.microsoft.com/2008/1/ActiveDirectory");
}
return;
}
else
{
throw new ADException(StringResources.ADWSXmlParserInvalidActionForMessage);
}
}
/// <summary>
/// Получить заголовок сообщения из формата RabbitMq.
/// </summary>
public MessageHeaders ConvertMessageHeadersFrom(IDictionary <string, object> headers)
{
if (headers != null)
{
var result = new MessageHeaders();
foreach (var item in headers)
{
var key = item.Key;
var value = item.Value as byte[];
if (key != null)
{
result[key] = value;
}
}
return(result);
}
return(null);
}
void PreProcess(Message message)
{
//If the user does not have manual addressing enabled then clear these out
if (!this.manualAddressing)
{
MessageHeaders headers = message.Headers;
string addressingNamespace = RoutingUtilities.GetAddressingNamespace(headers.MessageVersion.Addressing);
//Go through in reverse to reduce shifting after RemoveAt(i)
for (int i = headers.Count - 1; i >= 0; --i)
{
MessageHeaderInfo header = headers[i];
if (string.Equals(header.Namespace, addressingNamespace, StringComparison.Ordinal))
{
if (!addressingHeadersToFlow.Contains(header.Name))
{
headers.RemoveAt(i);
}
}
}
}
}
// Token: 0x06000386 RID: 902 RVA: 0x00015F04 File Offset: 0x00014104
private static bool TryGetRequestVersion(out ExchangeVersion requestVersion)
{
requestVersion = ExchangeVersion.Exchange2010;
bool result;
try
{
MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders;
string header = incomingMessageHeaders.GetHeader <string>("RequestedServerVersion", "http://schemas.microsoft.com/exchange/2010/Autodiscover");
AutodiscoverRequestMessage.RemapEquivalentRequestedExchangeVersion(ref header);
result = EnumValidator <ExchangeVersion> .TryParse(header, EnumParseOptions.Default, out requestVersion);
}
catch (MessageHeaderException)
{
result = false;
}
catch (SerializationException)
{
result = false;
}
return(result);
}
public void TestDebatchByContainerBadMessageRejected()
{
var provider = new ServiceCollection().BuildServiceProvider();
var config = new ConfigurationBuilder().Build();
var context = new GenericApplicationContext(provider, config);
context.ServiceExpressionResolver = new StandardServiceExpressionResolver();
var container = new DirectMessageListenerContainer(context, connectionFactory);
container.SetQueueNames(ROUTE);
var listener = new EmptyListener();
container.MessageListener = listener;
var errorHandler = new TestConditionalRejectingErrorHandler();
container.ErrorHandler = errorHandler;
container.Initialize();
container.Start();
try
{
var template = new RabbitTemplate
{
ConnectionFactory = connectionFactory
};
var headers = new MessageHeaders(new Dictionary <string, object>()
{
{ RabbitMessageHeaders.SPRING_BATCH_FORMAT, RabbitMessageHeaders.BATCH_FORMAT_LENGTH_HEADER4 }
});
var message = Message.Create(Encoding.UTF8.GetBytes("\u0000\u0000\u0000\u0004foo"), headers);
template.Send(string.Empty, ROUTE, message);
Thread.Sleep(1000);
Assert.Equal(0, listener.Count);
Assert.True(errorHandler.HandleErrorCalled);
}
finally
{
container.Stop();
}
}
public void TestInt2809JavaTypePropertiesFromAmqp()
{
var config = new ConfigurationBuilder().Build();
var services = new ServiceCollection().BuildServiceProvider();
var context = new GenericApplicationContext(services, config);
var channel = new Mock <RC.IModel>();
channel.Setup(c => c.IsOpen).Returns(true);
var connection = new Mock <Messaging.RabbitMQ.Connection.IConnection>();
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.CreateChannel(It.IsAny <bool>())).Returns(channel.Object);
var connectionFactory = new Mock <Messaging.RabbitMQ.Connection.IConnectionFactory>();
connectionFactory.Setup(f => f.CreateConnection()).Returns(connection.Object);
var container = new DirectMessageListenerContainer();
container.ConnectionFactory = connectionFactory.Object;
var adapter = new RabbitInboundChannelAdapter(context, container);
var qchannel = new QueueChannel(context);
adapter.OutputChannel = qchannel;
object payload = new Foo("bar1");
var headers = new MessageHeaders();
var amqpMessage = new JsonMessageConverter().ToMessage(payload, headers);
var listener = container.MessageListener as IChannelAwareMessageListener;
listener.OnMessage(amqpMessage, null);
var receive = qchannel.Receive(1000);
var result = new JsonToObjectTransformer(context).Transform(receive) as IMessage;
Assert.NotNull(result);
Assert.Equal(payload, result.Payload);
var sourceData = result.Headers.Get <IMessage>(IntegrationMessageHeaderAccessor.SOURCE_DATA);
Assert.Null(sourceData);
}
/// <inheritdoc />
/// <summary>
/// Returns messages in the queue that are pending
/// </summary>
/// <param name="cancellationToken">(Optional) A token provided by the caller that can
/// be used by the caller to request cancellation of the fetch operation</param>
/// <returns>Returns the set of pending messages in the queue</returns>
protected override async Task <IEnumerable <QueuedMessage> > GetPendingMessages(CancellationToken cancellationToken = default(CancellationToken))
{
var fb = Builders <QueuedMessageDocument> .Filter;
var filter = fb.Eq(qm => qm.Queue, (string)QueueName) &
fb.Eq(qm => qm.State, QueuedMessageState.Pending);
var existingMessages = await _queuedMessages.Find(filter).ToListAsync(cancellationToken);
var queuedMessages = new List <QueuedMessage>();
foreach (var queuedMessage in existingMessages)
{
try
{
var messageHeaders = new MessageHeaders(queuedMessage.Headers);
var principal = await _securityTokenService.NullSafeValidate(messageHeaders.SecurityToken);
var message = new Message(messageHeaders, queuedMessage.Content);
if (message.IsEncrypted() && _messageEncryptionService != null)
{
message = await _messageEncryptionService.Decrypt(message);
}
message = message.WithoutSecurityToken();
queuedMessages.Add(new QueuedMessage(message, principal, queuedMessage.Attempts));
}
catch (Exception ex)
{
DiagnosticService.Emit(new MongoDBEventBuilder(this, MongoDBEventType.MessageDocumentFormatError)
{
Detail = "Error reading previously queued message document ID " + queuedMessage.Id + "; skipping",
CollectionName = _queuedMessages.CollectionNamespace.CollectionName,
DatabaseName = _queuedMessages.Database.DatabaseNamespace.DatabaseName,
Exception = ex
}.Build());
}
}
return(queuedMessages);
}
/// <summary>
/// 接收请求后事件
/// </summary>
/// <param name="request">请求消息</param>
/// <param name="channel">信道</param>
/// <param name="instanceContext">WCF实例上下文</param>
/// <returns></returns>
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
//如果是身份认证接口，无需认证
if (OperationContext.Current.EndpointDispatcher.ContractName != "IAuthenticationContract")
{
//获取消息头
MessageHeaders headers = OperationContext.Current.IncomingMessageHeaders;
#region # 验证消息头
if (!headers.Any(x => x.Name == CommonConstants.WcfAuthHeaderName && x.Namespace == CommonConstants.WcfAuthHeaderNamespace))
{
throw new NullReferenceException("身份认证消息头不存在，请检查程序！");
}
#endregion
//读取消息头中的公钥
Guid publicKey = headers.GetHeader <Guid>(CommonConstants.WcfAuthHeaderName, CommonConstants.WcfAuthHeaderNamespace);
//认证
lock (_Sync)
{
//以公钥为键，查询分布式缓存，如果有值则通过，无值则不通过
LoginInfo loginInfo = CacheMediator.Get <LoginInfo>(publicKey.ToString());
if (loginInfo == null)
{
throw new NoPermissionException("身份过期，请重新登录！");
}
//通过后，重新设置缓存过期时间
CacheMediator.Set(publicKey.ToString(), loginInfo, DateTime.Now.AddMinutes(_Timeout));
}
}
return(null);
}
/// <summary>
/// 请求发送前事件
/// </summary>
/// <param name="request">请求消息</param>
/// <param name="channel">信道</param>
/// <returns></returns>
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
//WCF客户端获取公钥处理
MessageHeaders headers = OperationContext.Current.IncomingMessageHeaders;
#region # 验证消息头
if (!headers.Any(x => x.Name == CommonConstants.WcfAuthHeaderName && x.Namespace == CommonConstants.WcfAuthHeaderNamespace))
{
throw new NullReferenceException("身份认证消息头不存在，请检查程序！");
}
#endregion
//读取消息头中的公钥
Guid publishKey = headers.GetHeader <Guid>(CommonConstants.WcfAuthHeaderName, CommonConstants.WcfAuthHeaderNamespace);
//添加消息头
MessageHeader header = MessageHeader.CreateHeader(CommonConstants.WcfAuthHeaderName, CommonConstants.WcfAuthHeaderNamespace, publishKey);
request.Headers.Add(header);
return(null);
}
private static async Task <MessageJournalReadResult> ParseResponseContent(HttpResponseMessage responseMessage)
{
var content = await responseMessage.Content.ReadAsStringAsync();
var model = JsonConvert.DeserializeObject <JournalGetResponseModel>(content);
var start = new VerbatimMessageJournalPosition(model.Start);
var next = new VerbatimMessageJournalPosition(model.Next);
var endOfJournal = model.EndOfJournal;
var entries = new List <MessageJournalEntry>();
foreach (var entryModel in model.Entries)
{
var category = entryModel.Category;
var position = new VerbatimMessageJournalPosition(entryModel.Position);
var timestamp = entryModel.Timestamp;
var headers = new MessageHeaders(entryModel.Data.Headers);
var messageContent = entryModel.Data.Content;
var message = new Message(headers, messageContent);
var entry = new MessageJournalEntry(category, position, timestamp, message);
entries.Add(entry);
}
return(new MessageJournalReadResult(start, next, endOfJournal, entries));
}
public void TestAction()
{
Message m = Message.CreateMessage(MessageVersion.Default, "test", 1);
m.Headers.Add(MessageHeader.CreateHeader("FirstHeader", "ns", "first"));
Assert.AreEqual("test", m.Headers.Action, "#1");
MessageHeaders headers = new MessageHeaders(MessageVersion.Default, 1);
Assert.AreEqual(null, headers.Action, "#2");
headers.Add(MessageHeader.CreateHeader("Action", "http://www.w3.org/2005/08/addressing", "test"));
MessageHeaderInfo info = headers [0];
Assert.AreEqual("Action", info.Name, "#2-1");
Assert.AreEqual("http://www.w3.org/2005/08/addressing", info.Namespace, "#2-2");
Assert.AreEqual(false, info.MustUnderstand, "#2-3");
Assert.AreEqual(String.Empty, info.Actor, "#2-4");
Assert.AreEqual("test", headers.Action, "#3");
headers.Clear();
Assert.AreEqual(null, headers.Action, "#4");
}
internal void ProcessHeaders(Message msg, Dictionary <QName, int> qnameLookup, Dictionary <string, HeaderBit[]> headerLookup)
{
string key;
QName qname;
MessageHeaders headers = msg.Headers;
for (int j = 0; j < headers.Count; ++j)
{
qname.name = headers[j].Name;
qname.ns = headers[j].Namespace;
if (headers.MessageVersion.Addressing == AddressingVersion.WSAddressing10 &&
!headers[j].IsReferenceParameter)
{
continue;
}
if (qnameLookup.ContainsKey(qname))
{
_builder.Remove(0, _builder.Length);
XmlReader reader = headers.GetReaderAtHeader(j).ReadSubtree();
reader.Read(); // Needed after call to ReadSubtree
key = GetComparableForm(_builder, reader);
if (headerLookup.TryGetValue(key, out HeaderBit[] bits))
internal void ProcessHeaders(Message msg, Dictionary <QName, int> qnameLookup, Dictionary <string, HeaderBit[]> headerLookup)
{
MessageHeaders headers = msg.Headers;
for (int i = 0; i < headers.Count; i++)
{
QName name;
name.name = headers[i].Name;
name.ns = headers[i].Namespace;
if (((headers.MessageVersion.Addressing != AddressingVersion.WSAddressing10) || headers[i].IsReferenceParameter) && qnameLookup.ContainsKey(name))
{
HeaderBit[] bitArray;
this.builder.Remove(0, this.builder.Length);
XmlReader reader = headers.GetReaderAtHeader(i).ReadSubtree();
reader.Read();
string comparableForm = GetComparableForm(this.builder, reader);
if (headerLookup.TryGetValue(comparableForm, out bitArray))
{
this.SetBit(bitArray);
}
}
}
}
void WriteHeaders(MessageHeaders headers)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("IncomingHeader:");
Console.ForegroundColor = ConsoleColor.Blue;
foreach (MessageHeaderInfo h in headers)
{
if (!h.Actor.Equals(String.Empty))
{
Console.WriteLine("\t" + h.Actor);
}
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("\t" + h.Name);
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("\t" + h.Namespace);
Console.WriteLine("\t" + h.Relay);
if (h.IsReferenceParameter == true)
{
Console.WriteLine("IsReferenceParameter header detected: " + h.ToString());
}
}
Console.ResetColor();
}
internal override void OnAddHeaders(MessageHeaders messageHeaders)
{
if (AddHeaders != null)
{
ServiceRemotingMessageHeaders headers = Header <ServiceRemotingMessageHeaders> .Get(messageHeaders);
AddHeaders(new HeaderAccessor(headers));
Header <ServiceRemotingMessageHeaders> .Replace(headers, messageHeaders);
}
else
{
if (Accessor != null)
{
ServiceRemotingMessageHeaders headers = Header <ServiceRemotingMessageHeaders> .Get(messageHeaders);
foreach (KeyValuePair <string, byte[]> header in (Accessor as HeaderAccessor).Headers.Headers())
{
headers.AddHeader(header.Key, header.Value);
}
Header <ServiceRemotingMessageHeaders> .Replace(headers, messageHeaders);
}
}
}
/// <inheritdoc />
/// <summary>
/// Publishes a message to a topic.
/// </summary>
/// <param name="message">The message to publish.</param>
/// <param name="topicName">The name of the topic.</param>
/// <param name="cancellationToken">A token used by the caller
/// to indicate if and when the publish operation has been canceled.</param>
/// <returns>returns a task that completes when the message has
/// been successfully published to the topic.</returns>
public async Task PublishMessage(Message message, TopicName topicName, CancellationToken cancellationToken)
{
if (_messageJournal != null)
{
await _messageJournal.Append(message, MessageJournalCategory.Published, cancellationToken);
}
var subscribers = await _subscriptionTrackingService.GetSubscribers(topicName, cancellationToken);
var transportTasks = new List <Task>();
foreach (var subscriber in subscribers)
{
IEndpointCredentials subscriberCredentials = null;
if (_endpoints.TryGetEndpointByAddress(subscriber, out var subscriberEndpoint))
{
subscriberCredentials = subscriberEndpoint.Credentials;
}
var perEndpointHeaders = new MessageHeaders(message.Headers)
{
MessageId = MessageId.Generate(),
Destination = subscriber
};
var addressedMessage = new Message(perEndpointHeaders, message.Content);
if (addressedMessage.Headers.Synchronous)
{
transportTasks.Add(TransportMessage(addressedMessage, subscriberCredentials, cancellationToken));
continue;
}
await _messageQueueingService.EnqueueMessage(_outboundQueueName, addressedMessage, null, cancellationToken);
}
await Task.WhenAll(transportTasks);
}
void FilterHeaders(MessageHeaders headers, HashSet <string> understoodHeadersSet)
{
string addressingNamespace = RoutingUtilities.GetAddressingNamespace(headers.MessageVersion.Addressing);
//Go in reverse to reduce shifting after RemoveAt(i)
for (int i = headers.Count - 1; i >= 0; --i)
{
MessageHeaderInfo header = headers[i];
bool removeHeader = false;
if (string.Equals(header.Namespace, addressingNamespace, StringComparison.Ordinal) &&
(addressingHeadersToFlow.Contains(header.Name) || this.manualAddressing))
{
continue;
}
if (understoodHeadersSet.Contains(MessageHeaderKey(header)))
{
// This header was understood at this endpoint, do _not_ flow it
removeHeader = true;
}
else if (ActorIsNextDestination(header, headers.MessageVersion))
{
//This was a header targeted at the SOAP Intermediary ("actor/next", which is us)
//It can explicitly tell us to relay this header when we don't understand it.
if (!header.Relay)
{
removeHeader = true;
}
}
if (removeHeader)
{
headers.RemoveAt(i);
}
}
}
private async Task ProcessMessageAsync(
IMessageSubscription subscription,
EnvelopedMessage envelopedMessage,
object payload,
MessageHeaders headers)
{
var publisher = _repliesPublisher?.Invoke(headers.CorrelationId)
?? ProhibitedRepliesMessagePublisher.Instance;
var handlingContext = new MessageHandlingContext
(
envelopedMessage.Exchange,
envelopedMessage.RetryCount,
envelopedMessage.RoutingKey
);
var result = await subscription.InvokeHandlerAsync(_serviceProvider, payload, headers, handlingContext, publisher);
if (result == null)
{
throw new InvalidOperationException("Result should be not null");
}
switch (result)
{
case MessageHandlingResult.SuccessResult _:
case MessageHandlingResult.NonTransientFailureResult _:
CurrentMessage.Ack();
break;
case MessageHandlingResult.TransientFailureResult tfr:
_retryManager.ScheduleRetry(CurrentMessage, tfr.RetryAfter ?? _defaultRetryTimeout);
break;
default:
throw new NotSupportedException($"Unexpected message handling result [{result.GetType().Name}].");
}
}
/// <summary>
/// Converts from an integration Message to a NMS Message.
/// </summary>
/// <param name="objectToConvert">the object to convert</param>
/// <param name="session">the Session to use for creating a NMS Message</param>
/// <returns>the NMS Message</returns>
/// <throws>NMSException if thrown by NMS API methods </throws>
/// <throws>MessageConversionException in case of conversion failure </throws>
public Apache.NMS.IMessage ToMessage(object objectToConvert, ISession session)
{
MessageHeaders headers = null;
Apache.NMS.IMessage nmsMessage = null;
if (objectToConvert is Spring.Integration.Core.IMessage)
{
headers = ((Spring.Integration.Core.IMessage)objectToConvert).Headers;
if (extractIntegrationMessagePayload)
{
objectToConvert = ((IMessage)objectToConvert).Payload;
}
}
nmsMessage = converter.ToMessage(objectToConvert, session);
if (headers != null)
{
headerMapper.FromHeaders(headers, nmsMessage);
}
if (logger.IsDebugEnabled)
{
logger.Debug("converted [" + objectToConvert + "] to NMS Message [" + nmsMessage + "]");
}
return(nmsMessage);
}
//This method will try to retrieve a header whose value matches the GUID passed by the client.
//The return value will notify the client whether the service was able to retrieve the header or not.
public bool RetrieveHeader(string guid)
{
MessageHeaders messageHeaderCollection = OperationContext.Current.IncomingMessageHeaders;
String guidHeader = null;
Console.WriteLine("Trying to check if IncomingMessageHeader collection contains header with value {0}", guid);
if (messageHeaderCollection.FindHeader(CustomHeader.HeaderName, CustomHeader.HeaderNamespace) != -1)
{
guidHeader = messageHeaderCollection.GetHeader <String>(CustomHeader.HeaderName, CustomHeader.HeaderNamespace);
}
else
{
Console.WriteLine("No header was found");
}
if (guidHeader != null)
{
Console.WriteLine("Found header with value {0}. Does it match with GUID sent as parameter: {1}", guidHeader, guidHeader.Equals(guid));
}
Console.WriteLine();
//Return true if header is present and equals the guid sent by client as argument
return(guidHeader != null && guidHeader.Equals(guid));
}
private ProcessingContext GetProcessingContext(MessageHeaders headers, ConfigData configData)
{
// проверка токена бд
var dbTokenData = dbTokenService.GetDbTokenData() ?? throw new InvalidOperationException("Отсутствует токен базы данных");
if (headers.DbToken != dbTokenData.DbToken)
{
// стоит переделать?
if (string.Compare(headers.DbToken, dbTokenData.DbToken) > -1)
{
dbTokenService.ReloadToken();
dbTokenData = dbTokenService.GetDbTokenData() ?? throw new InvalidOperationException("Отсутствует токен базы данных");
}
//lazyResponse.Value.SetDbTokenData(dbTokenData);
}
return(new ProcessingContext
{
CurrentConfigData = configData,
CurrentDbTokenData = dbTokenData,
MessageHeaders = headers,
});
}
public void AddReference(
MessageHeaders headers,
int i,
XmlDictionaryWriter writer,
string headerId,
bool idInserted)
{
HashStream hashStream = this.TakeHashStream();
writer.StartCanonicalization(hashStream, false, this.InclusivePrefixes);
headers.WriteStartHeader(i, writer);
if (idInserted)
{
writer.WriteAttributeString(this.discoveryInfo.DiscoveryPrefix, ProtocolStrings.IdAttributeName, this.discoveryInfo.DiscoveryNamespace, headerId);
}
headers.WriteHeaderContents(i, writer);
writer.WriteEndElement();
writer.EndCanonicalization();
writer.Flush();
// Add a pre-digested reference for this header
this.AddReference(headerId, hashStream.FlushHashAndGetValue());
}
public static void AddMessageHeader(MessageHeaders headers, HeaderParameter para)
{
headers.RemoveAll("CMD", ns);
headers.RemoveAll("RouterID", ns);
headers.RemoveAll("Plugin", ns);
headers.RemoveAll("ReplyIdentify", ns);
headers.RemoveAll("Token", ns);
headers.RemoveAll("IsCompressJson", ns);
headers.RemoveAll("IsEncryptionJson", ns);
headers.RemoveAll("SerializeType", ns);
var CMD = System.ServiceModel.Channels.MessageHeader.CreateHeader("CMD", ns, para.cmd);
headers.Add(CMD);
var router = System.ServiceModel.Channels.MessageHeader.CreateHeader("RouterID", ns, para.routerid);
headers.Add(router);
var plugin = System.ServiceModel.Channels.MessageHeader.CreateHeader("Plugin", ns, para.pluginname);
headers.Add(plugin);
var ReplyHN = System.ServiceModel.Channels.MessageHeader.CreateHeader("ReplyIdentify", ns, para.replyidentify);
headers.Add(ReplyHN);
var token = System.ServiceModel.Channels.MessageHeader.CreateHeader("Token", ns, para.token);
headers.Add(token);
var IsCompressJson = System.ServiceModel.Channels.MessageHeader.CreateHeader("IsCompressJson", ns, Convert.ToString(para.iscompressjson ? 1 : 0));
headers.Add(IsCompressJson);
var IsEncryptionJson = System.ServiceModel.Channels.MessageHeader.CreateHeader("IsEncryptionJson", ns, Convert.ToString(para.isencryptionjson ? 1 : 0));
headers.Add(IsEncryptionJson);
var SerializeType = System.ServiceModel.Channels.MessageHeader.CreateHeader("SerializeType", ns, Convert.ToString((int)para.serializetype));
headers.Add(SerializeType);
}
/// <summary>
/// Adds the message header.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="name">The name.</param>
/// <param name="ns">The ns.</param>
/// <param name="createHeader">The create header.</param>
protected virtual MessageHeader AddMessageHeader(ref System.ServiceModel.Channels.Message request,
string name, string ns, Func <MessageHeader> createHeader)
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "AddMessageHeader");
MessageHeader result = null;
try
{
MessageHeaders headers = request.Headers;
if (headers != null)
{
if (headers.FindHeader(name, ns) == -1)
{
headers.Add((result = createHeader()));
}
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
return(result);
}
public CertificateDto RegisterClient(string address)
{
CertificateDto certDto = null;
if (!String.IsNullOrEmpty(address))
{
MessageHeaders headers = OperationContext.Current.RequestContext.RequestMessage.Headers;
string subject = null;
if (headers.FindHeader("UserName", "") > -1)
{
subject = headers.GetHeader <string>(headers.FindHeader("UserName", ""));
}
if (subject == null)
{
throw new Exception("Invalid user name");
}
//string subject = ServiceSecurityContext.Current.PrimaryIdentity.Name.Replace('\\','_').Trim();
//string port = address.Split(':')[2].Split('/')[0];
//subject = subject.Replace('-', '_') + port;
certDto = CAProxy.GenerateCertificate(subject, address);
}
return(certDto);
}
protected T GetMessageHeaderData <T>(ref System.ServiceModel.Channels.Message message,
OperationContext context,
string headerNamespace, string headerName)
where T : class
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "GetMessageHeaderData");
T result = default(T);
try
{
if (message != null)
{
if (!headerNamespace.IsEmpty() &&
!headerName.IsEmpty())
{
if (context != null &&
context.IncomingMessageHeaders != null)
{
MessageHeaders headers = context.IncomingMessageHeaders;
int index = headers.FindHeader(headerName, headerNamespace);
if (index != -1)
{
result = DeserializeDC <T>(headers.GetReaderAtHeader(index));
headers.RemoveAt(index);
}
}
}
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
return(result);
}
public void TestFindHeader()
{
// <a:Action mU="true">test</a:Action>
Message m = Message.CreateMessage(MessageVersion.Default, "test", 1);
Assert.AreEqual(1, m.Headers.Count, "#0");
// <MyHeader xmlns="bar">1</MyHeader>
m.Headers.Add(MessageHeader.CreateHeader("MyHeader", "bar", 1));
// <MyHeader xmlns="baz" role="john">1</MyHeader>
m.Headers.Add(MessageHeader.CreateHeader("MyHeader", "baz", 1, false, "john"));
MessageHeaders headers = m.Headers;
// The first header is at 0
Assert.AreEqual(0, headers.FindHeader("Action", wsa1), "#1");
// The return value of FindHeader maps to its places in the headers
Assert.AreEqual(1, headers.FindHeader("MyHeader", "bar"), "#2");
// If a header has actor (role) specified, then it must be provided
Assert.AreEqual(-1, headers.FindHeader("MyHeader", "baz"), "#3");
Assert.AreEqual(2, headers.FindHeader("MyHeader", "baz", "john"), "#4");
}
public void SubscribeShouldCreateQueueHeadersAndRegisterWorker()
{
// Given
var routingHeader = new MessageHeaders();
var queueSession = new Mock <IMessageQueueSession>();
var queueCommandExecutor = new Mock <IMessageQueueCommandExecutor>();
var queueWorkerContainer = new Mock <IMessageQueueWorkerContainer>();
queueCommandExecutor
.Setup(m => m.Execute(It.IsAny <Action <IMessageQueueSession> >()))
.Callback <Action <IMessageQueueSession> >(command => command(queueSession.Object));
// When
IExchangeHeadersBinding target = new ExchangeBinding(ExchangeName, queueCommandExecutor.Object, queueWorkerContainer.Object);
target.Subscribe(QueueName, () => null, routingHeader);
// Then
queueSession.Verify(m => m.CreateQueueHeaders(It.Is <QueueConfig>(q => q.QueueName == QueueName), routingHeader));
queueWorkerContainer.Verify(m => m.RegisterWorker(QueueName, It.IsAny <IMessageQueueWorker>()));
}
public void DoWork()
{
//check for CustomHeaderValue custom header
MessageHeaders headers = OperationContext.Current.IncomingMessageHeaders;
if (headers.FindHeader("CustomHeaderValue", "ns") != -1)
{
var customheader = headers.GetHeader <string>("CustomHeaderValue", "ns");
if (customheader != null)
{
Helper.Log("ServiceDemo.DoWork() was called with custom header CustomHeaderValue: {0}", customheader);
}
}
//check for InspectorHeader custom header
if (headers.FindHeader("InspectorHeader", "ns") != -1)
{
var customheader = headers.GetHeader <string>("InspectorHeader", "ns");
if (customheader != null)
{
Helper.Log("ServiceDemo.DoWork() was called with header from Inspector InspectorHeader: {0}", customheader);
}
}
}
public RawMessageBuffer(byte [] buffer, MessageHeaders headers, MessageProperties properties)
{
this.buffer = buffer;
this.headers = new MessageHeaders(headers);
this.properties = new MessageProperties(properties);
}
