/// <summary> /// Constructor /// </summary> /// <param name="cloudEvent">CloudEvent</param> /// <param name="contentMode">Content mode. Structured or binary.</param> /// <param name="formatter">Event formatter</param> public CloudEventContent(CloudEvent cloudEvent, ContentMode contentMode, ICloudEventFormatter formatter) { if (contentMode == ContentMode.Structured) { inner = new InnerByteArrayContent(formatter.EncodeStructuredEvent(cloudEvent, out var contentType)); // This is optional in the specification, but can be useful. MapHeaders(cloudEvent, includeDataContentType: true); Headers.ContentType = new MediaTypeHeaderValue(contentType.MediaType); return; } if (cloudEvent.Data is byte[]) { inner = new InnerByteArrayContent((byte[])cloudEvent.Data); } else if (cloudEvent.Data is string) { inner = new InnerStringContent((string)cloudEvent.Data); } else if (cloudEvent.Data is Stream) { inner = new InnerStreamContent((Stream)cloudEvent.Data); } else { inner = new InnerByteArrayContent(formatter.EncodeAttribute(cloudEvent.SpecVersion, CloudEventAttributes.DataAttributeName(cloudEvent.SpecVersion), cloudEvent.Data, cloudEvent.Extensions.Values)); } var mediaType = cloudEvent.DataContentType?.MediaType ?? throw new ArgumentException(Strings.ErrorContentTypeUnspecified, nameof(cloudEvent)); Headers.ContentType = new MediaTypeHeaderValue(mediaType); MapHeaders(cloudEvent, includeDataContentType: false); }
/// <summary> /// Constructor /// </summary> /// <param name="cloudEvent">CloudEvent</param> /// <param name="contentMode">Content mode. Structured or binary.</param> /// <param name="formatter">Event formatter</param> public CloudEventContent(CloudEvent cloudEvent, ContentMode contentMode, ICloudEventFormatter formatter) { if (contentMode == ContentMode.Structured) { inner = new InnerByteArrayContent(formatter.EncodeStructuredEvent(cloudEvent, out var contentType)); Headers.ContentType = new MediaTypeHeaderValue(contentType.MediaType); MapHeaders(cloudEvent); return; } if (cloudEvent.Data is byte[]) { inner = new InnerByteArrayContent((byte[])cloudEvent.Data); } else if (cloudEvent.Data is string) { inner = new InnerStringContent((string)cloudEvent.Data); } else if (cloudEvent.Data is Stream) { inner = new InnerStreamContent((Stream)cloudEvent.Data); } else { inner = new InnerByteArrayContent(formatter.EncodeAttribute(cloudEvent.SpecVersion, CloudEventAttributes.DataAttributeName(cloudEvent.SpecVersion), cloudEvent.Data, cloudEvent.Extensions.Values)); } Headers.ContentType = new MediaTypeHeaderValue(cloudEvent.DataContentType?.MediaType); MapHeaders(cloudEvent); }
public AmqpCloudEventMessage(CloudEvent cloudEvent, ContentMode contentMode, ICloudEventFormatter formatter) { ApplicationProperties = new ApplicationProperties(); MapHeaders(cloudEvent); if (contentMode == ContentMode.Structured) { BodySection = new Data { Binary = formatter.EncodeStructuredEvent(cloudEvent, out var contentType) }; Properties = new Properties { ContentType = contentType.MediaType }; ApplicationProperties = new ApplicationProperties(); MapHeaders(cloudEvent); return; } else { BodySection = SerializeData(cloudEvent.Data); Properties = new Properties { ContentType = cloudEvent.DataContentType }; } }
public static void Update <T>(this IBasicProperties self, MotorCloudEvent <byte[]> cloudEvent, RabbitMQPublisherConfig <T> config, ICloudEventFormatter cloudEventFormatter) { var messagePriority = cloudEvent.Extension <RabbitMQPriorityExtension>()?.Priority ?? config.DefaultPriority; if (messagePriority.HasValue) { self.Priority = messagePriority.Value; } var dictionary = new Dictionary <string, object>(); foreach (var attr in cloudEvent.GetAttributes()) { if (string.Equals(attr.Key, CloudEventAttributes.DataAttributeName(cloudEvent.SpecVersion)) || string.Equals(attr.Key, CloudEventAttributes.DataContentTypeAttributeName(cloudEvent.SpecVersion)) || string.Equals(attr.Key, RabbitMQPriorityExtension.PriorityAttributeName) || string.Equals(attr.Key, RabbitMQBindingConfigExtension.ExchangeAttributeName) || string.Equals(attr.Key, RabbitMQBindingConfigExtension.RoutingKeyAttributeName)) { continue; } dictionary.Add($"{CloudEventPrefix}{attr.Key}", cloudEventFormatter.EncodeAttribute(cloudEvent.SpecVersion, attr.Key, attr.Value, cloudEvent.GetExtensions().Values)); } self.Headers = dictionary; }
public static CloudEvent ToCloudEvent(this Message <string, byte[]> message, ICloudEventFormatter eventFormatter = null, params ICloudEventExtension[] extensions) { if (!IsCloudEvent(message)) { throw new InvalidOperationException(); } var contentType = ExtractContentType(message); CloudEvent cloudEvent; if (!string.IsNullOrEmpty(contentType) && contentType.StartsWith(CloudEvent.MediaType, StringComparison.InvariantCultureIgnoreCase)) { // structured mode if (eventFormatter == null) { if (contentType.EndsWith(JsonEventFormatter.MediaTypeSuffix, StringComparison.InvariantCultureIgnoreCase)) { eventFormatter = _jsonFormatter; } else { throw new InvalidOperationException("Not supported CloudEvents media formatter."); } } cloudEvent = _jsonFormatter.DecodeStructuredEvent(message.Value, extensions); } else { // binary mode var specVersion = ExtractVersion(message); cloudEvent = new CloudEvent(specVersion, extensions); var attributes = cloudEvent.GetAttributes(); var cloudEventHeaders = message.Headers.Where(h => h.Key.StartsWith(KafkaCloudEventMessage.KafkaHeaderPerfix)); foreach (var header in cloudEventHeaders) { if (string.Equals(header.Key, SpecVersionKafkaHeader1, StringComparison.InvariantCultureIgnoreCase) || string.Equals(header.Key, SpecVersionKafkaHeader2, StringComparison.InvariantCultureIgnoreCase)) { continue; } var attributeName = header.Key.Substring(KafkaCloudEventMessage.KafkaHeaderPerfix.Length); attributes.Add(attributeName, eventFormatter.DecodeAttribute(specVersion, attributeName, header.GetValueBytes(), extensions)); } cloudEvent.DataContentType = contentType != null ? new ContentType(contentType) : null; cloudEvent.Data = message.Value; } InitPartitioningKey(message, cloudEvent); return(cloudEvent); }
public RabbitMQMessagePublisher(IRabbitMQConnectionFactory connectionFactory, IOptions <RabbitMQPublisherConfig <T> > config, ICloudEventFormatter cloudEventFormatter) { _connectionFactory = connectionFactory; _cloudEventFormatter = cloudEventFormatter; _config = config.Value; }
public KafkaMessagePublisher(IOptions <KafkaPublisherConfig <T> > options, ICloudEventFormatter cloudEventFormatter) { _cloudEventFormatter = cloudEventFormatter; config = options.Value ?? throw new ArgumentNullException(nameof(options)); producer = new ProducerBuilder <string, byte[]>(config).Build(); }
static Stream MapDataAttributeToStream(CloudEvent cloudEvent, ICloudEventFormatter formatter) { Stream stream; if (cloudEvent.Data is byte[]) { stream = new MemoryStream((byte[])cloudEvent.Data); } else if (cloudEvent.Data is string) { stream = new MemoryStream(Encoding.UTF8.GetBytes((string)cloudEvent.Data)); } else if (cloudEvent.Data is Stream) { stream = (Stream)cloudEvent.Data; } else { stream = new MemoryStream(formatter.EncodeAttribute(cloudEvent.SpecVersion, CloudEventAttributes.DataAttributeName(cloudEvent.SpecVersion), cloudEvent.Data, cloudEvent.Extensions.Values)); } return(stream); }
public static CloudEvent ToCloudEvent(this Message message, ICloudEventFormatter formatter, params ICloudEventExtension[] extensions) { if (message == null) { throw new ArgumentNullException(nameof(message)); } return(InternalToCloudEvent(message, formatter, extensions)); }
public CloudEventJsonInputFormatter(ICloudEventFormatter formatter) { _formatter = formatter; SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/json")); SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/cloudevents+json")); SupportedEncodings.Add(Encoding.UTF8); SupportedEncodings.Add(Encoding.Unicode); }
public static CloudEvent ToCloudEvent(this Message <string, byte[]> message, ICloudEventFormatter eventFormatter, IEnumerable <CloudEventAttribute> extensionAttributes) { if (!IsCloudEvent(message)) { throw new InvalidOperationException(); } var contentType = ExtractContentType(message); CloudEvent cloudEvent; // Structured mode if (contentType?.StartsWith(CloudEvent.MediaType, StringComparison.InvariantCultureIgnoreCase) == true) { cloudEvent = eventFormatter.DecodeStructuredEvent(message.Value, extensionAttributes); } else { // Binary mode CloudEventsSpecVersion version = CloudEventsSpecVersion.Default; if (GetHeaderValue(message, KafkaCloudEventMessage.SpecVersionKafkaHeader) is byte[] versionIdBytes) { string versionId = Encoding.UTF8.GetString(versionIdBytes); version = CloudEventsSpecVersion.FromVersionId(versionId); } cloudEvent = new CloudEvent(version, extensionAttributes) { Data = message.Value, DataContentType = contentType }; foreach (var header in message.Headers.Where(h => h.Key.StartsWith(KafkaCloudEventMessage.KafkaHeaderPrefix))) { var attributeName = header.Key.Substring(KafkaCloudEventMessage.KafkaHeaderPrefix.Length).ToLowerInvariant(); if (attributeName == CloudEventsSpecVersion.SpecVersionAttribute.Name) { continue; } // TODO: Is this feasible? var headerValue = header.GetValueBytes(); if (headerValue is null) { continue; } string attributeValue = Encoding.UTF8.GetString(headerValue); cloudEvent.SetAttributeFromString(attributeName, attributeValue); } } InitPartitioningKey(message, cloudEvent); return(cloudEvent); }
public RabbitMQMessageConsumer(ILogger <RabbitMQMessageConsumer <T> > logger, IRabbitMQConnectionFactory connectionFactory, IOptions <RabbitMQConsumerConfig <T> > config, IHostApplicationLifetime applicationLifetime, IApplicationNameService applicationNameService, ICloudEventFormatter cloudEventFormatter) { _logger = logger; _connectionFactory = connectionFactory; _config = config.Value; _applicationLifetime = applicationLifetime; _applicationNameService = applicationNameService; _cloudEventFormatter = cloudEventFormatter; }
private void MapHeaders(CloudEvent cloudEvent, ICloudEventFormatter formatter) { foreach (var pair in cloudEvent.GetPopulatedAttributes()) { var attribute = pair.Key; if (attribute == cloudEvent.SpecVersion.DataContentTypeAttribute || attribute.Name == Partitioning.PartitionKeyAttribute.Name) { continue; } var value = attribute.Format(pair.Value); Headers.Add(KafkaHeaderPrefix + attribute.Name, Encoding.UTF8.GetBytes(value)); } }
public KafkaMessageConsumer(ILogger <KafkaMessageConsumer <TData> > logger, IOptions <KafkaConsumerConfig <TData> > config, IMetricsFactory <KafkaMessageConsumer <TData> >?metricsFactory, IApplicationNameService applicationNameService, ICloudEventFormatter cloudEventFormatter) { _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _applicationNameService = applicationNameService ?? throw new ArgumentNullException(nameof(config)); _cloudEventFormatter = cloudEventFormatter; _config = config?.Value ?? throw new ArgumentNullException(nameof(config)); _consumerLagSummary = metricsFactory?.CreateSummary("consumer_lag_distribution", "Contains a summary of current consumer lag of each partition", new [] { "topic", "partition" }); _consumerLagGauge = metricsFactory?.CreateGauge("consumer_lag", "Contains current number consumer lag of each partition", false, "topic", "partition"); }
private void MapHeaders(CloudEvent cloudEvent, ICloudEventFormatter formatter) { foreach (var attr in cloudEvent.GetAttributes()) { if (string.Equals(attr.Key, CloudEventAttributes.DataAttributeName(cloudEvent.SpecVersion)) || string.Equals(attr.Key, CloudEventAttributes.DataContentTypeAttributeName(cloudEvent.SpecVersion)) || string.Equals(attr.Key, PartitioningExtension.PartitioningKeyAttributeName)) { continue; } Headers.Add(KafkaHeaderPerfix + attr.Key, formatter.EncodeAttribute(cloudEvent.SpecVersion, attr.Key, attr.Value, cloudEvent.Extensions.Values)); } }
/// <summary> /// Converts this HTTP request into a CloudEvent object, with the given extensions, /// overriding the formatter. /// </summary> /// <param name="httpRequest">HTTP request</param> /// <param name="formatter">The event formatter to use to process the request body.</param> /// <param name="extensions">List of extension instances</param> /// <returns>A CloudEvent instance or 'null' if the request message doesn't hold a CloudEvent</returns> public static async ValueTask <CloudEvent> ReadCloudEventAsync(this HttpRequest httpRequest, ICloudEventFormatter formatter, params CloudEventAttribute[] extensionAttributes) { if (HasCloudEventsContentType(httpRequest)) { // TODO: Handle formatter being null return(await formatter.DecodeStructuredEventAsync(httpRequest.Body, extensionAttributes).ConfigureAwait(false)); } else { var headers = httpRequest.Headers; CloudEventsSpecVersion version = CloudEventsSpecVersion.Default; if (headers.TryGetValue(HttpUtilities.SpecVersionHttpHeader, out var values)) { string versionId = values.First(); version = CloudEventsSpecVersion.FromVersionId(versionId); } var cloudEvent = new CloudEvent(version, extensionAttributes); foreach (var header in headers) { string attributeName = HttpUtilities.GetAttributeNameFromHeaderName(header.Key); if (attributeName is null || attributeName == CloudEventsSpecVersion.SpecVersionAttribute.Name) { continue; } string attributeValue = HttpUtilities.DecodeHeaderValue(header.Value.First()); cloudEvent.SetAttributeFromString(attributeName, attributeValue); } cloudEvent.DataContentType = httpRequest.ContentType; if (httpRequest.Body is Stream body) { // TODO: This is a bit ugly. var memoryStream = new MemoryStream(); await body.CopyToAsync(memoryStream).ConfigureAwait(false); if (memoryStream.Length != 0) { cloudEvent.Data = formatter.DecodeData(memoryStream.ToArray(), cloudEvent.DataContentType); } } return(cloudEvent); } }
/// <summary> /// Constructor /// </summary> /// <param name="cloudEvent">CloudEvent</param> /// <param name="contentMode">Content mode. Structured or binary.</param> /// <param name="formatter">Event formatter</param> public CloudEventHttpContent(CloudEvent cloudEvent, ContentMode contentMode, ICloudEventFormatter formatter) { if (contentMode == ContentMode.Structured) { inner = new InnerByteArrayContent(formatter.EncodeStructuredEvent(cloudEvent, out var contentType)); // This is optional in the specification, but can be useful. MapHeaders(cloudEvent, includeDataContentType: true); Headers.ContentType = new MediaTypeHeaderValue(contentType.MediaType); return; } // TODO: Shouldn't we use the formatter in all cases? If I have a JSON formatter and // If we specify that the the data is a byte array, I'd expect to end up with a base64-encoded representation... if (cloudEvent.Data is byte[]) { inner = new InnerByteArrayContent((byte[])cloudEvent.Data); } else if (cloudEvent.Data is string) { inner = new InnerStringContent((string)cloudEvent.Data); } else if (cloudEvent.Data is Stream) { inner = new InnerStreamContent((Stream)cloudEvent.Data); } else { inner = new InnerByteArrayContent(formatter.EncodeData(cloudEvent.Data)); } // We don't require a data content type if there isn't any data. // We may not be able to tell whether the data is empty or not, but we're lenient // in that case. var dataContentType = cloudEvent.DataContentType; if (dataContentType is object) { var mediaType = new ContentType(dataContentType).MediaType; Headers.ContentType = new MediaTypeHeaderValue(mediaType); } else if (TryComputeLength(out var length) && length != 0L) { throw new ArgumentException(Strings.ErrorContentTypeUnspecified, nameof(cloudEvent)); } MapHeaders(cloudEvent, includeDataContentType: false); }
public ServiceBusCloudEventMessage(CloudEvent cloudEvent, ICloudEventFormatter formatter) { if (cloudEvent == null) { throw new ArgumentNullException(nameof(cloudEvent)); } if (formatter == null) { throw new ArgumentNullException(nameof(formatter)); } Body = formatter.EncodeStructuredEvent(cloudEvent, out var contentType); ContentType = contentType.MediaType; MessageId = cloudEvent.Id; MapHeaders(cloudEvent); }
public CloudEventReader(Dictionary <string, Type> typeMappings, ILogger <CloudEventReader> logger) { #region Check arguments if (typeMappings == null || typeMappings.Count == 0) { throw new ArgumentNullException("typeMappings"); } #endregion this._typeMappings = typeMappings; this._logger = logger; this._pLoadFormatters = new List <IPayloadDeserializationFormatter>() { new JsonPayloadDeserializationFormatter() }; this._cEventsFormatter = new JsonEventFormatter(); }
/// <summary> /// Copies the CloudEvent into this HttpListenerResponse instance /// </summary> /// <param name="httpListenerResponse">this</param> /// <param name="cloudEvent">CloudEvent to copy</param> /// <param name="contentMode">Content mode (structured or binary)</param> /// <param name="formatter">Formatter</param> /// <returns>Task</returns> public static Task CopyFromAsync(this HttpListenerResponse httpListenerResponse, CloudEvent cloudEvent, ContentMode contentMode, ICloudEventFormatter formatter) { if (contentMode == ContentMode.Structured) { var buffer = formatter.EncodeStructuredEvent(cloudEvent, out var contentType); httpListenerResponse.ContentType = contentType.ToString(); MapAttributesToListenerResponse(cloudEvent, httpListenerResponse); return(httpListenerResponse.OutputStream.WriteAsync(buffer, 0, buffer.Length)); } Stream stream = MapDataAttributeToStream(cloudEvent, formatter); httpListenerResponse.ContentType = cloudEvent.DataContentType.ToString(); MapAttributesToListenerResponse(cloudEvent, httpListenerResponse); return(stream.CopyToAsync(httpListenerResponse.OutputStream)); }
// TODO: Check the pattern here. I suspect that cloudEvent.CopyToAsync(response) would be more natural. /// <summary> /// Copies the CloudEvent into this HttpListenerResponse instance /// </summary> /// <param name="httpListenerResponse">this</param> /// <param name="cloudEvent">CloudEvent to copy</param> /// <param name="contentMode">Content mode (structured or binary)</param> /// <param name="formatter">Formatter</param> /// <returns>Task</returns> public static Task CopyFromAsync(this HttpListenerResponse httpListenerResponse, CloudEvent cloudEvent, ContentMode contentMode, ICloudEventFormatter formatter) { if (contentMode == ContentMode.Structured) { var buffer = formatter.EncodeStructuredEvent(cloudEvent, out var contentType); httpListenerResponse.ContentType = contentType.ToString(); MapAttributesToListenerResponse(cloudEvent, httpListenerResponse); return(httpListenerResponse.OutputStream.WriteAsync(buffer, 0, buffer.Length)); } Stream stream = HttpUtilities.MapDataAttributeToStream(cloudEvent, formatter); // TODO: Check the defaulting to JSON here... httpListenerResponse.ContentType = cloudEvent.DataContentType?.ToString() ?? "application/json"; MapAttributesToListenerResponse(cloudEvent, httpListenerResponse); return(stream.CopyToAsync(httpListenerResponse.OutputStream)); }
/// <summary> /// Copies the CloudEvent into this HttpWebRequest instance /// </summary> /// <param name="httpWebRequest">this</param> /// <param name="cloudEvent">CloudEvent to copy</param> /// <param name="contentMode">Content mode (structured or binary)</param> /// <param name="formatter">Formatter</param> /// <returns>Task</returns> public static async Task CopyFromAsync(this HttpWebRequest httpWebRequest, CloudEvent cloudEvent, ContentMode contentMode, ICloudEventFormatter formatter) { if (contentMode == ContentMode.Structured) { var buffer = formatter.EncodeStructuredEvent(cloudEvent, out var contentType); httpWebRequest.ContentType = contentType.ToString(); await(httpWebRequest.GetRequestStream()).WriteAsync(buffer, 0, buffer.Length); return; } Stream stream = MapDataAttributeToStream(cloudEvent, formatter); httpWebRequest.ContentType = cloudEvent.DataContentType?.ToString() ?? "application/json"; MapAttributesToWebRequest(cloudEvent, httpWebRequest); await stream.CopyToAsync(httpWebRequest.GetRequestStream()); }
/// <summary> /// Converts this listener request into a CloudEvent object, with the given extension attributes. /// </summary> /// <param name="httpListenerRequest">Listener request</param> /// <param name="formatter"></param> /// <param name="extensions">List of extension instances</param> /// <returns>A CloudEvent instance or 'null' if the request message doesn't hold a CloudEvent</returns> public static CloudEvent ToCloudEvent(this HttpListenerRequest httpListenerRequest, ICloudEventFormatter formatter, params CloudEventAttribute[] extensionAttributes) { if (HasCloudEventsContentType(httpListenerRequest)) { // FIXME: Handle no formatter being specified. return(formatter.DecodeStructuredEvent(httpListenerRequest.InputStream, extensionAttributes)); } else { CloudEventsSpecVersion version = CloudEventsSpecVersion.Default; if (httpListenerRequest.Headers[HttpUtilities.SpecVersionHttpHeader] is string versionId) { version = CloudEventsSpecVersion.FromVersionId(versionId); } var cloudEvent = new CloudEvent(version, extensionAttributes); var headers = httpListenerRequest.Headers; foreach (var key in headers.AllKeys) { string attributeName = HttpUtilities.GetAttributeNameFromHeaderName(key); if (attributeName is null || attributeName == CloudEventsSpecVersion.SpecVersionAttribute.Name) { continue; } string attributeValue = HttpUtilities.DecodeHeaderValue(headers[key]); cloudEvent.SetAttributeFromString(attributeName, attributeValue); } // TODO: Check that this doesn't come through as a header already cloudEvent.DataContentType = httpListenerRequest.ContentType; // TODO: This is a bit ugly. var memoryStream = new MemoryStream(); httpListenerRequest.InputStream.CopyTo(memoryStream); if (memoryStream.Length != 0) { cloudEvent.Data = formatter.DecodeData(memoryStream.ToArray(), cloudEvent.DataContentType); } return(cloudEvent); } }
private static async Task <CloudEvent> ToCloudEventInternalAsync(HttpHeaders headers, HttpContent content, ICloudEventFormatter formatter, IEnumerable <CloudEventAttribute> extensionAttributes) { if (HasCloudEventsContentType(content)) { // FIXME: Handle no formatter being specified. var stream = await content.ReadAsStreamAsync().ConfigureAwait(false); return(await formatter.DecodeStructuredEventAsync(stream, extensionAttributes).ConfigureAwait(false)); } else { CloudEventsSpecVersion version = CloudEventsSpecVersion.Default; if (headers.Contains(HttpUtilities.SpecVersionHttpHeader)) { string versionId = headers.GetValues(HttpUtilities.SpecVersionHttpHeader).First(); version = CloudEventsSpecVersion.FromVersionId(versionId); } var cloudEvent = new CloudEvent(version, extensionAttributes); foreach (var header in headers) { string attributeName = HttpUtilities.GetAttributeNameFromHeaderName(header.Key); if (attributeName is null || attributeName == CloudEventsSpecVersion.SpecVersionAttribute.Name) { continue; } string attributeValue = HttpUtilities.DecodeHeaderValue(header.Value.First()); cloudEvent.SetAttributeFromString(attributeName, attributeValue); } if (content is object) { // TODO: Should this just be the media type? We probably need to take a full audit of this... cloudEvent.DataContentType = content.Headers?.ContentType?.ToString(); var data = await content.ReadAsByteArrayAsync().ConfigureAwait(false); cloudEvent.Data = formatter.DecodeData(data, cloudEvent.DataContentType); } return(cloudEvent); } }
public CloudEventWriter(string eventTypeUrnAuthority, Uri eventSource, ILogger <CloudEventWriter> logger) { #region Check arguments if (String.IsNullOrWhiteSpace(eventTypeUrnAuthority)) { throw new ArgumentNullException("eventTypeUrnAuthority"); } if (eventSource == null) { throw new ArgumentNullException("eventSource"); } #endregion this._pLoadFormatters = new List <IPayloadSerializationFormatter>() { new JsonPayloadSerializationFormatter() }; this._declarativeTypeMapper = Utils.ConvertPascalToKebabCase; this._eventTypeUrnAuthority = eventTypeUrnAuthority.ToLower(); this._eventSource = eventSource; this._cEventsFormatter = new JsonEventFormatter(); this._logger = logger; }
static CloudEvent ToCloudEventInternal(HttpResponseMessage httpResponseMessage, ICloudEventFormatter formatter, ICloudEventExtension[] extensions) { if (httpResponseMessage.Content?.Headers.ContentType != null && httpResponseMessage.Content.Headers.ContentType.MediaType.StartsWith("application/cloudevents", StringComparison.InvariantCultureIgnoreCase)) { // handle structured mode if (formatter == null) { // if we didn't get a formatter, pick one if (httpResponseMessage.Content.Headers.ContentType.MediaType.EndsWith("+json", StringComparison.InvariantCultureIgnoreCase)) { formatter = jsonFormatter; } else { throw new InvalidOperationException("Unsupported CloudEvents encoding"); } } return(formatter.DecodeStructuredEvent( httpResponseMessage.Content.ReadAsByteArrayAsync().GetAwaiter().GetResult(), extensions)); } else { CloudEventsSpecVersion version = CloudEventsSpecVersion.Default; if (httpResponseMessage.Headers.Contains(SpecVersionHttpHeader1)) { version = CloudEventsSpecVersion.V0_1; } if (httpResponseMessage.Headers.Contains(SpecVersionHttpHeader2)) { version = httpResponseMessage.Headers.GetValues(SpecVersionHttpHeader2).First() == "0.2" ? CloudEventsSpecVersion.V0_2 : httpResponseMessage.Headers.GetValues(SpecVersionHttpHeader2).First() == "0.3" ? CloudEventsSpecVersion.V0_3 : CloudEventsSpecVersion.Default; } var cloudEvent = new CloudEvent(version, extensions); var attributes = cloudEvent.GetAttributes(); foreach (var httpResponseHeader in httpResponseMessage.Headers) { if (httpResponseHeader.Key.Equals(SpecVersionHttpHeader1, StringComparison.InvariantCultureIgnoreCase) || httpResponseHeader.Key.Equals(SpecVersionHttpHeader2, StringComparison.InvariantCultureIgnoreCase)) { continue; } if (httpResponseHeader.Key.StartsWith(HttpHeaderPrefix, StringComparison.InvariantCultureIgnoreCase)) { string headerValue = httpResponseHeader.Value.First(); var name = httpResponseHeader.Key.Substring(3); // abolished structures in headers in 1.0 if (version != CloudEventsSpecVersion.V1_0 && (headerValue.StartsWith("\"") && headerValue.EndsWith("\"") || headerValue.StartsWith("'") && headerValue.EndsWith("'") || headerValue.StartsWith("{") && headerValue.EndsWith("}") || headerValue.StartsWith("[") && headerValue.EndsWith("]"))) { attributes[name] = jsonFormatter.DecodeAttribute(version, name, Encoding.UTF8.GetBytes(headerValue), extensions); } else { attributes[name] = headerValue; } } } cloudEvent.DataContentType = httpResponseMessage.Content?.Headers.ContentType != null ? new ContentType(httpResponseMessage.Content.Headers.ContentType.ToString()) : null; cloudEvent.Data = httpResponseMessage.Content?.ReadAsStreamAsync().GetAwaiter().GetResult(); return(cloudEvent); } }
/// <summary> /// Converts this listener request into a CloudEvent object, with the given extensions, /// overriding the formatter. /// </summary> /// <param name="httpListenerRequest">Listener request</param> /// <param name="formatter"></param> /// <param name="extensions">List of extension instances</param> /// <returns>A CloudEvent instance or 'null' if the request message doesn't hold a CloudEvent</returns> public static CloudEvent ToCloudEvent(this HttpRequestMessage httpListenerRequest, ICloudEventFormatter formatter = null, params ICloudEventExtension[] extensions) { if (httpListenerRequest.Content != null && httpListenerRequest.Content.Headers.ContentType != null && httpListenerRequest.Content.Headers.ContentType.MediaType.StartsWith(CloudEvent.MediaType, StringComparison.InvariantCultureIgnoreCase)) { // handle structured mode if (formatter == null) { // if we didn't get a formatter, pick one if (httpListenerRequest.Content.Headers.ContentType.MediaType.EndsWith( JsonEventFormatter.MediaTypeSuffix, StringComparison.InvariantCultureIgnoreCase)) { formatter = jsonFormatter; } else { throw new InvalidOperationException("Unsupported CloudEvents encoding"); } } return(formatter.DecodeStructuredEvent( httpListenerRequest.Content.ReadAsStreamAsync().GetAwaiter().GetResult(), extensions)); } else { CloudEventsSpecVersion version = CloudEventsSpecVersion.Default; if (httpListenerRequest.Headers.Contains(SpecVersionHttpHeader1)) { version = CloudEventsSpecVersion.V0_1; } if (httpListenerRequest.Headers.Contains(SpecVersionHttpHeader2)) { version = httpListenerRequest.Headers.GetValues(SpecVersionHttpHeader2).First() == "0.2" ? CloudEventsSpecVersion.V0_2 : CloudEventsSpecVersion.Default; } var cloudEvent = new CloudEvent(version, extensions); var attributes = cloudEvent.GetAttributes(); foreach (var httpRequestHeaders in httpListenerRequest.Headers) { if (httpRequestHeaders.Key.Equals(SpecVersionHttpHeader1, StringComparison.InvariantCultureIgnoreCase) || httpRequestHeaders.Key.Equals(SpecVersionHttpHeader2, StringComparison.InvariantCultureIgnoreCase)) { continue; } if (httpRequestHeaders.Key.StartsWith(HttpHeaderPrefix, StringComparison.InvariantCultureIgnoreCase)) { string headerValue = httpListenerRequest.Headers.GetValues(httpRequestHeaders.Key).First(); // maps in headers have been abolished in version 1.0 if (version != CloudEventsSpecVersion.V1_0 && (headerValue.StartsWith("{") && headerValue.EndsWith("}") || headerValue.StartsWith("[") && headerValue.EndsWith("]"))) { attributes[httpRequestHeaders.Key.Substring(3)] = JsonConvert.DeserializeObject(headerValue); } else { attributes[httpRequestHeaders.Key.Substring(3)] = headerValue; } } } cloudEvent.DataContentType = httpListenerRequest.Content?.Headers.ContentType != null ? new ContentType(httpListenerRequest.Content.Headers.ContentType.MediaType) : null; cloudEvent.Data = httpListenerRequest.Content?.ReadAsStreamAsync().GetAwaiter().GetResult(); return(cloudEvent); } }
/// <summary> /// Converts this response message into a CloudEvent object, with the given extensions and /// overriding the default formatter. /// </summary> /// <param name="httpResponseMessage">Response message</param> /// <param name="formatter"></param> /// <param name="extensions">List of extension instances</param> /// <returns>A CloudEvent instance or 'null' if the response message doesn't hold a CloudEvent</returns> public static CloudEvent ToCloudEvent(this HttpResponseMessage httpResponseMessage, ICloudEventFormatter formatter, params ICloudEventExtension[] extensions) { return(ToCloudEventInternal(httpResponseMessage, formatter, extensions)); }
/// <summary> /// Converts this listener request into a CloudEvent object, with the given extensions, /// overriding the formatter. /// </summary> /// <param name="httpListenerRequest">Listener request</param> /// <param name="formatter"></param> /// <param name="extensions">List of extension instances</param> /// <returns>A CloudEvent instance or 'null' if the response message doesn't hold a CloudEvent</returns> public static CloudEvent ToCloudEvent(this HttpListenerRequest httpListenerRequest, ICloudEventFormatter formatter = null, params ICloudEventExtension[] extensions) { if (httpListenerRequest.ContentType != null && httpListenerRequest.ContentType.StartsWith(CloudEvent.MediaType, StringComparison.InvariantCultureIgnoreCase)) { // handle structured mode if (formatter == null) { // if we didn't get a formatter, pick one if (httpListenerRequest.ContentType.EndsWith(JsonEventFormatter.MediaTypeSuffix, StringComparison.InvariantCultureIgnoreCase)) { formatter = jsonFormatter; } else { throw new InvalidOperationException("Unsupported CloudEvents encoding"); } } return(formatter.DecodeStructuredEvent(httpListenerRequest.InputStream, extensions)); } else { CloudEventsSpecVersion version = CloudEventsSpecVersion.Default; if (httpListenerRequest.Headers[SpecVersionHttpHeader1] != null) { version = CloudEventsSpecVersion.V0_1; } if (httpListenerRequest.Headers[SpecVersionHttpHeader2] != null) { version = httpListenerRequest.Headers[SpecVersionHttpHeader2] == "0.2" ? CloudEventsSpecVersion.V0_2 : httpListenerRequest.Headers[SpecVersionHttpHeader2] == "0.3" ? CloudEventsSpecVersion.V0_3 : CloudEventsSpecVersion.Default; } var cloudEvent = new CloudEvent(version, extensions); var attributes = cloudEvent.GetAttributes(); foreach (var httpRequestHeaders in httpListenerRequest.Headers.AllKeys) { if (httpRequestHeaders.Equals(SpecVersionHttpHeader1, StringComparison.InvariantCultureIgnoreCase) || httpRequestHeaders.Equals(SpecVersionHttpHeader2, StringComparison.InvariantCultureIgnoreCase)) { continue; } if (httpRequestHeaders.StartsWith(HttpHeaderPrefix, StringComparison.InvariantCultureIgnoreCase)) { string headerValue = httpListenerRequest.Headers[httpRequestHeaders]; if (headerValue.StartsWith("{") && headerValue.EndsWith("}") || headerValue.StartsWith("[") && headerValue.EndsWith("]")) { attributes[httpRequestHeaders.Substring(3)] = JsonConvert.DeserializeObject(headerValue); } else { attributes[httpRequestHeaders.Substring(3)] = headerValue; attributes[httpRequestHeaders.Substring(3)] = headerValue; } } } cloudEvent.DataContentType = httpListenerRequest.ContentType != null ? new ContentType(httpListenerRequest.ContentType) : null; cloudEvent.Data = httpListenerRequest.InputStream; return(cloudEvent); } }
public static CloudEvent ToCloudEvent(this MqttApplicationMessage message, ICloudEventFormatter eventFormatter, params ICloudEventExtension[] extensions) { return(eventFormatter.DecodeStructuredEvent(message.Payload, extensions)); }