private T DeserializePayload <T>(BasicDeliverEventArgs message) where T : new()
{
Stream stream = new MemoryStream(message.Body, writable: false);
var encoding = message.BasicProperties.ContentEncoding;
if (!string.IsNullOrEmpty(encoding))
{
if ("gzip".Equals(encoding, StringComparison.OrdinalIgnoreCase))
{
stream = new GZipStream(stream, CompressionMode.Decompress, leaveOpen: false);
}
else if ("deflate".Equals(encoding, StringComparison.OrdinalIgnoreCase))
{
stream = new DeflateStream(stream, CompressionMode.Decompress, leaveOpen: false);
}
else
{
throw new InvalidOperationException($"Unknown Content-Encoding '{encoding}'.");
}
}
var serializer = _serializerProvider.GetSerializer(message.BasicProperties.ContentType);
using (stream)
{
return(serializer.Deserialize <T>(stream));
}
}
private EventingHttpClient CreateEventingClient(ServiceId serviceId)
{
var serviceRef = _serviceResolver.Resolve(serviceId);
var configuration = _communicationModelConfiguration.GetCommandsConfiguration(serviceRef.Definition, "communication");
var settings = new HttpCommunicatorSettings();
configuration.Bind(settings);
var serializer = string.IsNullOrEmpty(settings.Serializer)
? _defaultSerializerProvider.DefaultSerializer
: _serializerProvider.GetSerializer(settings.Serializer);
var compressPayload = settings.Compress ?? false;
var urlTemplate = HttpCommunicationMethod.GetUrlTemplate(settings);
var schemeDelimiterIndex = urlTemplate.IndexOf("://");
var firstSegmentIndex = urlTemplate.IndexOf('/', schemeDelimiterIndex > 0 ? schemeDelimiterIndex + 3 : 0);
var address = firstSegmentIndex > 0 ? urlTemplate.Substring(0, firstSegmentIndex) : urlTemplate;
address = address.Replace("{serviceName}", serviceRef.Definition.Name);
var urlBase = address + "/dev/events";
return(new EventingHttpClient(serializer, urlBase));
}
public void CopyValues(IValueContainer source, IValueContainer destination)
{
if (source is ISerializedValueContainer serializedValueContainer)
{
var format = serializedValueContainer.GetFormat();
var serializer = _serializerProvider.GetSerializer(format);
var serializedForm = serializedValueContainer.GetSerializedForm();
if (serializedForm is string stringContent)
{
serializer.Populate(stringContent, destination);
}
else if (serializedForm is byte[] byteContent)
{
serializer.Populate(byteContent, destination);
}
else
{
throw new InvalidOperationException($"Unsupported runtime type '{serializedForm?.GetType()}' for a serialized form of '{format}'.");
}
}
else
{
// TODO: type conversion
source.CopyTo(destination);
}
}
public IEventPublisher CreateEventPublisher(IConfiguration configuration)
{
var serializationFormat = configuration.GetSection("serializer").Value;
var serializer = string.IsNullOrWhiteSpace(serializationFormat)
? _defaultSerializer
: _serializerProvider.GetSerializer(serializationFormat);
return(new InMemoryEventPublisher(serializer, _messageHub));
}
public ICommunicator CreateCommunicator(IConfiguration configuration)
{
var serializationFormat = configuration.GetSection("serializer").Value;
var serializer = string.IsNullOrWhiteSpace(serializationFormat)
? _defaultSerializer
: _serializerProvider.GetSerializer(serializationFormat);
return(new InMemoryCommunicator(serializer, _messageHub, _methodStateStorageProvider));
}
public EventingMiddleware(
ISerializerProvider serializerProvider,
IEventSubscriber eventSubscriber)
{
_serializerProvider = serializerProvider;
_jsonSerializer = _serializerProvider.GetSerializer("json");
_eventSubscriber = eventSubscriber;
_eventingPath = "/dev/events";
}
public async Task <MethodExecutionState> ReadStateAsync(ServiceId serviceId, PersistedMethodId methodId, CancellationToken ct)
{
var tableName = GetTableQualifiedName(serviceId, methodId);
var key = new StorageRecord
{
service = serviceId.Name,
method = methodId.Name,
intent_id = methodId.IntentId
};
var query = new StringBuilder("SELECT * FROM ")
.Append(tableName).Append(" WHERE ");
WriteValues(query, key, delimiter: " AND ");
var result = await ExecuteQueryAsync(serviceId, methodId, query.ToString());
var row = result.FirstOrDefault();
if (row == null)
{
throw new StateNotFoundException(serviceId, methodId);
}
var record = ReadValues(row);
if (record.status.HasValue && record.status.Value != (int)Statuses.Paused)
{
throw new InvalidOperationException("Method is not paused");
}
if (!(record.execution_state?.Length > 0))
{
throw new InvalidOperationException("Empty state data");
}
var serializer = !string.IsNullOrEmpty(record.format)
? _serializerProvider.GetSerializer(record.format)
: _serializer;
return(serializer.Deserialize <MethodExecutionState>(record.execution_state));
}
/// <summary>
/// Initializes a new <see cref="V1ArchiveWorkflowInstanceCommandHandler"/>
/// </summary>
/// <param name="loggerFactory">The service used to create <see cref="ILogger"/>s</param>
/// <param name="mediator">The service used to mediate calls</param>
/// <param name="mapper">The service used to map objects</param>
/// <param name="options">The service used to access the current <see cref="SynapseApplicationOptions"/></param>
/// <param name="serializerProvider">The service used to provide <see cref="ISerializer"/>s</param>
/// <param name="workflows">The <see cref="IRepository"/> used to manage <see cref="V1Workflow"/>s</param>
/// <param name="workflowInstances">The <see cref="IRepository"/> used to manage <see cref="V1WorkflowInstance"/>s</param>
/// <param name="workflowProcesses">The <see cref="IRepository"/> used to manage <see cref="V1WorkflowProcess"/>es</param>
public V1ArchiveWorkflowInstanceCommandHandler(ILoggerFactory loggerFactory, IMediator mediator, IMapper mapper, IOptions <SynapseApplicationOptions> options,
ISerializerProvider serializerProvider, IRepository <V1Workflow> workflows, IRepository <V1WorkflowInstance> workflowInstances, IRepository <V1WorkflowProcess> workflowProcesses)
: base(loggerFactory, mediator, mapper)
{
this.Options = options.Value;
this.Serializer = serializerProvider.GetSerializer(this.Options.Archiving.SerializerType);
this.Workflows = workflows;
this.WorkflowInstances = workflowInstances;
this.WorkflowProcesses = workflowProcesses;
}
public async Task <object> GetAsync(string name, Type valueType)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (valueType == null)
{
throw new ArgumentNullException(nameof(valueType));
}
byte[] data = await _Database.StringGetAsync(name);
if (data == null)
{
return(null);
}
var seralizer = _SerializerProvider.GetSerializer(valueType);
var stream = new MemoryStream(data);
return(seralizer.Deserialize(stream));
}
public ICommunicator CreateCommunicator(IConfiguration configuration)
{
var settings = new HttpCommunicatorSettings();
configuration.Bind(settings);
var serializer = string.IsNullOrEmpty(settings.Serializer)
? _defaultSerializer
: _serializerProvider.GetSerializer(settings.Serializer);
var compressPayload = settings.Compress ?? false;
var urlTemplate = GetUrlTemplate(settings);
return(new HttpCommunicator(serializer, urlTemplate, compressPayload));
}
public CassandraStateStorage(
StateStorageSettings settings,
ICluster cluster,
ISerializer defaultSerializer,
ISerializerProvider serializerProvider)
{
_settings = settings;
_cluster = cluster;
_serializerProvider = serializerProvider;
_serializer =
!string.IsNullOrEmpty(settings.Serializer)
? serializerProvider.GetSerializer(settings.Serializer)
: defaultSerializer;
}
public HttpRequestHandler(
ISerializerProvider serializerProvider,
IUniqueIdGenerator idGenerator,
IRoutineCompletionNotifier routineCompletionNotifier,
IServiceResolver serviceResolver,
IMethodResolver methodResolver,
ILocalMethodRunner localTransitionRunner)
{
_idGenerator = idGenerator;
_routineCompletionNotifier = routineCompletionNotifier;
_serviceResolver = serviceResolver;
_methodResolver = methodResolver;
_localTransitionRunner = localTransitionRunner;
_serializerProvider = serializerProvider;
_jsonSerializer = _serializerProvider.GetSerializer("json");
}
private ISerializer GetSerializer(ContentType contentType, bool isQueryRequest)
{
if (contentType == null ||
string.IsNullOrEmpty(contentType.MediaType) ||
string.Equals(contentType.MediaType, "application/json", StringComparison.OrdinalIgnoreCase) ||
(isQueryRequest && string.Equals(contentType.MediaType, "application/octet-stream", StringComparison.OrdinalIgnoreCase)))
{
return(_jsonSerializer); // default serializer
}
else
{
var format =
contentType.MediaType.StartsWith("application/", StringComparison.OrdinalIgnoreCase)
? contentType.MediaType.Substring(12)
: contentType.MediaType;
return(_serializerProvider.GetSerializer(format));
}
}
public SerializedValueContainer(
string format,
object serializedForm,
ISerializerProvider serializerProvider)
{
_format = format;
_serializedForm = serializedForm;
_lazyValueContainer = new Lazy <IValueContainer>(() =>
{
var serializer = serializerProvider.GetSerializer(_format);
if (_serializedForm is string text)
{
return(serializer.Deserialize <IValueContainer>(text));
}
else
{
return(serializer.Deserialize <IValueContainer>((byte[])_serializedForm));
}
});
}
private ISerializer SelectSerializer(string settingValue)
{
return(string.IsNullOrWhiteSpace(settingValue)
? _defaultSerializer
: _serializerProvider.GetSerializer(settingValue));
}
/// <summary>Gets serializer mapped to the key.</summary>
/// <typeparam name="TKey">Type of the serializer key.</typeparam>
/// <typeparam name="TSerializer">Type of the serializer.</typeparam>
/// <param name="provider">Provider to get serializer from.</param>
/// <param name="key">Key to get the serializer for.</param>
/// <param name="serializer">Found serializer.</param>
/// <returns>True if non-fallback serializer was found; otherwise false.</returns>
public static bool TryFindSerializer <TKey, TSerializer>(this ISerializerProvider <TKey, TSerializer> provider, TKey key, out TSerializer serializer)
{
serializer = provider.GetSerializer(key);
return(serializer != null);
}
