예제 #1
0
        private async Task Subscribe(string productStream, string queryGroup)
        {
            try
            {
                await _connection.CreatePersistentSubscriptionAsync(productStream, queryGroup, PersistentSubscriptionSettings.Create().ResolveLinkTos().StartFromBeginning(), new UserCredentials(_eventStoreSettings.UserName, _eventStoreSettings.Password));
            }
            catch (Exception e)
            {
            }

            async Task EventAppeared(EventStorePersistentSubscriptionBase s, ResolvedEvent e)
            {
                using (var scope = _serviceProvider.CreateScope())
                {
                    var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();

                    var @event = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(e.Event.Data), new JsonSerializerSettings {
                        TypeNameHandling = TypeNameHandling.All
                    }) as INotification;
                    await mediator.Publish(@event);
                }
            };

            void SubscriptionDropped(EventStorePersistentSubscriptionBase e, SubscriptionDropReason s, Exception exc)
            {
                _subscriptions.TryTake(out e);
                _subscriptions.Add(_connection.ConnectToPersistentSubscriptionAsync(productStream, queryGroup, EventAppeared, SubscriptionDropped).Result);
            };

            _subscriptions.Add(await _connection.ConnectToPersistentSubscriptionAsync(productStream, queryGroup, EventAppeared, SubscriptionDropped));
        }
예제 #2
0
        private async Task CreateSubscription(IEventStoreConnection connection, string stream, string group)
        {
            var persistentSubscriptionSettings = PersistentSubscriptionSettings.Create().DoNotResolveLinkTos().StartFromCurrent();
            var userCredentials = new UserCredentials("admin", "changeit");

            await connection.CreatePersistentSubscriptionAsync(stream, group, persistentSubscriptionSettings, userCredentials);
        }
        public async Task Subscribe(string streamName, Func <Guid, object, Task> messageSender)
        {
            await DefaultRetryAsync(() => SubscribeImpl());

            async Task SubscribeImpl()
            {
                await CreateSubscription();

                await _conn.ConnectToPersistentSubscriptionAsync(
                    streamName, _options.GroupSubscription,
                    (_, x) => messageSender(
                        GetAggregateId(x.Event.EventStreamId),
                        _eventDeserializer.Deserialize(x.Event)));

                Guid GetAggregateId(string streamId)
                {
                    var streamIdParts = streamId.Split('-');

                    return(streamIdParts.Length == 2
                            ? Guid.TryParse(streamIdParts[1], out Guid aggregateId)
                                ? aggregateId
                                : Guid.Empty
                            : Guid.Empty);
                }

                async Task CreateSubscription()
                {
                    var settings = PersistentSubscriptionSettings.Create()
                                   .ResolveLinkTos()
                                   .StartFromCurrent();

                    await _conn.CreatePersistentSubscriptionAsync(streamName, _options.GroupSubscription, settings, _options.Credentials);
                }
            }
        }
예제 #4
0
        public async Task Crate()
        {
            #region CreatePersistentSubscription

            var userCredentials = new UserCredentials("admin", "changeit");

            var settings = PersistentSubscriptionSettings
                           .Create()
                           .DoNotResolveLinkTos()
                           .StartFromCurrent();

            await conn.CreatePersistentSubscriptionAsync(
                "myStream",
                "grour1",
                settings,
                userCredentials
                );

            var subscription = await conn.ConnectToPersistentSubscriptionAsync(
                "myStream",
                "group1",
                (_, evt) => Console.WriteLine($"Received: {Encoding.UTF8.GetString(evt.Event.Data)}")
                );

            #endregion CreatePersistentSubscription
        }
예제 #5
0
        public static async Task <int> Main(string[] args)
        {
            // enumerate all streams
            IEventStoreConnection conn = EventStoreConnection.Create(connection);

            await Task.Run(() => conn.ConnectAsync());

            try
            {
                await conn.CreatePersistentSubscriptionAsync(stream, group,
                                                             PersistentSubscriptionSettings.Create(), null);
            }
            catch
            {
            }

            dynamic ps = conn.ConnectToPersistentSubscription(stream, group,
                                                              (s, e) => Process(s, e),
                                                              (s, r, ex) => HandleException(s, r, ex),
                                                              null,
                                                              2,
                                                              false);

            Console.ReadKey();
        }
        private void CreateStream()
        {
            var settings = PersistentSubscriptionSettings.Create();

            _connectionES.CreatePersistentSubscriptionAsync(streamName, "PictureScan", settings, _connectionES.Settings.DefaultUserCredentials);
            SetPermisions();
        }
예제 #7
0
        public override async Task <CreatePersistentSubscriptionResponse> CreatePersistentSubscription(
            CreatePersistentSubscriptionRequest request, ServerCallContext context)
        {
            await _eventStoreConnection.CreatePersistentSubscriptionAsync(request.Stream, request.GroupName,
                                                                          request.Settings.ToPersistentSubscriptionSettings(), request.UserCredentials.ToUserCredentials());

            return(new CreatePersistentSubscriptionResponse());
        }
예제 #8
0
        private static async Task CreateSubscription(IEventStoreConnection conn, EventStoreOptions options)
        {
            var settings = PersistentSubscriptionSettings.Create()
                           .ResolveLinkTos()
                           .StartFromCurrent();

            await conn.CreatePersistentSubscriptionAsync(options.Subscription.stream, options.Subscription.group, settings, options.Credentials);
        }
 private async Task CreateSubscription(string subscription, string eventTypeStream, PersistentSubscriptionSettingsBuilder settings)
 {
     try
     {
         await _conn.CreatePersistentSubscriptionAsync(eventTypeStream, subscription, settings, _credentials);
     }
     catch
     {
         // Already exists
     }
 }
예제 #10
0
        private static async Task StartMultipleSubscriptions()
        {
            try
            {
                await _subscriptionConnection.CreatePersistentSubscriptionAsync(
                    "$et-AccountCreated",
                    "InvoiceGeneration",
                    PersistentSubscriptionSettings
                    .Create()
                    .StartFromBeginning()
                    .CheckPointAfter(TimeSpan.FromSeconds(5))
                    .ResolveLinkTos()
                    .Build(), new UserCredentials("admin", "changeit"));
            }
            catch (Exception e)
            {
                Console.WriteLine($"Subscription already exist.");
            }

            await _subscriptionConnection.ConnectToPersistentSubscriptionAsync("$et-AccountCreated", "InvoiceGeneration", AccountCreatedEventAppeared);
        }
예제 #11
0
 private static void CreatePersistentSubscription(IEventStoreConnection conn)
 {
     try
     {
         conn.CreatePersistentSubscriptionAsync(StreamName, GroupName, PersistentSubscriptionSettings.Create().StartFromBeginning(),
                                                new UserCredentials("admin", "changeit")).Wait();
     }
     catch (Exception e)
     {
         // Already exist
     }
 }
        /// <summary>
        /// Creates the persistent connection.
        /// </summary>
        /// <param name="streamName">Name of the stream.</param>
        /// <param name="groupName">Name of the group.</param>
        /// <param name="persistentSubscriptionSettings">The persistent subscription settings.</param>
        /// <returns></returns>
        private async Task CreatePersistentSubscription(String streamName, String groupName, PersistentSubscriptionSettings persistentSubscriptionSettings)
        {
            Guard.ThrowIfNullOrEmpty(streamName, typeof(ArgumentNullException), "Stream Name cannot be null or empty when creating a Persistent Subscription");
            Guard.ThrowIfNullOrEmpty(groupName, typeof(ArgumentNullException), "Group Name cannot be null or empty when creating a Persistent Subscription");
            Guard.ThrowIfNull(persistentSubscriptionSettings, typeof(ArgumentNullException), "Persistent Subscription Settings cannot be null when creating a Persistent Subscription");

            // Get the connection
            IEventStoreConnection connection = await this.GetEventStoreConnection();

            // Attempt to create the subscription
            await connection.CreatePersistentSubscriptionAsync(streamName, groupName, persistentSubscriptionSettings, this.UserCredentials);
        }
예제 #13
0
        public static void Method()
        {
            var userCredentials = new UserCredentials("admin", "changeit");
            var settings        = PersistentSubscriptionSettings.Create()
                                  .DoNotResolveLinkTos().StartFromCurrent();

            conn.CreatePersistentSubscriptionAsync("newstream", "gr1", settings, userCredentials).Wait();
            var subscription = conn.ConnectToPersistentSubscriptionAsync(
                "newstream", "gr1", (_, evt) =>
            {
                Console.WriteLine("Received: " + Encoding.UTF8.GetString(evt.Event.Data));
            }).Result;
        }
예제 #14
0
 protected override void Given()
 {
     _conn = EventStoreConnection.Create(_node.TcpEndPoint);
     _conn.ConnectAsync().Wait();
     _conn.CreatePersistentSubscriptionAsync(_streamName, _groupName, _settings,
                                             DefaultData.AdminCredentials).Wait();
     _sub1 = _conn.ConnectToPersistentSubscription(_streamName, _groupName,
                                                   (subscription, @event) => Console.WriteLine(),
                                                   (subscription, reason, arg3) => Console.WriteLine());
     _sub2 = _conn.ConnectToPersistentSubscription(_streamName, _groupName,
                                                   (subscription, @event) => Console.WriteLine(),
                                                   (subscription, reason, arg3) => Console.WriteLine(),
                                                   DefaultData.AdminCredentials);
 }
 private async Task EnsureSubscriptionExists(string queue, IEventStoreConnection connection)
 {
     try
     {
         await connection.CreatePersistentSubscriptionAsync(queue, queue, PersistentSubscriptionSettings.Create(), null).ConfigureAwait(false);
     }
     catch (Exception ex)
     {
         if (ex.Message != string.Format("Subscription group {0} on stream {0} already exists", queue))
         {
             throw;
         }
     }
 }
예제 #16
0
        public async Task Subscribe(CancellationToken cancelToken)
        {
            var stream = $"{_endpoint}.{Assembly.GetEntryAssembly().GetName().Version}";
            var group  = $"{_endpoint}.{Assembly.GetEntryAssembly().GetName().Version}.sub";

            Logger.Write(LogLevel.Info, () => $"Endpoint [{_endpoint}] connecting to subscription group [{stream}]");

            try
            {
                var settings = PersistentSubscriptionSettings.Create()
                               .StartFromBeginning()
                               .WithReadBatchOf(_readsize)
                               .WithMessageTimeoutOf(TimeSpan.FromSeconds(60))
                               .CheckPointAfter(TimeSpan.FromSeconds(10))
                               .ResolveLinkTos()
                               .WithNamedConsumerStrategy(SystemConsumerStrategies.RoundRobin);

                await
                _connection.CreatePersistentSubscriptionAsync(stream, group, settings,
                                                              _connection.Settings.DefaultUserCredentials).ConfigureAwait(false);
            }
            catch (InvalidOperationException)
            {
            }

            ThreadPool.QueueUserWorkItem(_ =>
            {
                while (Bus.OnMessage == null || Bus.OnError == null)
                {
                    Logger.Warn($"Could not find NSBs onMessage handler yet - if this persists there is a problem.");
                    Thread.Sleep(1000);
                }

                // PushSettings will only exist AFTER finding OnMessage
                if (_concurrencyLimit == null)
                {
                    _concurrencyLimit = new SemaphoreSlim(Bus.PushSettings.MaxConcurrency);
                }

                _subscription = _connection.ConnectToPersistentSubscriptionAsync(stream, group, EventProcessor(cancelToken), subscriptionDropped: (sub, reason, e) =>
                {
                    Logger.Write(LogLevel.Warn, () => $"Subscription dropped for reason: {reason}.  Exception: {e?.Message ?? "UNKNOWN"}");
                    ProcessingLive = false;
                    Dropped?.Invoke(reason.ToString(), e);
                }, bufferSize: _readsize * 10, autoAck: false).Result;
                ProcessingLive = true;
            });
        }
 public async Task create(UserCredentials user)
 {
     try
     {
         var setting = create_subscription();
         await event_store_connection.CreatePersistentSubscriptionAsync(Stream, Subscription, setting, user);
     }
     catch (Exception ex)
     {
         if (ex.GetType() != typeof(InvalidOperationException) ||
             ex.Message != $"Subscription group {Subscription} on stream {Stream} already exists")
         {
             throw;
         }
     }
 }
예제 #18
0
        public static void ConnectToPersistentSubscription(
            string chatRoom,
            string groupName,
            Action <ChatMessage> onRecieved)
        {
            Connection.CreatePersistentSubscriptionAsync(
                chatRoom,
                groupName,
                PersistentSubscriptionSettings.Create().StartFromBeginning().Build(),
                _userCredentials);

            Connection.ConnectToPersistentSubscription(
                groupName,
                chatRoom,
                OnRecievedPersistent(onRecieved));
        }
예제 #19
0
 private void CreateSubscription(IEventStoreConnection connection)
 {
     PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create().StartFromCurrent();
     try
     {
         connection.CreatePersistentSubscriptionAsync(_streamName, Group, settings, new UserCredentials("admin", "changeit")).Wait();
     }
     catch (AggregateException ex)
     {
         if (ex.InnerException != null && (ex.InnerException.GetType() != typeof(InvalidOperationException)
             && ex.InnerException?.Message != $"Subscription group {Group} on stream {_streamName} already exists"))
         {
             Console.WriteLine("Persistant Subscription: CreateSubscription exception :" + ex);
             throw;
         }
     }
 }
        private void CreateSubscription()
        {
            PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create()
                                                      .StartFromCurrent();

            try
            {
                conn.CreatePersistentSubscriptionAsync(this.settings.Stream, this.settings.SubscriptionGroup, settings, User).Wait();
            }
            catch (AggregateException ex)
            {
                if (ex.InnerException.GetType() != typeof(InvalidOperationException) &&
                    ex.InnerException?.Message != $"Subscription group {this.settings.SubscriptionGroup} on stream {this.settings.Stream} already exists")
                {
                    throw;
                }
            }
        }
        private void CreateSubscription()
        {
            var settings = PersistentSubscriptionSettings.Create()
                           .DoNotResolveLinkTos()
                           .StartFromCurrent();

            try
            {
                conn.CreatePersistentSubscriptionAsync(streamName, groupName, settings, userCredentials).Wait();
            }
            catch (Exception e)
            {
                if (e.InnerException?.GetType() != typeof(InvalidOperationException) && e.InnerException?.Message !=
                    $"Subscription group {groupName} on stream {streamName} already exists")
                {
                    throw;
                }
            }
        }
예제 #22
0
        private static void CreateSubscription(IEventStoreConnection conn)
        {
            PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create()
                                                      .DoNotResolveLinkTos()
                                                      .StartFromCurrent();

            try
            {
                conn.CreatePersistentSubscriptionAsync(STREAM, GROUP, settings, new UserCredentials("admin", "changeit")).Wait();
            }
            catch (AggregateException ex)
            {
                if (ex.InnerException.GetType() != typeof(InvalidOperationException) &&
                    ex.InnerException?.Message != $"Subscription group {GROUP} on stream {STREAM} already exists")
                {
                    throw;
                }
            }
        }
예제 #23
0
        private async Task CreatePersistenSubscription()
        {
            PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create()
                                                      .ResolveLinkTos()
                                                      .StartFromBeginning()
                                                      .WithExtraStatistics();

            try
            {
                await _conn.CreatePersistentSubscriptionAsync(_streamName, "transactionReadModelWriter", settings,
                                                              _adminCredentials);

                Console.WriteLine("PersistentSubscription created");
            }
            catch (Exception e)
            {
                Console.WriteLine("PersistentSubscription already exists, using existing one.");
            }
        }
예제 #24
0
        private static async Task CreateSubscription(IEventStoreConnection conn, EventStoreOptions options)
        {
            try
            {
                var settings = PersistentSubscriptionSettings.Create()
                               .ResolveLinkTos()
                               .StartFromCurrent();

                await conn.CreatePersistentSubscriptionAsync(options.Subscription.stream, options.Subscription.group, settings, options.Credentials);
            }
            catch (AggregateException ex)
            {
                if (ex.InnerException.GetType() != typeof(InvalidOperationException) &&
                    ex.InnerException?.Message != $"Subscription group {options.Subscription.group} on stream {options.Subscription.stream} already exists")
                {
                    throw;
                }
            }
        }
        /*
         * Normally the creating of the subscription group is not done in your general executable code.
         * Instead it is normally done as a step during an install or as an admin task when setting
         * things up. You should assume the subscription exists in your code.
         */
        private void CreateSubscription()
        {
            PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create()
                                                      .DoNotResolveLinkTos()
                                                      .StartFromCurrent();

            try
            {
                _conn.CreatePersistentSubscriptionAsync(STREAM, GROUP, settings, User).Wait();
            }
            catch (AggregateException ex)
            {
                if (ex.InnerException.GetType() != typeof(InvalidOperationException) &&
                    ex.InnerException?.Message != $"Subscription group {GROUP} on stream {STREAM} already exists")
                {
                    throw;
                }
            }
        }
예제 #26
0
        public EventStoreDataFactory(string connectionString, string username, string password)
        {
            this.Username = username;
            this.Password = password;
            connection    = EventStoreConnection.Create(connectionString);
            //EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113));

            // Don't forget to tell the connection to connect!
            connection.ConnectAsync().Wait();

            //Should be run ONLY once actually.
            try
            {
                EventStore.ClientAPI.SystemData.UserCredentials credentials = new EventStore.ClientAPI.SystemData.UserCredentials(username, password);
                PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create().DoNotResolveLinkTos().StartFromCurrent();
                connection.CreatePersistentSubscriptionAsync("fingrid.messaging.smsrequest", "fingrid.messaging.smsrequest.group", settings, credentials).Wait();
            }
            catch { }
        }
예제 #27
0
        public static async Task <bool> CreateSubscription(
            this IEventStoreConnection conn,
            string stream,
            string group,
            UserCredentials credentials,
            Microsoft.Extensions.Logging.ILogger logger,
            bool startFromCurrent = false)
        {
            try
            {
                var settings = (startFromCurrent) ?
                               PersistentSubscriptionSettings
                               .Create()
                               .ResolveLinkTos()
                               .StartFromCurrent()
                               .Build() :
                               PersistentSubscriptionSettings
                               .Create()
                               .ResolveLinkTos()
                               .StartFromBeginning()
                               .Build();


                await conn.CreatePersistentSubscriptionAsync(stream, group, settings, credentials);

                return(true);
            }
            catch (InvalidOperationException invalidOperationException)
            {
                if (invalidOperationException.Message == $"Subscription group {group} on stream {stream} already exists")
                {
                    return(true);
                }

                logger.LogError(invalidOperationException, invalidOperationException.Message);
                throw;
            }
            catch (Exception e)
            {
                logger.LogError(e, e.Message);
                throw;
            }
        }
예제 #28
0
        public async Task InitializeActivityStream()
        {
            Logger.LogInformation("Initialize");

            await DeleteActivitliesStream();

            var conf =
                PersistentSubscriptionSettings
                .Create()
                .StartFromBeginning()
                .ResolveLinkTos()
                .CheckPointAfter(TimeSpan.FromSeconds(1))
                .MinimumCheckPointCountOf(1)
                .MaximumCheckPointCountOf(10)
                .Build();

            await conn.CreatePersistentSubscriptionAsync(Constants.StreamNameActivities,
                                                         Constants.GroupNameActivities, conf,
                                                         creds);
        }
예제 #29
0
        public async Task InstallConsumerGroupFor(string stream, Func <PersistentSubscriptionSettingsBuilder, PersistentSubscriptionSettingsBuilder> alterSettings = null)
        {
            var settings = PersistentSubscriptionSettings.Create().PreferRoundRobin().ResolveLinkTos();

            alterSettings = alterSettings ?? (x => x);

            settings = alterSettings(settings);

            var subscriberSettings = _environment.GetSettings <SubscribersSettings>();
            var groupName          = subscriberSettings.GetPersistentSubscriptionGroupNameFor(stream, _environment);

            try
            {
                await _eventStoreConnection.CreatePersistentSubscriptionAsync(stream, groupName, settings, _eventStoreConnectionString.GetUserCredentials()).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                _environment.Log(ex, "Failed to create consumer group for stream: {0}", LogLevel.Error, stream);
            }
        }
        private void CreateSubscription(Projection projection)
        {
            PersistentSubscriptionSettings settings = PersistentSubscriptionSettings.Create()
                                                      .DoNotResolveLinkTos()
                                                      .StartFromBeginning();

            try
            {
                Console.WriteLine($"Persistent subscriptişng is creating for {projection}");

                eventStoreConnection.CreatePersistentSubscriptionAsync(projection.ToString(), Group, settings, userCredentials).Wait();
            }
            catch (AggregateException ex)
            {
                if (ex.InnerException.GetType() != typeof(InvalidOperationException) &&
                    ex.InnerException?.Message != $"Subscription group {Group} on stream {projection.ToString()} already exists")
                {
                    throw;
                }
            }
        }
예제 #31
0
        protected override void Given()
        {
            _conn = EventStoreConnection.Create(_node.TcpEndPoint.ToESTcpUri());
            _conn.ConnectAsync().Wait();
            _conn.CreatePersistentSubscriptionAsync(_streamName, _groupName, _settings,
                    DefaultData.AdminCredentials).Wait();
            _sub1 = _conn.ConnectToPersistentSubscription(_streamName,_groupName,
                        (subscription, @event) => Console.WriteLine(), 
                        (subscription, reason, arg3) => Console.WriteLine());
            _sub2 = _conn.ConnectToPersistentSubscription(_streamName, _groupName,
                        (subscription, @event) => Console.WriteLine(),
                        (subscription, reason, arg3) => Console.WriteLine(),
                        DefaultData.AdminCredentials);

        }