public void HandleMulticastEventNotification(SimpleHTTPRequest request)
{
string nt = request["NT"];
string nts = request["NTS"];
string sid = request["SID"];
string usn = request["USN"];
string svcid = request["SVCID"];
string contentType = request["CONTENT-TYPE"];
lock (_cpData.SyncObj)
{
CpService service;
if (nt != "upnp:event" || nts != "upnp:propchange" || string.IsNullOrEmpty(sid) ||
!TryGetService(usn, svcid, out service))
{
return;
}
Encoding contentEncoding;
string mediaType;
if (!EncodingUtils.TryParseContentTypeEncoding(contentType, Encoding.UTF8, out mediaType, out contentEncoding) ||
mediaType != "text/xml")
{
return;
}
Stream stream = new MemoryStream(request.MessageBody);
HandleEventNotification(stream, contentEncoding, service, _upnpVersion);
}
}
/// <summary>
/// Convert StackValue to boolean typed StackValue. Returns
/// StackValue.Null if not able to do conversion.
/// </summary>
/// <param name="core"></param>
/// <returns></returns>
public StackValue ToBoolean(RuntimeCore runtimeCore)
{
switch (optype)
{
case AddressType.Boolean:
return(this);
case AddressType.Int:
return(BuildBoolean(opdata != 0));
case AddressType.Null:
return(StackValue.Null);
case AddressType.Double:
bool b = !Double.IsNaN(RawDoubleValue) && !RawDoubleValue.Equals(0.0);
return(BuildBoolean(b));
case AddressType.Pointer:
return(StackValue.BuildBoolean(true));
case AddressType.String:
string str = runtimeCore.RuntimeMemory.Heap.GetString(this);
return(string.IsNullOrEmpty(str) ? StackValue.False : StackValue.True);
case AddressType.Char:
char c = EncodingUtils.ConvertInt64ToCharacter(opdata);
return((c == 0) ? StackValue.False : StackValue.True);
default:
return(StackValue.Null);
}
}
public void AddSubjectKeyId(string subjectKeyId)
{
if (_subjectKeyIds == null)
{
_subjectKeyIds = new ArrayList();
}
_subjectKeyIds.Add(EncodingUtils.DecodeHexString(subjectKeyId));
}
private static String ReadFast(ref MessagePackReader reader, ref byte position)
{
var length = (int)Unsafe.AddByteOffset(ref position, (IntPtr)1);
var valueSpan = reader.PeekFast(2, length);
reader.AdvanceWithinSpan(length + 2);
return(EncodingUtils.ToString(valueSpan));
}
private static String ReadFast(ref MessagePackReader reader, byte position)
{
var length = position & 0x1F;
var valueSpan = reader.PeekFast(1, length);
reader.AdvanceWithinSpan(length + 1);
return(EncodingUtils.ToString(valueSpan));
}
public void WithMessageBatch(List <IMessage <byte[]> > messageBatch)
{
BatchPayloads = new List <object>();
foreach (var m in messageBatch)
{
BatchPayloads.Add(EncodingUtils.GetDefaultEncoding().GetString((byte[])m.Payload));
}
}
public void TestConvertBytes()
{
var template = new RabbitTemplate();
var payload = EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!");
var message = template.ConvertMessageIfNecessary(payload);
Assert.Same(payload, message.Payload);
}
public BdxlLocator(Mode mode)
: this(
mode.GetValue("lookup.locator.bdxl.prefix"),
mode.GetValue("lookup.locator.hostname"),
mode.GetValue("lookup.locator.bdxl.algorithm"),
EncodingUtils.Get(mode.GetValue("lookup.locator.bdxl.encoding")),
mode.GetValue("lookup.locator.sml"))
{
}
private static String ReadFast(ref MessagePackReader reader, ref byte position)
{
IntPtr offset = (IntPtr)1;
var length = unchecked ((Unsafe.AddByteOffset(ref position, offset) << 8) + Unsafe.AddByteOffset(ref position, offset + 1));
var valueSpan = reader.PeekFast(3, length);
reader.AdvanceWithinSpan(length + 3);
return(EncodingUtils.ToString(valueSpan));
}
private static String ReadMultisegment(ref MessagePackReader reader)
{
var length = (int)reader.GetRawByte(1);
var readSize = length + 2;
var valueSpan = reader.Peek(readSize);
reader.Advance(readSize);
return(EncodingUtils.ToString(valueSpan.Slice(2, length)));
}
private static String ReadMultisegment(ref MessagePackReader reader, byte position)
{
var length = position & 0x1F;
var readSize = length + 1;
var valueSpan = reader.Peek(readSize);
reader.Advance(readSize);
return(EncodingUtils.ToString(valueSpan.Slice(1, length)));
}
public void TestConvertString()
{
var template = new RabbitTemplate();
var payload = "Hello, world!";
var message = template.ConvertMessageIfNecessary(payload);
var messageString = EncodingUtils.GetDefaultEncoding().GetString((byte[])message.Payload);
Assert.Equal(payload, messageString);
}
public void TestExplicitListenerMethod()
{
adapter.DefaultListenerMethod = "Handle";
adapter.Instance = simpleService;
var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
adapter.OnMessage(Message.Create(bytes, messageProperties), null);
Assert.Equal("Handle", simpleService.Called);
}
/// <summary>
/// The remote URL and signature are encoded in the "file" part
/// of the virtualPath parameter as follows:
/// path/path/.../path/url_b64.hmac.ext
/// </summary>
/// <param name="virtualPath"></param>
/// <returns></returns>
public async Task <IBlobData> Fetch(string virtualPath)
{
var remote = virtualPath
.Split('/')
.Last()?
.Split('.');
if (remote == null || remote.Length < 2)
{
logger?.LogWarning("Invalid remote path: {VirtualPath}", virtualPath);
throw new BlobMissingException($"Invalid remote path: {virtualPath}");
}
var urlBase64 = remote[0];
var hmac = remote[1];
var sig = Signatures.SignString(urlBase64, options.SigningKey, 8);
if (hmac != sig)
{
logger?.LogWarning("Missing or Invalid signature on remote path: {VirtualPath}", virtualPath);
throw new BlobMissingException($"Missing or Invalid signature on remote path: {virtualPath}");
}
var url = EncodingUtils.FromBase64UToString(urlBase64);
if (!Uri.TryCreate(url, UriKind.Absolute, out var uri))
{
logger?.LogWarning("RemoteReader blob {VirtualPath} not found. Invalid Uri: {Url}", virtualPath, url);
throw new BlobMissingException($"RemoteReader blob \"{virtualPath}\" not found. Invalid Uri: {url}");
}
var httpClientName = httpClientSelector(uri);
using var http = httpFactory.CreateClient(httpClientName);
try
{
var resp = await http.GetAsync(url);
if (!resp.IsSuccessStatusCode)
{
logger?.LogWarning("RemoteReader blob {VirtualPath} not found. The remote {Url} responded with status: {StatusCode}", virtualPath, url, resp.StatusCode);
throw new BlobMissingException($"RemoteReader blob \"{virtualPath}\" not found. The remote \"{url}\" responded with status: {resp.StatusCode}");
}
return(new RemoteReaderBlob(resp));
}
catch (BlobMissingException)
{
throw;
}
catch (Exception ex)
{
logger?.LogWarning(ex, "RemoteReader blob error retrieving {Url} for {VirtualPath}.", url, virtualPath);
throw new BlobMissingException($"RemoteReader blob error retrieving \"{url}\" for \"{virtualPath}\".", ex);
}
}
public void TestConvertMessage()
{
var template = new RabbitTemplate();
var payload = EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!");
var input = Message.Create(payload, new MessageHeaders());
var message = template.ConvertMessageIfNecessary(input);
Assert.Same(message, input);
}
public void TestShutdownWhileWaitingForReply()
{
var mockConnectionFactory = new Mock <RC.IConnectionFactory>();
var mockConnection = new Mock <RC.IConnection>();
var mockChannel1 = new Mock <RC.IModel>();
mockChannel1.Setup((c) => c.IsOpen).Returns(true);
mockConnection.Setup((c) => c.IsOpen).Returns(true);
mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())).Returns(mockConnection.Object);
mockConnection.SetupSequence((c) => c.CreateModel()).Returns(mockChannel1.Object);
mockChannel1.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties());
mockChannel1.Setup((c) => c.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()))
.Returns(() => new RC.QueueDeclareOk("foo", 0, 0));
var listener = new AtomicReference <EventHandler <RC.ShutdownEventArgs> >();
var shutdownLatch = new CountdownEvent(1);
mockChannel1.SetupAdd((m) => m.ModelShutdown += It.IsAny <EventHandler <RC.ShutdownEventArgs> >())
.Callback <EventHandler <RC.ShutdownEventArgs> >((handler) =>
{
listener.Value = handler;
shutdownLatch.Signal();
});
var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object);
var template = new RabbitTemplate(connectionFactory)
{
ReplyTimeout = 60_000
};
var input = Message.Create(EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!"), new MessageHeaders());
Task.Run(() =>
{
try
{
shutdownLatch.Wait(TimeSpan.FromSeconds(10));
}
catch (Exception)
{
// Ignore
}
listener.Value.Invoke(null, new RC.ShutdownEventArgs(RC.ShutdownInitiator.Peer, (ushort)RabbitUtils.NotFound, string.Empty));
});
try
{
template.DoSendAndReceiveWithTemporary("foo", "bar", input, null, default);
throw new Exception("Expected exception");
}
catch (RabbitException e)
{
var cause = e.InnerException;
Assert.IsType <ShutdownSignalException>(cause);
}
}
public Uri GetUserRealmEndpoint(string username)
{
return(new Uri(
string.Format(
CultureInfo.InvariantCulture,
"https://{0}/common/UserRealm/{1}?api-version=1.0",
_environment,
EncodingUtils.UrlEncode(username))));
}
protected override Encoding DetectStreamEncoding(Stream stream)
{
Encoding ret = EncodingUtils.GetEncodingFromConfigXMLName(fmtInfo.Encoding);
if (ret == null)
{
ret = EncodingUtils.DetectEncodingFromBOM(stream, EncodingUtils.GetDefaultEncoding());
}
return(ret);
}
public void CanReadLongAsShortStringNegative()
{
ByteBuffer buffer = ByteBuffer.Allocate(0x1000);
EncodingUtils.WriteShortStringBytes(buffer, "-98878122");
buffer.Flip();
long value = EncodingUtils.ReadLongAsShortString(buffer);
Assert.AreEqual(-98878122, value);
}
public static string SignData(string data, string key)
{
HMACSHA256 hmac = new HMACSHA256(UTF8Encoding.UTF8.GetBytes(key));
byte[] hash = hmac.ComputeHash(UTF8Encoding.UTF8.GetBytes(data));
//32-byte hash is a bit overkill. Truncation doesn't weaken the integrity of the algorithm.
byte[] shorterHash = new byte[8];
Array.Copy(hash, shorterHash, 8);
return(EncodingUtils.ToBase64U(shorterHash));
}
public void Test_GetUnicodeDEC(string str, string unicode)
{
//for (int i = 0; i < str.Length; i++)
//{
// var s = str[i].ToString();
// TestContext.WriteLine($"{s} {EncodingUtils.GetUnicodeDEC(s)}");
//}
TestContext.WriteLine($"{str} {EncodingUtils.GetUnicodeDEC(str)}");
}
public void CanReadLongAsShortStringEmpty()
{
ByteBuffer buffer = ByteBuffer.Allocate(0x1000);
EncodingUtils.WriteShortStringBytes(buffer, "");
buffer.Flip();
long value = EncodingUtils.ReadLongAsShortString(buffer);
Assert.AreEqual(0, value);
}
public void TestUninterruptibleListenerDMLC()
{
var cf = new CachingConnectionFactory("localhost");
var admin = new RabbitAdmin(cf);
admin.DeclareQueue(new Config.Queue("test.shutdown"));
var container = new DirectMessageListenerContainer(null, cf)
{
ShutdownTimeout = 500
};
container.SetQueueNames("test.shutdown");
var latch = new CountdownEvent(1);
var testEnded = new CountdownEvent(1);
var listener = new TestListener(latch, testEnded);
container.MessageListener = listener;
var connection = cf.CreateConnection() as ChannelCachingConnectionProxy;
// var channels = TestUtils.getPropertyValue(connection, "target.delegate._channelManager._channelMap");
var field = typeof(RC.Framing.Impl.Connection)
.GetField("m_sessionManager", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.NotNull(field);
var channels = (SessionManager)field.GetValue(connection.Target.Connection);
Assert.NotNull(channels);
container.Start();
Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));
try
{
var template = new RabbitTemplate(cf);
template.Execute(c =>
{
var properties = c.CreateBasicProperties();
var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
c.BasicPublish(string.Empty, "test.shutdown", false, properties, bytes);
RabbitUtils.SetPhysicalCloseRequired(c, false);
});
Assert.True(latch.Wait(TimeSpan.FromSeconds(30)));
Assert.Equal(2, channels.Count);
}
finally
{
container.Stop();
Assert.Equal(1, channels.Count);
cf.Destroy();
testEnded.Signal();
admin.DeleteQueue("test.shutdown");
}
}
protected override IMessage CreateMessage(object payload, IMessageHeaders messageProperties, object conversionHint)
{
byte[] bytes = null;
var accessor = RabbitHeaderAccessor.GetMutableAccessor(messageProperties);
if (payload is byte[])
{
bytes = (byte[])payload;
accessor.ContentType = MessageHeaders.CONTENT_TYPE_BYTES;
}
else if (payload is string)
{
try
{
var enc = EncodingUtils.GetEncoding(DefaultCharset);
bytes = enc.GetBytes((string)payload);
}
catch (Exception e)
{
throw new MessageConversionException("failed to convert to Message content", e);
}
accessor.ContentType = MessageHeaders.CONTENT_TYPE_TEXT_PLAIN;
accessor.ContentEncoding = DefaultCharset;
}
else if (payload.GetType().IsSerializable)
{
try
{
var formatter = new BinaryFormatter();
var stream = new MemoryStream(512);
// TODO: don't disable this warning! https://aka.ms/binaryformatter
#pragma warning disable SYSLIB0011 // Type or member is obsolete
formatter.Serialize(stream, payload);
#pragma warning restore SYSLIB0011 // Type or member is obsolete
bytes = stream.ToArray();
accessor.ContentType = MessageHeaders.CONTENT_TYPE_DOTNET_SERIALIZED_OBJECT;
}
catch (Exception e)
{
throw new MessageConversionException("failed to convert serialized Message content", e);
}
}
if (bytes == null)
{
throw new ArgumentException("SimpleMessageConverter only supports string, byte[] and serializable payloads, received: " + payload?.GetType().Name);
}
var message = Message.Create(bytes, messageProperties);
accessor.ContentLength = bytes.Length;
return(message);
}
public ERRORParser(string message)
{
// ERROR,<error code>,<error message>
string[] pieces = message.Trim().Split(',');
if (pieces.Length != 3)
{
throw new ParsingException("Unexpected response to control request: " + message);
}
errorCode = myParseInt(pieces[1], "error code", message);
errorMsg = EncodingUtils.unquote(pieces[2]);
}
public void TestAlternateConstructor()
{
var called = new AtomicBoolean(false);
var dele = new TestDelegate2(called);
adapter = new MessageListenerAdapter(null, dele, "MyPojoMessageMethod");
var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
adapter.OnMessage(Message.Create(bytes, messageProperties), null);
Assert.True(called.Value);
}
public static string EncodeAndSignUrl(string url, string key)
{
var uri = new Uri(url);
var path = uri.AbsolutePath;
var extension = Path.GetExtension(path);
var sanitizedExtension = PathHelpers.SanitizeImageExtension(extension) ?? "jpg";
var data = EncodingUtils.ToBase64U(url);
var sig = Signatures.SignString(data, key, 8);
return($"{data}.{sig}.{sanitizedExtension}");
}
public void TestDefaultListenerMethod()
{
var called = new AtomicBoolean(false);
var dele = new TestDelegate1(called);
adapter.Instance = dele;
var bytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
adapter.OnMessage(Message.Create(bytes, messageProperties), null);
Assert.True(called.Value);
}
public REQERRParser(string message)
{
// REQERR,<requestId>,<error code>,<error message>
string[] pieces = message.Trim().Split(',');
if (pieces.Length != 4)
{
throw new ParsingException("Unexpected response to control request: " + message);
}
requestId = myParseLong(pieces[1], "request identifier", message);
errorCode = myParseInt(pieces[2], "error code", message);
errorMsg = EncodingUtils.unquote(pieces[3]);
}
public async Task TestReleaseConsumerRace()
{
var connectionFactory = new CachingConnectionFactory("localhost");
var container = new DirectReplyToMessageListenerContainer(null, connectionFactory);
var latch = new CountdownEvent(1);
container.MessageListener = new EmptyListener();
var mockMessageListener = new MockChannelAwareMessageListener(container.MessageListener, latch);
container.SetChannelAwareMessageListener(mockMessageListener);
var foobytes = EncodingUtils.GetDefaultEncoding().GetBytes("foo");
var barbytes = EncodingUtils.GetDefaultEncoding().GetBytes("bar");
await container.Start();
Assert.True(container._startedLatch.Wait(TimeSpan.FromSeconds(10)));
var channel1 = container.GetChannelHolder();
var props = channel1.Channel.CreateBasicProperties();
props.ReplyTo = Address.AMQ_RABBITMQ_REPLY_TO;
RC.IModelExensions.BasicPublish(channel1.Channel, string.Empty, TEST_RELEASE_CONSUMER_Q, props, foobytes);
var replyChannel = connectionFactory.CreateConnection().CreateChannel(false);
var request = replyChannel.BasicGet(TEST_RELEASE_CONSUMER_Q, true);
var n = 0;
while (n++ < 100 && request == null)
{
Thread.Sleep(100);
request = replyChannel.BasicGet(TEST_RELEASE_CONSUMER_Q, true);
}
Assert.NotNull(request);
props = channel1.Channel.CreateBasicProperties();
RC.IModelExensions.BasicPublish(replyChannel, string.Empty, request.BasicProperties.ReplyTo, props, barbytes);
replyChannel.Close();
Assert.True(latch.Wait(TimeSpan.FromSeconds(10)));
var channel2 = container.GetChannelHolder();
Assert.Same(channel1.Channel, channel2.Channel);
container.ReleaseConsumerFor(channel1, false, null); // simulate race for future timeout/cancel and onMessage()
var inUse = container._inUseConsumerChannels;
Assert.Single(inUse);
container.ReleaseConsumerFor(channel2, false, null);
Assert.Empty(inUse);
await container.Stop();
connectionFactory.Destroy();
}
