public IEnumerable<HosepipeMessage> GetMessagesFromQueue(QueueParameters parameters)
{
using (var connection = HosepipeConnection.FromParamters(parameters))
using (var channel = connection.CreateModel())
{
try
{
channel.QueueDeclarePassive(parameters.QueueName);
}
catch (OperationInterruptedException exception)
{
Console.WriteLine(exception.Message);
yield break;
}
var count = 0;
while (count++ < parameters.NumberOfMessagesToRetrieve)
{
var basicGetResult = channel.BasicGet(parameters.QueueName, noAck: parameters.Purge);
if (basicGetResult == null) break; // no more messages on the queue
var properties = new MessageProperties(basicGetResult.BasicProperties);
var info = new MessageReceivedInfo(
"hosepipe",
basicGetResult.DeliveryTag,
basicGetResult.Redelivered,
basicGetResult.Exchange,
basicGetResult.RoutingKey,
parameters.QueueName);
yield return new HosepipeMessage(errorMessageSerializer.Serialize(basicGetResult.Body), properties, info);
}
}
}
public PublishedMessageEvent(string exchangeName, string routingKey, MessageProperties properties, byte[] body)
{
ExchangeName = exchangeName;
RoutingKey = routingKey;
Properties = properties;
Body = body;
}
private void OldSendMessages(RabbitTemplate template)
{
IBasicProperties basicProperties = template.Execute<IBasicProperties>(delegate(IModel model)
{
return model.CreateBasicProperties();
});
/*
* System.ArgumentNullException: String reference not set to an instance of a String.
Parameter name: s
at System.Text.Encoding.GetBytes(String s)
at RabbitMQ.Client.Impl.WireFormatting.WriteShortstr(NetworkBinaryWriter writer, String val)
*/
IMessageProperties messageProperties = new MessageProperties(basicProperties);
//write all short props
messageProperties.ContentType = "text/plain";
messageProperties.ContentEncoding = "UTF-8";
messageProperties.CorrelationId = Encoding.UTF8.GetBytes("corr1");
messageProperties.DeliveryMode = MessageDeliveryMode.PERSISTENT;
messageProperties.Priority = 0;
byte[] byteMessage = Encoding.UTF8.GetBytes("testing");
template.Send("amq.direct", "foo", delegate
{
Message msg = new Message(byteMessage, messageProperties);
Console.WriteLine("sending...");
return msg;
});
//template.Send("amq.direct", "foo", channel => new Message(Encoding.UTF8.GetBytes("testing"), messageProperties));
}
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 SendWithTemplate()
{
QpidTemplate template = InitializeAndCreateTemplate();
IMessageProperties messageProperties = new MessageProperties();
//write all short props
messageProperties.ContentType = "text/plain";
messageProperties.ContentEncoding = "UTF-8";
messageProperties.CorrelationId = Encoding.UTF8.GetBytes("corr1");
messageProperties.DeliveryMode = MessageDeliveryMode.PERSISTENT;
messageProperties.Priority = 0;
for (int i = 0; i < 10; i++)
{
template.Send("amq.direct", "routing_key", delegate
{
Message msg = new Message(Encoding.UTF8.GetBytes("Message " + i), messageProperties);
Console.WriteLine("sending...");
return msg;
});
}
template.Send("amq.direct", "routing_key", delegate
{
Message msg = new Message(Encoding.UTF8.GetBytes("That's all, folks!"), messageProperties);
Console.WriteLine("sending...");
return msg;
});
}
public void SetUp()
{
postAckCallbackWasRun = false;
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub<IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy);
Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub<IBasicConsumer>();
channel = MockRepository.GenerateStub<IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
context.SetPostAckCallback(() => postAckCallbackWasRun = true);
var autoResetEvent = new AutoResetEvent(false);
((HandlerRunner) handlerRunner).SynchronisationAction = () => autoResetEvent.Set();
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public void AppendTo( MessageProperties messageProperties )
{
messageProperties.Type = messageType;
if( alternativeTypes.Any() )
messageProperties.Headers[ AlternativeMessageTypesHeaderKey ] = string.Join( AlternativeMessageTypeSeparator, alternativeTypes );
}
public void SetUp()
{
//var logger = new ConsoleLogger();
var logger = MockRepository.GenerateStub<IEasyNetQLogger>();
var consumerErrorStrategy = MockRepository.GenerateStub<IConsumerErrorStrategy>();
var eventBus = new EventBus();
handlerRunner = new HandlerRunner(logger, consumerErrorStrategy, eventBus);
Func<byte[], MessageProperties, MessageReceivedInfo, Task> userHandler = (body, properties, info) =>
Task.Factory.StartNew(() =>
{
deliveredBody = body;
deliveredProperties = properties;
deliveredInfo = info;
});
var consumer = MockRepository.GenerateStub<IBasicConsumer>();
channel = MockRepository.GenerateStub<IModel>();
consumer.Stub(x => x.Model).Return(channel).Repeat.Any();
var context = new ConsumerExecutionContext(
userHandler, messageInfo, messageProperties, messageBody, consumer);
var autoResetEvent = new AutoResetEvent(false);
eventBus.Subscribe<AckEvent>(x => autoResetEvent.Set());
handlerRunner.InvokeUserMessageHandler(context);
autoResetEvent.WaitOne(1000);
}
public Dictionary<string, string> ValidateMessagePropertyHeaders()
{
Dictionary<string, string> headerCollection = new Dictionary<string, string>();
try
{
HttpRequestMessageProperty property;
object obj;
MessageProperties properties = new MessageProperties(OperationContext.Current.IncomingMessageProperties);
if (properties.TryGetValue(HttpRequestMessageProperty.Name, out obj))
{
property = obj as HttpRequestMessageProperty;
WebHeaderCollection collection = property.Headers;
string[] headers = collection.AllKeys;
foreach (string s in headers)
{
string[] values = collection.GetValues(s);
headerCollection.Add(s, String.Join(",", values));
}
}
else
{
headerCollection.Add("ERROR", "No HttpRequestMessageProperty was found!");
}
}
catch (Exception ex)
{
headerCollection.Add("ERROR", string.Format("An exception was thrown: {0}", ex.Message));
}
return headerCollection;
}
public TestHttpRequestMessageProperty EchoHttpRequestMessageProperty()
{
object obj;
MessageProperties properties = new MessageProperties(OperationContext.Current.IncomingMessageProperties);
if (properties.TryGetValue(HttpRequestMessageProperty.Name, out obj))
{
HttpRequestMessageProperty property = (HttpRequestMessageProperty)obj;
if (property != null)
{
TestHttpRequestMessageProperty testProperty = new TestHttpRequestMessageProperty();
testProperty.SuppressEntityBody = property.SuppressEntityBody;
testProperty.Method = property.Method;
testProperty.QueryString = property.QueryString;
WebHeaderCollection collection = property.Headers;
foreach (string s in collection.AllKeys)
{
string[] values = collection.GetValues(s);
testProperty.Headers.Add(s, String.Join(",", values));
}
return testProperty;
}
}
return null;
}
public void Should_be_able_to_write_debug_properties()
{
const string expectedDebugProperties =
"ContentType=content_type, ContentEncoding=content_encoding, " +
"Headers=[key1=value1, key2=value2], DeliveryMode=10, Priority=3, CorrelationId=NULL, " +
"ReplyTo=reply_to, Expiration=expiration, MessageId=message_id, Timestamp=123456, Type=type, " +
"UserId=userid, AppId=app_id, ClusterId=cluster_id";
var stringBuilder = new StringBuilder();
var headers = new Dictionary<string, object>
{
{"key1", "value1"},
{"key2", "value2"}
};
var properties = new MessageProperties
{
AppId = "app_id",
ClusterId = "cluster_id",
ContentEncoding = "content_encoding",
ContentType = "content_type",
//CorrelationId = "correlation_id",
DeliveryMode = 10,
Expiration = "expiration",
Headers = headers,
MessageId = "message_id",
Priority = 3,
ReplyTo = "reply_to",
Timestamp = 123456,
Type = "type",
UserId = "userid",
};
properties.ToString().ShouldEqual(expectedDebugProperties);
}
public void WriteSomeFiles()
{
var directory = new DirectoryInfo(tempDirectory);
foreach (var file in directory.EnumerateFiles())
{
file.Delete();
}
var properties = new MessageProperties();
var info = Helper.CreateMessageRecievedInfo();
var writer = new FileMessageWriter();
var messages = new List<HosepipeMessage>
{
new HosepipeMessage("This is message one", properties, info),
new HosepipeMessage("This is message two", properties, info),
new HosepipeMessage("This is message three", properties, info)
};
var parameters = new QueueParameters
{
QueueName = "Queue EasyNetQ_Tests_TestAsyncRequestMessage:EasyNetQ_Tests_Messages",
MessageFilePath = tempDirectory
};
writer.Write(messages, parameters);
foreach (var file in directory.EnumerateFiles())
{
Console.Out.WriteLine("{0}", file.Name);
}
}
/// <summary>
/// Constructor.
/// </summary>
protected AmfMessageBase()
{
_properties = new MessageProperties();
//Make sure that there is no wrapping applied to this message
_headers = new MessageHeaders(MessageVersion.None);
}
public AckEvent(MessageReceivedInfo info, MessageProperties properties, byte[] body , AckResult ackResult)
{
ReceivedInfo = info;
Properties = properties;
Body = body;
AckResult = ackResult;
}
public void Setup()
{
MessageData = Encoding.UTF8.GetBytes("hej");
ChannelConfigurator = new ChannelConfigurator();
Exchange = null;
MessageProperties = new MessageProperties() { MessageId = MessageId };
_message = new ReceivedMessage(MessageData, GetExchangeName(), MessageProperties);
}
public void AddOrReplaceInMessageProperties(MessageProperties properties)
{
if (properties == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("properties");
}
properties["ContextMessageProperty"] = this;
}
public void ReturnProperties(MessageProperties properties)
{
if (properties.CanRecycle)
{
properties.Recycle();
this.recycledProperties = properties;
}
}
public static bool TryGet(MessageProperties properties, out System.ServiceModel.Channels.ContextMessageProperty contextMessageProperty)
{
Contract.Ensures(Contract.Result<bool>() == (Contract.ValueAtReturn(out contextMessageProperty) != null));
contextMessageProperty = default(System.ServiceModel.Channels.ContextMessageProperty);
return default(bool);
}
public void AddTo(MessageProperties properties)
{
if (properties == null)
{
throw FxTrace.Exception.ArgumentNull("properties");
}
properties.Add(NetworkInterfaceMessageProperty.Name, this);
}
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 void AllowOutputBatching ()
{
var mp = new MessageProperties ();
Assert.IsFalse (mp.AllowOutputBatching, "#0");
mp.AllowOutputBatching = true;
Assert.AreEqual (1, mp.Count, "#1");
foreach (KeyValuePair<string,object> p in mp)
Assert.AreEqual ("AllowOutputBatching", p.Key, "#2");
}
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 void Via ()
{
var mp = new MessageProperties ();
Assert.IsNull (mp.Via, "#0");
mp.Via = new Uri ("urn:foo");
Assert.AreEqual (1, mp.Count, "#1");
foreach (KeyValuePair<string,object> p in mp)
Assert.AreEqual ("Via", p.Key, "#2");
}
public void Encoder ()
{
var mp = new MessageProperties ();
Assert.IsNull (mp.Via, "#0");
mp.Encoder = new TextMessageEncodingBindingElement ().CreateMessageEncoderFactory ().Encoder;
Assert.AreEqual (1, mp.Count, "#1");
foreach (KeyValuePair<string,object> p in mp)
Assert.AreEqual ("Encoder", p.Key, "#2");
}
public static bool TryGet(MessageProperties properties, out System.ServiceModel.Channels.CorrelationDataMessageProperty property)
{
Contract.Requires(properties != null);
Contract.Ensures(Contract.Result<bool>() == (Contract.ValueAtReturn(out property) != null));
property = default(System.ServiceModel.Channels.CorrelationDataMessageProperty);
return default(bool);
}
public void AddTo(MessageProperties properties)
{
this.ThrowIfDisposed();
if (properties == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("properties");
}
properties.Add(Name, this);
}
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;
}
bool MatchInternal(MessageProperties messageProperties)
{
object value;
if (messageProperties.TryGetValue(EndpointNameKey, out value))
{
string messageEndpoint = value.ToString();
return string.Equals(messageEndpoint, this.endpointName, StringComparison.Ordinal);
}
return false;
}
public HosepipeMessage(string body, MessageProperties properties, MessageReceivedInfo info)
{
if(body == null) throw new ArgumentNullException("body");
if(properties == null) throw new ArgumentNullException("properties");
if(info == null) throw new ArgumentNullException("info");
Body = body;
Properties = properties;
Info = info;
}
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();
}
/// <inheritdoc />
public void HandleBasicDeliver(
string consumerTag,
ulong deliveryTag,
bool redelivered,
string exchange,
string routingKey,
IBasicProperties properties,
ReadOnlyMemory <byte> body
)
{
if (logger.IsDebugEnabled())
{
logger.DebugFormat("Message delivered to consumer {consumerTag} with deliveryTag {deliveryTag}", consumerTag, deliveryTag);
}
if (disposed)
{
// this message's consumer has stopped, so just return
logger.InfoFormat(
"Consumer with consumerTag {consumerTag} on queue {queue} has stopped running. Ignoring message",
ConsumerTag,
Queue.Name
);
return;
}
var bodyBytes = body.ToArray();
var messageReceivedInfo = new MessageReceivedInfo(consumerTag, deliveryTag, redelivered, exchange, routingKey, Queue.Name);
var messageProperties = new MessageProperties(properties);
var context = new ConsumerExecutionContext(OnMessage, messageReceivedInfo, messageProperties, bodyBytes);
eventBus.Publish(new DeliveredMessageEvent(messageReceivedInfo, messageProperties, bodyBytes));
handlerRunner.InvokeUserMessageHandlerAsync(context)
.ContinueWith(async x =>
{
var ackStrategy = await x.ConfigureAwait(false);
consumerDispatcher.QueueAction(() =>
{
var ackResult = ackStrategy(Model, deliveryTag);
eventBus.Publish(new AckEvent(messageReceivedInfo, messageProperties, bodyBytes, ackResult));
});
},
TaskContinuationOptions.ExecuteSynchronously
);
}
public IMessage DeserializeMessage(MessageProperties properties, byte[] body)
{
string message;
switch (_serializer.BytesToMessage(typeof(object), body))
{
case string messageTmp:
message = messageTmp;
break;
case var messageTmp:
message = ((JObject)messageTmp).ToString();
break;
}
return(MessageFactory.CreateInstance(typeof(string), message, properties));
}
public MessageInspector_CustomHeaderAuthentication.ResultObject <string> UserGetAuthToken()
{
MessageInspector_CustomHeaderAuthentication.ResultObject <string> resultObject = null;
try
{
HttpRequestMessageProperty property;
object obj;
MessageProperties properties = new MessageProperties(OperationContext.Current.IncomingMessageProperties);
if (properties.TryGetValue(HttpRequestMessageProperty.Name, out obj))
{
property = obj as HttpRequestMessageProperty;
WebHeaderCollection collection = property.Headers;
string authValue = collection.Get(Enum.GetName(typeof(HttpRequestHeader), HttpRequestHeader.Authorization));
if (authValue == "Not Allowed")
{
resultObject = MessageInspector_CustomHeaderAuthentication.ResultObject <string> .CreateFailureObject <string>();
resultObject.Result = resultObject.ResultMessage;
}
else if (authValue == "Allow")
{
resultObject = MessageInspector_CustomHeaderAuthentication.ResultObject <string> .CreateSuccessObject <string>();
resultObject.Result = resultObject.ResultMessage;
}
}
else
{
resultObject = MessageInspector_CustomHeaderAuthentication.ResultObject <string> .CreateFailureObject <string>();
resultObject.Result = "ERROR";
resultObject.ResultMessage = "No HttpRequestMessageProperty was found on the incoming Message.";
}
}
catch (Exception ex)
{
resultObject = MessageInspector_CustomHeaderAuthentication.ResultObject <string> .CreateFailureObject <string>();
resultObject.Result = ex.ToString();
resultObject.ResultMessage = ex.Message;
}
return(resultObject);
}
public void ProcessWithRetry(MessageMetadata product, IList <Subscription> subscriptionGroup, int tryIndex = 0)
{
var deliveryCount = tryIndex + 1;
int nextDelay;
try
{
ProcessSubscriptionGroup(product, subscriptionGroup);
return;
}
catch (Exception e)
{
Log.Warning(e, $"Error occured when retry count: {deliveryCount}");
switch (deliveryCount)
{
case 1:
nextDelay = (int)TimeSpan.FromSeconds(5).TotalMilliseconds;
break;
case 2:
nextDelay = (int)TimeSpan.FromSeconds(15).TotalMilliseconds;
break;
default:
Log.Error(e, $"Exceeded Retry Count: {deliveryCount}");
return;
}
}
var properties = new MessageProperties()
{
Headers = new Dictionary <string, object>()
{
{ "x-delay", nextDelay }
}
};
var redeliveribleInformationResource = new RedeliveribleMessage()
{
DeliveryCount = deliveryCount,
Message = product,
Subscriptions = subscriptionGroup
};
_bus.Publish(_retryExchanger, String.Empty, true, new Message <RedeliveribleMessage>(redeliveribleInformationResource, properties));
}
/// <summary>
/// Getting sender IP address and port
/// </summary>
/// <returns>IP address with port</returns>
private string GetClientEndpoint()
{
OperationContext context = OperationContext.Current;
if (context != null)
{
MessageProperties messageProperties = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpointProperty =
messageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
return(endpointProperty.Address.Replace("::1", "127.0.0.1") + ":" + endpointProperty.Port);
}
else
{
return("127.0.0.1");
}
}
/// <summary>Create a message from the object with properties.</summary>
/// <param name="obj">The obj.</param>
/// <param name="messageProperties">The message properties.</param>
/// <returns>The Message.</returns>
public Message ToMessage(object obj, MessageProperties messageProperties)
{
if (messageProperties == null)
{
messageProperties = new MessageProperties();
}
var message = this.CreateMessage(obj, messageProperties);
messageProperties = message.MessageProperties;
if (this.createMessageIds && messageProperties.MessageId == null)
{
messageProperties.MessageId = Guid.NewGuid().ToString();
}
return(message);
}
public void MultipleCodecs()
{
var properties = new MessageProperties {
ContentEncoding = "deflate, gzip",
ContentTypePresent = true
};
var input = new RawMessage(properties, Encoding.UTF8.GetBytes("test"));
var subject = new ExtensibleContentEncodingInterceptor();
var encoded = subject.OnProduce(input);
Assert.Equal(new Byte[] { 147, 239, 230, 96, 0, 3, 110, 109, 79, 93, 61, 70, 6, 158, 186, 250, 27, 44, 64, 46, 0 }, encoded.Body);
var decoded = subject.OnConsume(encoded);
Assert.Equal("test", Encoding.UTF8.GetString(decoded.Body));
}
public void CodecDeflate()
{
var properties = new MessageProperties {
ContentEncoding = "deflate",
ContentTypePresent = true
};
var input = new RawMessage(properties, Encoding.UTF8.GetBytes("test"));
var subject = new ExtensibleContentEncodingInterceptor();
var encoded = subject.OnProduce(input);
Assert.Equal(new byte[] { 43, 73, 45, 46, 1, 0 }, encoded.Body);
var decoded = subject.OnConsume(encoded);
Assert.Equal("test", Encoding.UTF8.GetString(decoded.Body));
}
public void CodecIdentity()
{
var properties = new MessageProperties {
ContentEncoding = "identity",
ContentTypePresent = true
};
var input = new RawMessage(properties, Encoding.UTF8.GetBytes("test"));
var subject = new ExtensibleContentEncodingInterceptor();
var encoded = subject.OnProduce(input);
Assert.Equal("test", Encoding.UTF8.GetString(encoded.Body));
var decoded = subject.OnConsume(encoded);
Assert.Equal("test", Encoding.UTF8.GetString(decoded.Body));
}
public ConsumerExecutionContext(
Func <byte[], MessageProperties, MessageReceivedInfo, Task> userHandler,
MessageReceivedInfo info,
MessageProperties properties,
byte[] body
)
{
Preconditions.CheckNotNull(userHandler, "userHandler");
Preconditions.CheckNotNull(info, "info");
Preconditions.CheckNotNull(properties, "properties");
Preconditions.CheckNotNull(body, "body");
UserHandler = userHandler;
Info = info;
Properties = properties;
Body = body;
}
public void CodecGzip()
{
var properties = new MessageProperties {
ContentEncoding = "gzip",
ContentTypePresent = true
};
var input = new RawMessage(properties, Encoding.UTF8.GetBytes("test"));
var subject = new ExtensibleContentEncodingInterceptor();
var encoded = subject.OnProduce(input);
Assert.Equal(new Byte[] { 31, 139, 8, 0, 0, 0, 0, 0, 0, 11, 43, 73, 45, 46, 1, 0, 12, 126, 127, 216, 4, 0, 0, 0 }, encoded.Body);
var decoded = subject.OnConsume(encoded);
Assert.Equal("test", Encoding.UTF8.GetString(decoded.Body));
}
protected override void Write(LogEventInfo logEvent)
{
var message = GetMessage(logEvent);
var routingKey = GetRoutingKey(logEvent.Level.Name);
var properties = new MessageProperties
{
AppId = AppId,
ContentEncoding = "utf8",
ContentType = "application/json",
Timestamp = GetEpochTimeStamp(logEvent),
UserId = _rabbitMqHostHostConfig.UserName,
Type = "Log",
};
Bus.Publish(_exchange, routingKey, true, false, properties, message);
}
public void CodecBrotli()
{
var properties = new MessageProperties {
ContentEncoding = "br",
ContentTypePresent = true
};
var input = new RawMessage(properties, Encoding.UTF8.GetBytes("test"));
var subject = new ExtensibleContentEncodingInterceptor();
var encoded = subject.OnProduce(input);
Assert.Equal(new Byte[] { 139, 1, 128, 116, 101, 115, 116, 3 }, encoded.Body);
var decoded = subject.OnConsume(encoded);
Assert.Equal("test", Encoding.UTF8.GetString(decoded.Body));
}
public static async Task <Model> ModifyAsync(ulong channelId, ulong msgId, BaseDiscordClient client, Action <MessageProperties> func,
RequestOptions options)
{
var args = new MessageProperties();
func(args);
if ((args.Content.IsSpecified && string.IsNullOrEmpty(args.Content.Value)) && (args.Embed.IsSpecified && args.Embed.Value == null))
{
Preconditions.NotNullOrEmpty(args.Content.IsSpecified ? args.Content.Value : string.Empty, nameof(args.Content));
}
if (args.AllowedMentions.IsSpecified)
{
AllowedMentions allowedMentions = args.AllowedMentions.Value;
Preconditions.AtMost(allowedMentions?.RoleIds?.Count ?? 0, 100, nameof(allowedMentions.RoleIds), "A max of 100 role Ids are allowed.");
Preconditions.AtMost(allowedMentions?.UserIds?.Count ?? 0, 100, nameof(allowedMentions.UserIds), "A max of 100 user Ids are allowed.");
// check that user flag and user Id list are exclusive, same with role flag and role Id list
if (allowedMentions != null && allowedMentions.AllowedTypes.HasValue)
{
if (allowedMentions.AllowedTypes.Value.HasFlag(AllowedMentionTypes.Users) &&
allowedMentions.UserIds != null && allowedMentions.UserIds.Count > 0)
{
throw new ArgumentException("The Users flag is mutually exclusive with the list of User Ids.", nameof(allowedMentions));
}
if (allowedMentions.AllowedTypes.Value.HasFlag(AllowedMentionTypes.Roles) &&
allowedMentions.RoleIds != null && allowedMentions.RoleIds.Count > 0)
{
throw new ArgumentException("The Roles flag is mutually exclusive with the list of Role Ids.", nameof(allowedMentions));
}
}
}
var apiArgs = new API.Rest.ModifyMessageParams
{
Content = args.Content,
Embed = args.Embed.IsSpecified ? args.Embed.Value.ToModel() : Optional.Create <API.Embed>(),
Flags = args.Flags.IsSpecified ? args.Flags.Value : Optional.Create <MessageFlags?>(),
AllowedMentions = args.AllowedMentions.IsSpecified ? args.AllowedMentions.Value.ToModel() : Optional.Create <API.AllowedMentions>(),
};
return(await client.ApiClient.ModifyMessageAsync(channelId, msgId, apiArgs, options).ConfigureAwait(false));
}
public object BeforeCall(string operationName, object[] inputs)
{
Type serviceType = OperationContext.Current.EndpointDispatcher.DispatchRuntime.Type;
MethodInfo methodInfo = serviceType.GetMethod(operationName);
ParameterInfo[] parameters = methodInfo.GetParameters();
// var ssoCookie = new SSOCookie(HttpContext.Current.Request.Cookies[ConfigurationManager.AppSettings["SSO_CookieName"]]);
//Validate contract objects using DataAnnotation Attributes
// methodInfo.Attributes
// var authorization = methodInfo.GetCustomAttributes(true).SingleOrDefault(a => a.GetType().Equals(typeof(ServiceAuthorization))) as ServiceAuthorization;
// if (authorization != null)
// {
// authorization.Authorize();
// }
// inputs.Where(i => i != null && i.GetType().BaseType == typeof(ModelBase)).ToList().ForEach(i => i.Validate());
try
{
// Log that we're starting the call, who the caller is, etc.
OperationContext context = OperationContext.Current;
MessageProperties incomingMessageProperties = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpoint = incomingMessageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
string clientIP = endpoint.Address;
_log.Info(string.Format("Beginning execution of {0}.{1} called from [{2}]", serviceType, operationName, clientIP));
}
catch (Exception exception)
{
_log.Error(string.Format("Error in BeforeCall. {0}", exception.Message), exception);
throw;
}
// try
// {
// OperationState.State["StartDateTime"] = Stopwatch.StartNew();
// return null;
// }
// catch (Exception exception)
// {
// _log.Error("Error in BeforeCall. " + exception.Message, exception);
// throw;
// }
return(null);
}
public async Task SendRpcRequest <T>(string requestName, T message, Action <IHandlerRegistry> registrar)
{
var correlationId = Guid.NewGuid().ToString();
var handlerId = string.Format("{0}.{1}", requestName, correlationId);
var handlers = GetHandlers(handlerId, registrar);
var exchange = CreateRpcRequestExchange();
var serialized = _serializationStrategy.Serialize(message);
var props = new MessageProperties()
{
Type = serialized.Item1,
ReplyTo = _clientId.ToString(),
CorrelationId = correlationId,
DeliveryMode = 1
};
ReceiveRpcResponse(requestName, correlationId, handlerId);
await _bus.Advanced.PublishAsync(exchange, requestName, false, false, props, serialized.Item2);
}
protected void MoveToDeadLetter(object message, MessageProperties properties, Exception exception)
{
var serializedMessage = Serializer.Get(properties.ContentType).Serialize(message);
properties.Headers.Add("x-death", new Dictionary <string, object>
{
{ "count", 1 },
{ "reason", "error" },
{ "error", exception.Message },
{ "queue", QueueConfiguration.Name },
{ "exchange", ExchangeConfiguration.Name },
{ "routing-keys", QueueConfiguration.RoutingKey },
{ "time", ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeMilliseconds() }
}
);
Bus.Publish(_deadLetterExchange, _deadLetterRoutingKey, true, properties, serializedMessage);
}
/// <summary>
/// Gets the ImpersonateOnSerializingReplyMessageProperty property from MessageProperties.
/// </summary>
/// <param name="properties">The MessagePropeties object.</param>
/// <param name="property">An output paramter to hold the ImpersonateOnSerializingReplyMessageProperty property.</param>
/// <returns>True if the ImpersonateOnSerializingReplyMessageProperty property was found.</returns>
public static bool TryGet(MessageProperties properties, out ImpersonateOnSerializingReplyMessageProperty property)
{
if (properties == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(properties));
}
if (properties.TryGetValue(PropertyName, out object value))
{
property = value as ImpersonateOnSerializingReplyMessageProperty;
}
else
{
property = null;
}
return(property != null);
}
/// <summary>
/// Grab the user IP address from the current WCF operation
/// </summary>
/// <param name="context">The current operation context (e.g. "OperationContext.Current")</param>
/// <returns>The IP address if all is well, otherwise empty string.</returns>
public static string GetUserIPFromOperationContect(OperationContext context)
{
string result = string.Empty;
MessageProperties messageProperties = context.IncomingMessageProperties;
if (messageProperties != null)
{
RemoteEndpointMessageProperty endpointProperty = messageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
if (endpointProperty != null)
{
result = endpointProperty.Address;
}
}
return(result);
}
public static Message GenerateMessage(object payload, MessageProperties messageSpecificProperties, IMessageGenerator messageGenerator = null)
{
messageGenerator = messageGenerator ?? new MessageGenerator();
var message = messageGenerator.GenerateMessage(payload);
var messageType = payload.GetType();
message.MessageId = Guid.NewGuid().ToString();
message.ContentType = messageType.SimpleQualifiedName();
message.UserProperties["MessageType"] = messageType.FullName;
message.PopulateCorrelationId(
messageSpecificProperties?.CorrelationIdProvider.CorrelationId);
message.AddProperties(messageSpecificProperties?.CustomProperties);
return(message);
}
public static CorrelationCallbackContext CreateCorrelationCallbackContext(MessageProperties messageProperties)
{
CallbackContextMessageProperty callbackMessageContextProperty;
if (CallbackContextMessageProperty.TryGet(messageProperties, out callbackMessageContextProperty))
{
EndpointAddress listenAddress;
IDictionary <string, string> context;
callbackMessageContextProperty.GetListenAddressAndContext(out listenAddress, out context);
return(new CorrelationCallbackContext
{
ListenAddress = EndpointAddress10.FromEndpointAddress(listenAddress),
Context = context
});
}
return(null);
}
internal PendingMessageWrapper(T msg)
{
Message = msg;
WasCancelled = false;
WasFinished = true;
Properties = new MessageProperties {
CorrelationId = "UNIT-TEST",
DeliveryTag = 1234,
Exchange = "UNIT-TEST",
OriginalType = typeof(T).Name,
SenderName = "UNIT-TEST"
};
Cancel = () => { WasCancelled = true; };
Finish = () => { WasFinished = true; };
}
private Type ToType(MessageProperties properties)
{
var inferredType = properties.InferredArgumentType;
if (inferredType != null && !inferredType.IsAbstract && !inferredType.IsInterface)
{
return(inferredType);
}
var typeIdHeader = RetrieveHeaderAsString(properties, DEFAULT_CLASSID_FIELD_NAME);
if (typeIdHeader != null)
{
return(FromTypeHeader(properties, typeIdHeader));
}
return(typeof(object));
}
internal static bool TryGet(MessageProperties properties, out ChannelBindingMessageProperty property)
{
if (properties == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(properties));
}
property = null;
object value;
if (properties.TryGetValue(ChannelBindingMessageProperty.Name, out value))
{
property = value as ChannelBindingMessageProperty;
return(property != null);
}
return(false);
}
public void MessageToSerializedObject()
{
var converter = new SimpleMessageConverter();
var properties = new MessageProperties();
properties.ContentType = MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT;
var binaryFormatter = new BinaryFormatter();
var byteStream = new MemoryStream();
var testObject = new TestObject("foo");
binaryFormatter.Serialize(byteStream, testObject);
var bytes = byteStream.ToArray();
var message = new Message(bytes, properties);
var result = converter.FromMessage(message);
Assert.AreEqual(typeof(TestObject), result.GetType());
Assert.AreEqual(testObject, result);
}
public static async Task <Message> ModifyInteractionResponseAsync(BaseDiscordClient client, string token, Action <MessageProperties> func,
RequestOptions options = null)
{
var args = new MessageProperties();
func(args);
var embed = args.Embed;
var embeds = args.Embeds;
bool hasText = !string.IsNullOrEmpty(args.Content.GetValueOrDefault());
bool hasEmbeds = embed.IsSpecified && embed.Value != null || embeds.IsSpecified && embeds.Value?.Length > 0;
bool hasComponents = args.Components.IsSpecified && args.Components.Value != null;
if (!hasComponents && !hasText && !hasEmbeds)
{
Preconditions.NotNullOrEmpty(args.Content.IsSpecified ? args.Content.Value : string.Empty, nameof(args.Content));
}
var apiEmbeds = embed.IsSpecified || embeds.IsSpecified ? new List <API.Embed>() : null;
if (embed.IsSpecified && embed.Value != null)
{
apiEmbeds.Add(embed.Value.ToModel());
}
if (embeds.IsSpecified && embeds.Value != null)
{
apiEmbeds.AddRange(embeds.Value.Select(x => x.ToModel()));
}
Preconditions.AtMost(apiEmbeds?.Count ?? 0, 10, nameof(args.Embeds), "A max of 10 embeds are allowed.");
var apiArgs = new ModifyInteractionResponseParams
{
Content = args.Content,
Embeds = apiEmbeds?.ToArray() ?? Optional <API.Embed[]> .Unspecified,
AllowedMentions = args.AllowedMentions.IsSpecified ? args.AllowedMentions.Value?.ToModel() : Optional <API.AllowedMentions> .Unspecified,
Components = args.Components.IsSpecified ? args.Components.Value?.Components.Select(x => new API.ActionRowComponent(x)).ToArray() : Optional <API.ActionRowComponent[]> .Unspecified,
Flags = args.Flags
};
return(await client.ApiClient.ModifyInteractionResponseAsync(apiArgs, token, options).ConfigureAwait(false));
}
/// <summary>Creates an AMQP Message from the provided Object.</summary>
/// <param name="obj">The obj.</param>
/// <param name="messageProperties">The message properties.</param>
/// <returns>The message.</returns>
/// <exception cref="MessageConversionException"></exception>
protected override Message CreateMessage(object obj, MessageProperties messageProperties)
{
byte[] bytes = null;
if (obj is byte[])
{
bytes = (byte[])obj;
messageProperties.ContentType = MessageProperties.CONTENT_TYPE_BYTES;
}
else if (obj is string)
{
try
{
bytes = SerializationUtils.SerializeString((string)obj, this.defaultCharset);
}
catch (Exception e)
{
throw new MessageConversionException("failed to convert to Message content", e);
}
messageProperties.ContentType = MessageProperties.CONTENT_TYPE_TEXT_PLAIN;
messageProperties.ContentEncoding = this.defaultCharset;
}
else if (obj.GetType().IsSerializable || (obj != null && obj.GetType().IsSerializable))
{
try
{
bytes = SerializationUtils.SerializeObject(obj);
}
catch (Exception e)
{
throw new MessageConversionException("failed to convert to serialized Message content", e);
}
messageProperties.ContentType = MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT;
}
if (bytes != null)
{
messageProperties.ContentLength = bytes.Length;
}
return(new Message(bytes, messageProperties));
}
/// <summary>
/// 插入评论
/// </summary>
/// <param name="rData"></param>
/// <returns></returns>
private int InsertComments(CommentsData rData)
{
string puid = rData.puid ?? string.Empty;
string sourceId = rData.srcid ?? string.Empty;
string content = rData.content ?? string.Empty;
string sourceType = rData.type ?? string.Empty;
string url = rData.url ?? string.Empty;
int us_id = int.Parse(rData.us_id);
string us_name = rData.us_name;
CommentInfo cmt = new CommentInfo();
cmt.cmt_accept = 0;
cmt.cmt_checkRemark = string.Empty;
cmt.cmt_checkTime = string.Empty;
cmt.cmt_checkUser = string.Empty;
cmt.cmt_content = content;
cmt.cmt_createTime = DateTime.Now;
cmt.cmt_createUser = us_name;
cmt.cmt_createUserID = us_id;
cmt.cmt_id = 0;
OperationContext context = OperationContext.Current;
MessageProperties messageProperties = context.IncomingMessageProperties;
RemoteEndpointMessageProperty endpointProperty =
messageProperties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
cmt.cmt_ip = endpointProperty.Address;
cmt.cmt_ipArea = string.Empty;
cmt.cmt_parentIds = string.Empty;
cmt.cmt_sourceId = sourceId;
cmt.cmt_sourceType = sourceType;
cmt.cmt_status = 1;
cmt.cmt_title = string.Empty;
cmt.cmt_uid = GetCmtUID(sourceId);
cmt.cmt_sourceCateId = rData.cmt_sourceCateId;
cmt.cmt_platform = rData.cmt_platform;
cmt.cmt_device = rData.cmt_device;
cmt.cmt_title = rData.cmt_title;
return(DataAccess_News.Comments_Insert(cmt, puid, url));
}
internal static string GetTrackingId(MessageProperties messageProperties, MessageHeaders messageHeaders, WebOperationContext webOperationContext)
{
string id;
TrackingIdMessageProperty trackingIdMessageProperty;
TrackingIdHeader trackingIdHeader;
if (!TrackingIdMessageProperty.TryGet <TrackingIdMessageProperty>(messageProperties, out trackingIdMessageProperty))
{
string str = null;
if (webOperationContext != null)
{
str = webOperationContext.IncomingRequest.Headers.Get("TrackingId");
}
if (TrackingIdHeader.TryRead(messageHeaders, out trackingIdHeader))
{
id = trackingIdHeader.Id;
}
else if (messageHeaders.RelatesTo != null)
{
Guid trackingId = TrackingContext.GetTrackingId(messageHeaders.RelatesTo);
id = TrackingContext.AppendRoleInstanceInformationToTrackingId(trackingId.ToString());
}
else if (messageHeaders.MessageId != null)
{
Guid guid = TrackingContext.GetTrackingId(messageHeaders.MessageId);
id = TrackingContext.AppendRoleInstanceInformationToTrackingId(guid.ToString());
}
else if (string.IsNullOrEmpty(str))
{
Guid guid1 = Guid.NewGuid();
id = TrackingContext.AppendRoleInstanceInformationToTrackingId(guid1.ToString());
}
else
{
id = TrackingContext.AppendRoleInstanceInformationToTrackingId(str);
}
TrackingIdMessageProperty.TryAdd(messageProperties, id);
}
else
{
id = trackingIdMessageProperty.Id;
}
return(id);
}
public static async Task <Model> ModifyAsync(IMessage msg, BaseDiscordClient client, Action <MessageProperties> func,
RequestOptions options)
{
if (msg.Author.Id != client.CurrentUser.Id)
{
throw new InvalidOperationException("Only the author of a message may change it.");
}
var args = new MessageProperties();
func(args);
var apiArgs = new API.Rest.ModifyMessageParams
{
Content = args.Content,
Embed = args.Embed.IsSpecified ? args.Embed.Value.ToModel() : Optional.Create <API.Embed>()
};
return(await client.ApiClient.ModifyMessageAsync(msg.Channel.Id, msg.Id, apiArgs, options).ConfigureAwait(false));
}
