public AzureAtomicReader(IAzureStorageConfig storage, IAtomicStorageStrategy strategy)
{
_strategy = strategy;
var folder = strategy.GetFolderForEntity(typeof(TEntity), typeof(TKey));
_container = storage.CreateBlobClient().GetContainerReference(folder);
}
public AzureQueueWriterFactory(
IAzureStorageConfig accounts,
IEnvelopeStreamer streamer)
{
_config = accounts;
_streamer = streamer;
}
/// <summary>
/// Creates the tape storage factory for windows Azure storage.
/// </summary>
/// <param name="config">Azure storage configuration to create tape storage with.</param>
/// <param name="containerName">Name of the container.</param>
/// <param name="initializeForWriting">if set to <c>true</c>, then storage is initialized for writing as needed.</param>
/// <returns></returns>
public static BlobTapeStorageFactory CreateTape(this IAzureStorageConfig config, string containerName)
{
var factory = new BlobTapeStorageFactory(config, containerName);
factory.InitializeForWriting();
return(factory);
}
public AzureAtomicEntityWriter(IAzureStorageConfig storage, IAtomicStorageStrategy strategy)
{
_strategy = strategy;
var containerName = strategy.GetFolderForEntity(typeof(TEntity));
_container = storage.CreateBlobClient().GetContainerReference(containerName);
}
private static void Main()
{
CloudStorageAccount account = CloudStorageAccount.Parse("UseDevelopmentStorage=true");
IAzureStorageConfig storageConfig = AzureStorage.CreateConfig(account);
var builder = new CqrsClientBuilder();
builder.UseProtoBufSerialization();
builder.Domain(m => m.InAssemblyOf <MessageCreated>());
builder.Azure(config => config.AddAzureSender(storageConfig, Queues.MESSAGES));
builder.Storage(config => config.AtomicIsInAzure(storageConfig, s =>
{
s.WithAssemblyOf <MessageView>();
s.CustomStaticSerializer(new AtomicStorageSerializerWithProtoBuf());
}));
builder.Advanced.ConfigureContainer(b =>
{
b.RegisterType <Program>().As <Program>();
b.RegisterInstance(storageConfig).As <IAzureStorageConfig>();
//This is solely to show the replaying of events. You wouldn't ordinarily need the eventstore in a cqrs client;
b.RegisterInstance(ConfigureEventStore()).SingleInstance().As <IStoreEvents>();
});
CqrsClient cqrsClient = builder.Build();
ILifetimeScope scope = cqrsClient.Scope;
scope.Resolve <Program>().Run();
}
/// <summary> Creates the simplified nuclear storage wrapper around Atomic storage. </summary>
/// <param name="storageConfig">The storage config.</param>
/// <param name="strategy">The atomic storage strategy.</param>
/// <returns></returns>
public static NuclearStorage CreateNuclear(IAzureStorageConfig storageConfig, IAtomicStorageStrategy strategy)
{
var factory = new AzureAtomicStorageFactory(strategy, storageConfig);
factory.Initialize();
return(new NuclearStorage(factory));
}
public void AddAzureSender(IAzureStorageConfig config, string queueName, Action <SendMessageModule> configure)
{
var module = new SendMessageModule((context, endpoint) => new AzureQueueWriterFactory(config, context.Resolve <IEnvelopeStreamer>()), config.AccountName, queueName);
configure(module);
_modules += module.Configure;
}
public AzureQueueWriterFactory(
IAzureStorageConfig accounts,
IEnvelopeStreamer streamer)
{
_config = accounts;
_streamer = streamer;
}
public static void AtomicIsInAzure(this StorageModule self, IAzureStorageConfig storage, Action <DefaultAtomicStorageStrategyBuilder> config)
{
var builder = new DefaultAtomicStorageStrategyBuilder();
config(builder);
AtomicIsInAzure(self, storage, builder.Build());
}
/// <summary> Creates the simplified nuclear storage wrapper around Atomic storage. </summary>
/// <param name="config">The storage config.</param>
/// <param name="strategy">The atomic storage strategy.</param>
/// <returns></returns>
public static IDocumentStore CreateDocumentStore(this IAzureStorageConfig config,
IDocumentStrategy strategy)
{
var client = config.CreateBlobClient();
return(new AzureDocumentStore(strategy, client));
}
public static BlobAppendOnlyStore CreateAppendOnlyStore(this IAzureStorageConfig config, string s)
{
var client = config.CreateBlobClient();
var store = new BlobAppendOnlyStore(client.GetContainerReference(s));
store.InitializeWriter();
return(store);
}
public static AzurePartitionInbox CreateInbox(this IAzureStorageConfig cfg, string name,
Func <uint, TimeSpan> decay = null, TimeSpan visibilityTimeout = default(TimeSpan))
{
var intake = BuildIntake(cfg, name, visibilityTimeout);
var waiter = decay ?? DecayEvil.BuildExponentialDecay(2000);
return(new AzurePartitionInbox(new[] { intake }, waiter));
}
public BlobTapeStorageFactory(IAzureStorageConfig config, string containerName)
{
if (containerName.Any(Char.IsUpper))
throw new ArgumentException("All letters in a container name must be lowercase.");
_cloudBlobClient = config.CreateBlobClient();
_containerName = containerName;
}
public static StatelessAzureQueueWriter Create(IAzureStorageConfig config, string name)
{
var queue = config.CreateQueueClient().GetQueueReference(name);
var container = config.CreateBlobClient().GetContainerReference(name);
var v = new StatelessAzureQueueWriter(container, queue, name);
v.Init();
return v;
}
/// <summary> Creates the simplified nuclear storage wrapper around Atomic storage. </summary>
/// <param name="storageConfig">The storage config.</param>
/// <param name="strategy">The atomic storage strategy.</param>
/// <returns></returns>
public static NuclearStorage CreateNuclear(this IAzureStorageConfig storageConfig,
IDocumentStrategy strategy)
{
var client = storageConfig.CreateBlobClient();
var factory = new AzureDocumentStore(strategy, client);
return(new NuclearStorage(factory));
}
/// <summary> Creates the simplified nuclear storage wrapper around Atomic storage. </summary>
/// <param name="storageConfig">The storage config.</param>
/// <param name="configStrategy">The config strategy.</param>
/// <returns></returns>
public static NuclearStorage CreateNuclear(IAzureStorageConfig storageConfig, Action <DefaultAtomicStorageStrategyBuilder> configStrategy)
{
var strategyBuilder = new DefaultAtomicStorageStrategyBuilder();
configStrategy(strategyBuilder);
var strategy = strategyBuilder.Build();
return(CreateNuclear(storageConfig, strategy));
}
public static StatelessAzureQueueWriter Create(IAzureStorageConfig config, string name)
{
var queue = config.CreateQueueClient().GetQueueReference(name);
var container = config.CreateBlobClient().GetContainerReference(name);
var v = new StatelessAzureQueueWriter(container, queue, name);
v.Init();
return(v);
}
/// <summary>
/// Creates the tape storage factory for windows Azure storage.
/// </summary>
/// <param name="config">Azure storage configuration to create tape storage with.</param>
/// <param name="containerName">Name of the container.</param>
/// <param name="initializeForWriting">if set to <c>true</c>, then storage is initialized for writing as needed.</param>
/// <returns></returns>
public static BlobTapeStorageFactory CreateTape(IAzureStorageConfig config, string containerName, bool initializeForWriting = true)
{
var factory = new BlobTapeStorageFactory(config, containerName);
if (initializeForWriting)
{
factory.InitializeForWriting();
}
return(factory);
}
public BlobTapeStorageFactory(IAzureStorageConfig config, string containerName)
{
if (containerName.Any(Char.IsUpper))
{
throw new ArgumentException("All letters in a container name must be lowercase.");
}
_cloudBlobClient = config.CreateBlobClient();
_containerName = containerName;
}
public AzurePartitionModule(IAzureStorageConfig config, string[] queueNames)
{
DispatchAsEvents();
QueueVisibility(30000);
_config = config;
_queueNames = new HashSet<string>(queueNames);
Quarantine(c => new MemoryQuarantine());
DecayPolicy(TimeSpan.FromSeconds(2));
}
public AzurePartitionModule(IAzureStorageConfig config, string[] queueNames)
{
DispatchAsEvents();
QueueVisibility(30000);
_config = config;
_queueNames = new HashSet <string>(queueNames);
Quarantine(c => new MemoryQuarantine());
DecayPolicy(TimeSpan.FromSeconds(2));
}
public AzurePartitionFactory(
IEnvelopeStreamer streamer,
ISystemObserver observer,
IAzureStorageConfig config,
TimeSpan queueVisibilityTimeout,
Func <uint, TimeSpan> decayPolicy)
{
_streamer = streamer;
_queueVisibilityTimeout = queueVisibilityTimeout;
_decayPolicy = decayPolicy;
_config = config;
_observer = observer;
}
public AzurePartitionFactory(
IEnvelopeStreamer streamer,
ISystemObserver observer,
IAzureStorageConfig config,
TimeSpan queueVisibilityTimeout,
Func<uint, TimeSpan> decayPolicy)
{
_streamer = streamer;
_queueVisibilityTimeout = queueVisibilityTimeout;
_decayPolicy = decayPolicy;
_config = config;
_observer = observer;
}
public AzureStorageManager(ILoggingService log, ICMRepository repository, IAzureStorageConfig azureStorageConfig)
: base(log, repository)
{
AzureStorageConfig = azureStorageConfig;
if (AzureStorageConfig == null || string.IsNullOrEmpty(AzureStorageConfig.AccountKey) || string.IsNullOrEmpty(AzureStorageConfig.AccountName) ||
string.IsNullOrEmpty(AzureStorageConfig.ImageContainer))
{
throw new ArgumentNullException($"Null or empty AzureStorageConfig detected in Domain User class constructor. Ensure you have values set for AccountKey, AccountName, and ImageContainer.");
}
_storageCredentials = new StorageCredentials(AzureStorageConfig.AccountName, AzureStorageConfig.AccountKey);
_storageAccount = new CloudStorageAccount(_storageCredentials, true);
_blobClient = _storageAccount.CreateCloudBlobClient();
_imageContainer = new Lazy <CloudBlobContainer>(delegate { return(_blobClient.GetContainerReference(AzureStorageConfig.ImageContainer)); });
_thumbnailContainer = new Lazy <CloudBlobContainer>(delegate { return(_blobClient.GetContainerReference(AzureStorageConfig.ThumbnailContainer)); });
}
public static StatelessAzureQueueReader BuildIntake(IAzureStorageConfig cfg, string name,
TimeSpan visibilityTimeout = default(TimeSpan))
{
var timeout = visibilityTimeout == default(TimeSpan) ? TimeSpan.FromMinutes(5) : visibilityTimeout;
var queue = cfg.CreateQueueClient().GetQueueReference(name);
var container = cfg.CreateBlobClient().GetBlobDirectoryReference("queues-big").GetSubdirectory(name);
var poisonQueue = new Lazy<CloudQueue>(() =>
{
var queueReference = cfg.CreateQueueClient().GetQueueReference(name + "-poison");
queueReference.CreateIfNotExist();
return queueReference;
}, LazyThreadSafetyMode.ExecutionAndPublication);
var reader = new StatelessAzureQueueReader(name, queue, container, poisonQueue, timeout);
reader.InitIfNeeded();
return reader;
}
static StatelessAzureQueueReader BuildIntake(IAzureStorageConfig cfg, string name,
TimeSpan visibilityTimeout = default(TimeSpan))
{
var timeout = visibilityTimeout == default(TimeSpan) ? TimeSpan.FromMinutes(5) : visibilityTimeout;
var queue = cfg.CreateQueueClient().GetQueueReference(name);
var container = cfg.CreateBlobClient().GetBlobDirectoryReference("queues-big").GetSubdirectory(name);
var poisonQueue = new Lazy <CloudQueue>(() =>
{
var queueReference = cfg.CreateQueueClient().GetQueueReference(name + "-poison");
queueReference.CreateIfNotExist();
return(queueReference);
}, LazyThreadSafetyMode.ExecutionAndPublication);
var reader = new StatelessAzureQueueReader(name, queue, container, poisonQueue, timeout);
reader.InitIfNeeded();
return(reader);
}
public void AddAzureProcess(IAzureStorageConfig config, string[] queues, Action<AzurePartitionModule> configure)
{
foreach (var queue in queues)
{
if (queue.Contains(":"))
{
var message = string.Format("Queue '{0}' should not contain queue prefix, since it's azure already", queue);
throw new InvalidOperationException(message);
}
if (!QueueName.IsMatch(queue))
{
var format = string.Format("Queue name should match regex '{0}'", QueueName);
throw new InvalidOperationException(format);
}
}
var module = new AzurePartitionModule(config, queues);
configure(module);
_funqlets += module.Configure;
}
public void AddAzureProcess(IAzureStorageConfig config, string[] queues, Action <AzurePartitionModule> configure)
{
foreach (var queue in queues)
{
if (queue.Contains(":"))
{
var message = string.Format("Queue '{0}' should not contain queue prefix, since it's azure already", queue);
throw new InvalidOperationException(message);
}
if (!QueueName.IsMatch(queue))
{
var format = string.Format("Queue name should match regex '{0}'", QueueName);
throw new InvalidOperationException(format);
}
}
var module = new AzurePartitionModule(config, queues);
configure(module);
_funqlets += module.Configure;
}
public static StatelessAzureQueueWriter CreateQueueWriter(this IAzureStorageConfig cfg, string queueName)
{
return((StatelessAzureQueueWriter)CreateQueueWriterFactory(cfg).GetWriteQueue(queueName));
}
public static void AtomicIsInAzure(this StorageModule self, IAzureStorageConfig storage, IAtomicStorageStrategy strategy)
{
self.AtomicIs(new AzureAtomicStorageFactory(strategy, storage));
}
public static AzureQueueWriterFactory CreateQueueWriterFactory(this IAzureStorageConfig cfg)
{
return(new AzureQueueWriterFactory(cfg));
}
public static SimpleMessageSender CreateSimpleSender(this IAzureStorageConfig account,
IEnvelopeStreamer streamer, string queueName)
{
return(new SimpleMessageSender(streamer, CreateQueueWriter(account, queueName)));
}
/// <summary>
/// Creates the tape storage factory for windows Azure storage.
/// </summary>
/// <param name="config">Azure storage configuration to create tape storage with.</param>
/// <param name="containerName">Name of the container.</param>
/// <param name="initializeForWriting">if set to <c>true</c>, then storage is initialized for writing as needed.</param>
/// <returns></returns>
public static BlobTapeStorageFactory CreateTape(IAzureStorageConfig config, string containerName, bool initializeForWriting = true)
{
var factory = new BlobTapeStorageFactory(config, containerName);
if (initializeForWriting)
{
factory.InitializeForWriting();
}
return factory;
}
public static void AtomicIsInAzure(this StorageModule self, IAzureStorageConfig storage, Action<DefaultAtomicStorageStrategyBuilder> config)
{
var builder = new DefaultAtomicStorageStrategyBuilder();
config(builder);
AtomicIsInAzure(self, storage, builder.Build());
}
/// <summary> Creates the simplified nuclear storage wrapper around Atomic storage. </summary>
/// <param name="storageConfig">The storage config.</param>
/// <param name="configStrategy">The config strategy.</param>
/// <returns></returns>
public static NuclearStorage CreateNuclear(IAzureStorageConfig storageConfig, Action<DefaultAtomicStorageStrategyBuilder> configStrategy)
{
var strategyBuilder = new DefaultAtomicStorageStrategyBuilder();
configStrategy(strategyBuilder);
var strategy = strategyBuilder.Build();
return CreateNuclear(storageConfig, strategy);
}
public AzureQueueWriterFactory(IAzureStorageConfig accounts)
{
_config = accounts;
}
/// <summary>
/// Creates the streaming storage out of the provided storage config.
/// </summary>
/// <param name="config">The config.</param>
/// <returns></returns>
public static IStreamingRoot CreateStreaming(IAzureStorageConfig config)
{
return new BlobStreamingRoot(config.CreateBlobClient());
}
public void AddAzureSender(IAzureStorageConfig config, string queueName, Action<SendMessageModule> configure)
{
var module = new SendMessageModule((context, endpoint) => new AzureQueueWriterFactory(config, context.Resolve<IEnvelopeStreamer>()), config.AccountName, queueName);
configure(module);
_funqlets += module.Configure;
}
public void AddAzureSender(IAzureStorageConfig config, string queueName)
{
AddAzureSender(config, queueName, m => { });
}
public void AddAzureRouter(IAzureStorageConfig config, string queueName, Func<ImmutableEnvelope, string> configure)
{
AddAzureProcess(config, new[] {queueName}, m => m.DispatchToRoute(configure));
}
public void AddAzureProcess(IAzureStorageConfig config, string firstQueue, Action<AzurePartitionModule> configure)
{
AddAzureProcess(config, new[] { firstQueue}, configure);
}
public void AddAzureProcess(IAzureStorageConfig config, string firstQueue, params string[] otherQueues)
{
var queues = Enumerable.Repeat(firstQueue, 1).Concat(otherQueues).ToArray();
AddAzureProcess(config, queues, m => { });
}
public static void AtomicIsInAzure(this StorageModule self, IAzureStorageConfig storage)
{
AtomicIsInAzure(self, storage, builder => { });
}
/// <summary> Creates the simplified nuclear storage wrapper around Atomic storage. </summary>
/// <param name="storageConfig">The storage config.</param>
/// <param name="strategy">The atomic storage strategy.</param>
/// <returns></returns>
public static NuclearStorage CreateNuclear(IAzureStorageConfig storageConfig, IAtomicStorageStrategy strategy)
{
var factory = new AzureAtomicStorageFactory(strategy, storageConfig);
factory.Initialize();
return new NuclearStorage(factory);
}
/// <summary>
/// Creates the streaming storage out of the provided storage config.
/// </summary>
/// <param name="config">The config.</param>
/// <returns></returns>
public static IStreamingRoot CreateStreaming(IAzureStorageConfig config)
{
return(new BlobStreamingRoot(config.CreateBlobClient()));
}
public static void StreamingIsInAzure(this StorageModule self, IAzureStorageConfig storage)
{
self.StreamingIs(new BlobStreamingRoot(storage.CreateBlobClient()));
}
/// <summary>
/// Creates the simplified nuclear storage wrapper around Atomic storage, using the default storage
/// strategy.
/// </summary>
/// <param name="storageConfig">The storage config.</param>
/// <returns>new instance of the nuclear storage</returns>
public static NuclearStorage CreateNuclear(IAzureStorageConfig storageConfig)
{
return(CreateNuclear(storageConfig, b => { }));
}
public void AddAzureRouter(IAzureStorageConfig config, string queueName, Func <ImmutableEnvelope, string> configure)
{
AddAzureProcess(config, new[] { queueName }, m => m.DispatchToRoute(configure));
}
public void AddAzureSender(IAzureStorageConfig config, string queueName)
{
AddAzureSender(config, queueName, m => { });
}
public static IStreamContainer CreateStreaming(this IAzureStorageConfig config, string container)
{
return(config.CreateStreaming().GetContainer(container).Create());
}
public AzureBlobTable(IAzureStorageConfig config)
{
this.config = config;
}
/// <summary>
/// Creates the simplified nuclear storage wrapper around Atomic storage, using the default storage
/// strategy.
/// </summary>
/// <param name="storageConfig">The storage config.</param>
/// <returns>new instance of the nuclear storage</returns>
public static NuclearStorage CreateNuclear(IAzureStorageConfig storageConfig)
{
return CreateNuclear(storageConfig, b => { });
}
