public CosmosDBGrainStorage(string name, CosmosDBStorageOptions options, SerializationManager serializationManager,
Providers.IProviderRuntime providerRuntime, IPartitionKeyProvider partitionKeyProvider,
IOptions <ClusterOptions> clusterOptions, IGrainFactory grainFactory, ITypeResolver typeResolver, ILoggerFactory loggerFactory)
{
this._name = name;
this._partitionKeyProvider = partitionKeyProvider;
this._loggerFactory = loggerFactory;
var loggerName = $"{typeof(CosmosDBGrainStorage).FullName}.{name}";
this._logger = loggerFactory.CreateLogger(loggerName);
this._options = options;
this._serializationManager = serializationManager;
this._grainFactory = grainFactory;
this._typeResolver = typeResolver;
this._serviceId = clusterOptions.Value.ServiceId;
this._grainReferenceConverter = providerRuntime.ServiceProvider.GetRequiredService <IGrainReferenceConverter>();
this._sprocFiles = new Dictionary <string, string>
{
{ LOOKUP_INDEX_SPROC, $"{LOOKUP_INDEX_SPROC}.js" }
};
if (this._options.JsonSerializerSettings == null)
{
this._options.JsonSerializerSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(this._typeResolver, this._grainFactory),
this._options.UseFullAssemblyNames,
this._options.IndentJson,
this._options.TypeNameHandling);
this._options.JsonSerializerSettings.DefaultValueHandling = DefaultValueHandling.Include;
this._options.JsonSerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None;
}
}
/// <summary>
/// Registers a command auditor that writes to an event hub
/// </summary>
/// <param name="resolver">Dependency resolver</param>
/// <param name="eventHubClient">The event hub client</param>
/// <param name="partitionKeyProvider">An optional partition key provider, if unspecified events will be sent unpartitioned</param>
/// <param name="options">Options for the event hub auditor configuration</param>
/// <returns>Dependency resolver</returns>
public static ICommandingDependencyResolver UseEventHubCommandAuditing(this ICommandingDependencyResolver resolver,
Microsoft.Azure.EventHubs.EventHubClient eventHubClient,
IPartitionKeyProvider partitionKeyProvider = null,
AzureEventHubAuditorOptions options = null)
{
options = options ?? new AzureEventHubAuditorOptions();
IEventHubClient client = new EventHubClient(eventHubClient);
if (partitionKeyProvider == null)
{
partitionKeyProvider = new NullPartitionKeyProvider();
}
resolver.RegisterInstance(client);
resolver.RegisterInstance(partitionKeyProvider);
resolver.TypeMapping <IAuditItemMapper, AuditItemMapper>();
resolver.TypeMapping <IEventHubSerializer, EventHubSerializer>();
if (options.UsePreDispatchAuditor)
{
resolver.UsePreDispatchCommandingAuditor <AzureEventHubCommandAuditor>(options.AuditPreDispatchRootOnly);
}
if (options.UsePostDispatchAuditor)
{
resolver.UsePostDispatchCommandingAuditor <AzureEventHubCommandAuditor>(options.AuditPostDispatchRootOnly);
}
if (options.UseExecutionAuditor)
{
resolver.UseExecutionCommandingAuditor <AzureEventHubCommandAuditor>(options.AuditExecuteDispatchRootOnly);
}
return(resolver);
}
/// <summary>
/// Registers a command auditor that writes to an event hub
/// </summary>
/// <param name="resolver">Dependency resolver</param>
/// <param name="connectionString">Connection string to an event hub. This needs to also supply the EntityPath e.g.:
/// Endpoint=sb://myeventhub.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=mysharedaccesskey;EntityPath=myeventhub
/// </param>
/// <param name="partitionKeyProvider">An optional partition key provider, if unspecified events will be sent unpartitioned</param>
/// <param name="options">Options for the event hub auditor configuration</param>
/// <returns>Dependency resolver</returns>
public static ICommandingDependencyResolver UseEventHubCommandAuditing(this ICommandingDependencyResolver resolver,
string connectionString,
IPartitionKeyProvider partitionKeyProvider = null,
AzureEventHubAuditorOptions options = null)
{
Microsoft.Azure.EventHubs.EventHubClient client = Microsoft.Azure.EventHubs.EventHubClient.CreateFromConnectionString(connectionString);
return(UseEventHubCommandAuditing(resolver, client, partitionKeyProvider, options));
}
/// <summary>
/// Initializes an instance of the PartitionProxy class with specified IPartitionKeyProvider and IPartitionConnectionProvider implantations.
/// </summary>
/// <param name="partitionKeyProvider">Current partition key provider.</param>
/// <param name="partitionProvider">Partition provider.</param>
public PartitionProxy(IPartitionKeyProvider partitionKeyProvider, IPartitionConnectionProvider partitionProvider)
{
if(partitionKeyProvider == null)
throw new ArgumentNullException("partitionKeyProvider");
if(partitionProvider == null)
throw new ArgumentNullException("partitionProvider");
PartitionKeyProvider = partitionKeyProvider;
PartitionConnectionProvider = partitionProvider;
}
/// <summary>
/// Registers a command auditor that writes to an event hub
/// </summary>
/// <param name="resolver">Dependency resolver</param>
/// <param name="connectionString">Connection string to an event hub e.g.:
/// Endpoint=sb://myeventhub.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=mysharedaccesskey
/// </param>
/// <param name="entityPath">The path to the event hub (usually just the event hub name</param>
/// <param name="partitionKeyProvider">An optional partition key provider, if unspecified events will be sent unpartitioned</param>
/// <param name="options">Options for the event hub auditor configuration</param>
/// <returns>Dependency resolver</returns>
public static ICommandingDependencyResolver UseEventHubCommandAuditing(this ICommandingDependencyResolver resolver,
string connectionString,
string entityPath,
IPartitionKeyProvider partitionKeyProvider = null,
AzureEventHubAuditorOptions options = null)
{
EventHubsConnectionStringBuilder builder = new EventHubsConnectionStringBuilder(connectionString);
builder.EntityPath = entityPath;
Microsoft.Azure.EventHubs.EventHubClient client = Microsoft.Azure.EventHubs.EventHubClient.CreateFromConnectionString(builder.ToString());
return(UseEventHubCommandAuditing(resolver, client, partitionKeyProvider, options));
}
public AzureEventHubCommandAuditor(IEventHubClient client, IEventHubSerializer serializer, IPartitionKeyProvider partitionKeyProvider)
{
_client = client;
_serializer = serializer;
_partitionKeyProvider = partitionKeyProvider;
}