public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
lock (_messageTypes)
{
if (_messageTypes.TryGetValue(typeof(T), out var existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
var typeUrn = new MessageUrn(typeof(T)).ToString();
if (_supportedTypes.Any(typeUrn.Equals))
{
if (_message is T variable)
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, variable);
return(true);
}
message = null;
return(false);
}
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
public bool TryGetMessage <T>(out ConsumeContext <T> message)
where T : class
{
lock (_messageTypes)
{
object existing;
if (_messageTypes.TryGetValue(typeof(T), out existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
string typeUrn = new MessageUrn(typeof(T)).ToString();
if (_supportedTypes.Any(typeUrn.Equals))
{
if (_message is T)
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, (T)_message);
return(true);
}
message = null;
return(false);
}
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
public async Task <JobHandle> StartJob <T>(ConsumeContext <StartJob> context, T job, IPipe <ConsumeContext <T> > jobPipe, TimeSpan timeout)
where T : class
{
var startJob = context.Message;
if (_jobs.ContainsKey(startJob.JobId))
{
throw new JobAlreadyExistsException(startJob.JobId);
}
var jobContext = new ConsumeJobContext <T>(context, InstanceAddress, startJob.JobId, startJob.AttemptId, startJob.RetryAttempt, job, timeout);
LogContext.Debug?.Log("Executing job: {JobType} {JobId} ({RetryAttempt})", TypeMetadataCache <T> .ShortName, startJob.JobId,
startJob.RetryAttempt);
ConsumeContext <T> jobConsumeContext = new MessageConsumeContext <T>(context, job);
jobConsumeContext.AddOrUpdatePayload <JobContext <T> >(() => jobContext, existing => jobContext);
var jobTask = jobPipe.Send(jobConsumeContext);
var jobHandle = new ConsumerJobHandle <T>(jobContext, jobTask);
Add(jobHandle);
return(jobHandle);
}
public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
lock (_messageTypes)
{
object existing;
if (_messageTypes.TryGetValue(typeof(T), out existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
var typeUrn = new MessageUrn(typeof(T)).ToString();
if (_supportedTypes.Any(typeUrn.Equals))
{
using (var stream = ReceiveContext.GetBody())
{
stream.Seek(_offset, SeekOrigin.Current);
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, ProtoBuf.Serializer.DeserializeWithLengthPrefix <T>(stream, PrefixStyle.Fixed32));
return(true);
}
}
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
lock (_messageTypes)
{
if (_messageTypes.TryGetValue(typeof(T), out var existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
if (typeof(T) == typeof(JToken))
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, _messageToken as T);
return(true);
}
string typeUrn = MessageUrn.ForTypeString <T>();
try
{
object obj;
Type deserializeType = typeof(T);
if (deserializeType.GetTypeInfo().IsInterface&& TypeMetadataCache <T> .IsValidMessageType)
{
deserializeType = TypeMetadataCache <T> .ImplementationType;
}
var messageToken = _messageToken;
var jsonArrayType = deserializeType.GetInterfaces().FirstOrDefault(x =>
x.IsGenericType &&
x.GetGenericTypeDefinition() == typeof(IRawJsonArrayMessage <>));
var isJsonArrayType = jsonArrayType != null && jsonArrayType.GenericTypeArguments.Length > 0;
if (isJsonArrayType)
{
var parentMessageObj = new JObject();
parentMessageObj.Add("items", _messageToken);
messageToken = parentMessageObj;
}
using (JsonReader jsonReader = messageToken.CreateReader())
{
obj = _deserializer.Deserialize(jsonReader, deserializeType);
}
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, (T)obj);
return(true);
}
catch (Exception e)
{
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
}
public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
using (JsonReader jsonReader = messageToken.CreateReader())
{
var obj = deserializer.Deserialize(jsonReader, typeof(T));
message = new MessageConsumeContext <T>(this, (T)obj);
return(true);
}
}
public override bool TryGetMessage <T>(out ConsumeContext <T> consumeContext)
{
if (Message is T message)
{
consumeContext = new MessageConsumeContext <T>(this, message);
return(true);
}
consumeContext = default;
return(false);
}
public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
lock (_messageTypes)
{
if (_messageTypes.TryGetValue(typeof(T), out var existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
if (typeof(T) == typeof(JToken))
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, _messageToken as T);
return(true);
}
var typeUrn = MessageUrn.ForTypeString <T>();
if (_options.HasFlag(RawJsonSerializerOptions.AnyMessageType) ||
_supportedTypes.Length == 0 ||
_supportedTypes.Any(x => typeUrn.Equals(x, StringComparison.OrdinalIgnoreCase)))
{
try
{
object obj;
var deserializeType = typeof(T);
if (deserializeType.GetTypeInfo().IsInterface&& TypeMetadataCache <T> .IsValidMessageType)
{
deserializeType = TypeMetadataCache <T> .ImplementationType;
}
using (var jsonReader = _messageToken.CreateReader())
{
obj = _deserializer.Deserialize(jsonReader, deserializeType);
}
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, (T)obj);
return(true);
}
catch (Exception exception)
{
LogContext.Warning?.Log(exception, "Failed to deserialize message type: {MessageType}", TypeMetadataCache <T> .ShortName);
}
}
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
Task IFilter <ConsumeContext <T> > .Send(ConsumeContext <T> context, IPipe <ConsumeContext <T> > next)
{
var transformContext = new ConsumeTransformContext <T>(context);
TransformResult <T> result = _transform.ApplyTo(transformContext);
if (result.IsNewValue)
{
var transformedContext = new MessageConsumeContext <T>(context, result.Value);
return(next.Send(transformedContext));
}
return(next.Send(context));
}
public bool TryGetMessage <T>(out ConsumeContext <T> message)
where T : class
{
lock (_messageTypes)
{
object existing;
if (_messageTypes.TryGetValue(typeof(T), out existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
if (typeof(T) == typeof(JToken))
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, _messageToken as T);
return(true);
}
string typeUrn = new MessageUrn(typeof(T)).ToString();
if (_supportedTypes.Any(typeUrn.Equals))
{
object obj;
Type deserializeType = typeof(T);
if (deserializeType.IsInterface && TypeMetadataCache.IsValidMessageType(deserializeType))
{
deserializeType = TypeMetadataCache.GetImplementationType(deserializeType);
}
using (JsonReader jsonReader = _messageToken.CreateReader())
{
obj = _deserializer.Deserialize(jsonReader, deserializeType);
}
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, (T)obj);
return(true);
}
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
lock (_messageTypes)
{
if (_messageTypes.TryGetValue(typeof(T), out var existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
if (typeof(T) == typeof(JToken))
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, _messageToken as T);
return(true);
}
try
{
object obj;
var deserializeType = typeof(T);
if (deserializeType.GetTypeInfo().IsInterface&& TypeMetadataCache <T> .IsValidMessageType)
{
deserializeType = TypeMetadataCache <T> .ImplementationType;
}
using (var jsonReader = _messageToken.CreateReader())
{
obj = _deserializer.Deserialize(jsonReader, deserializeType);
}
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, (T)obj);
return(true);
}
catch (Exception)
{
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
}
public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
lock (_messageTypes)
{
if (_messageTypes.TryGetValue(typeof(T), out var existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
if (typeof(T) == typeof(JToken))
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, _messageToken as T);
return(true);
}
string typeUrn = MessageUrn.ForTypeString <T>();
if (SupportedMessageTypes.Any(x => typeUrn.Equals(x, StringComparison.OrdinalIgnoreCase)))
{
object obj;
Type deserializeType = typeof(T);
if (deserializeType.GetTypeInfo().IsInterface&& TypeMetadataCache <T> .IsValidMessageType)
{
deserializeType = TypeMetadataCache <T> .ImplementationType;
}
using (JsonReader jsonReader = _messageToken.CreateReader())
{
obj = _deserializer.Deserialize(jsonReader, deserializeType);
}
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, (T)obj);
return(true);
}
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
lock (_locker)
{
if (_messageTypes.TryGetValue(typeof(T), out var existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
var messageToken = GetMessageToken(_envelope.Message);
if (typeof(T) == typeof(JsonElement))
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, messageToken as T);
return(true);
}
var typeUrn = MessageUrn.ForTypeString <T>();
if (_supportedTypes.Any(x => typeUrn.Equals(x, StringComparison.OrdinalIgnoreCase)))
{
var deserializeType = typeof(T);
if (deserializeType.GetTypeInfo().IsInterface&& TypeMetadataCache <T> .IsValidMessageType)
{
deserializeType = TypeMetadataCache <T> .ImplementationType;
}
var obj = messageToken.ToObject <T>(SystemTextJsonMessageSerializer.Options);
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, obj);
return(true);
}
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
async Task Deliver(ConsumeContext context, IReadOnlyList <ConsumeContext <TMessage> > messages, BatchCompletionMode batchCompletionMode)
{
_timer.Dispose();
Batch <TMessage> batch = new Batch(_firstMessage, _lastMessage, batchCompletionMode, messages);
try
{
var proxy = new MessageConsumeContext <Batch <TMessage> >(context, batch);
await _consumerFactory.Send(proxy, _consumerPipe).ConfigureAwait(false);
_completed.TrySetResult(DateTime.UtcNow);
}
catch (OperationCanceledException exception) when(exception.CancellationToken == context.CancellationToken)
{
_completed.TrySetCanceled();
}
catch (Exception exception)
{
_completed.TrySetException(exception);
}
}
protected override async ValueTask Subscribe(CancellationToken cancellationToken)
{
if (Options.CreateSubscription)
{
await CreateSubscription(
_subscriptionName,
_topicName,
Options.ConfigureSubscription,
cancellationToken
)
.NoContext();
}
_client = await CreateAsync(
_subscriptionName,
Options.ClientCreationSettings,
Options.Settings
)
.NoContext();
_subscriberTask = _client.StartAsync(Handle);
async Task <Reply> Handle(PubsubMessage msg, CancellationToken ct)
{
var eventType = msg.Attributes[Options.Attributes.EventType];
var contentType = msg.Attributes[Options.Attributes.ContentType];
var evt = DeserializeData(
contentType,
eventType,
msg.Data.ToByteArray(),
_topicName.TopicId
);
var ctx = new MessageConsumeContext(
msg.MessageId,
eventType,
contentType,
_topicName.TopicId,
0,
0,
0,
msg.PublishTime.ToDateTime(),
evt,
AsMeta(msg.Attributes),
SubscriptionId,
ct
);
try {
await Handler(ctx).NoContext();
return(Reply.Ack);
}
catch (Exception ex) {
return(await _failureHandler(_client, msg, ex).NoContext());
}
}
Metadata AsMeta(MapField <string, string> attributes)
=> new(attributes.ToDictionary(x => x.Key, x => (object)x.Value) !);
}
public override bool TryGetMessage <T>(out ConsumeContext <T> message)
{
lock (_messageTypes)
{
if (_messageTypes.TryGetValue(typeof(T), out var existing))
{
message = existing as ConsumeContext <T>;
return(message != null);
}
if (typeof(T) == typeof(JToken))
{
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, _messageToken as T);
return(true);
}
var typeUrn = MessageUrn.ForTypeString <T>();
#region Masstransit Deserialize old code
// Masstransit old code
// if (_supportedTypes.Any(x => typeUrn.Equals(x, StringComparison.OrdinalIgnoreCase)))
// {
// object obj;
// var deserializeType = typeof(T);
// if (deserializeType.GetTypeInfo().IsInterface && TypeMetadataCache<T>.IsValidMessageType)
// deserializeType = TypeMetadataCache<T>.ImplementationType;
//
// using (var jsonReader = _messageToken.CreateReader())
// {
// obj = _deserializer.Deserialize(jsonReader, deserializeType);
// }
//
// _messageTypes[typeof(T)] = message = new MessageConsumeContext<T>(this, (T)obj);
// return true;
// }
#endregion
#region Masstransit Object Deserialize New Code
var supportedTypesNew = _supportedTypes.Select(_ => _.Split(':').Last()).ToList();
if (supportedTypesNew.Any(x => typeUrn.Split(':').Last().Contains(x, StringComparison.OrdinalIgnoreCase)))
{
object obj;
var deserializeType = typeof(T);
if (deserializeType.GetTypeInfo().IsInterface&& TypeMetadataCache <T> .IsValidMessageType)
{
deserializeType = TypeMetadataCache <T> .ImplementationType;
}
using (var jsonReader = _messageToken.CreateReader())
{
obj = _deserializer.Deserialize(jsonReader, deserializeType);
}
_messageTypes[typeof(T)] = message = new MessageConsumeContext <T>(this, (T)obj);
return(true);
}
#endregion
_messageTypes[typeof(T)] = message = null;
return(false);
}
}
