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 => { }); }