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(); }