/// <summary>
/// Establish EventStore Cluster Connection via Gossip Seed IP address(es)
/// </summary>
/// <remarks>
/// Connect to an EventStore cluster using gossip seed IP addresses.
/// This supports both a single EventStore cluster node and a multi-node EventStore cluster.
/// Note that a cluster of 1 is equivalent to a single instance.
/// </remarks>
/// <param name="credentials">UserCredentials: Username-Password used for authentication and authorization</param>
/// <param name="gossipSeeds">Array of GossipSeeds: The TCP/IP addresses, port and header. Generated by the <see cref="StreamStoreConnectionSettings"/>.</param>
/// <param name="useTlsConnection">bool: Use an encrypted TLS connection to EventStore server. (optional, defaults to false.)</param>
/// <param name="tlsCertificateHostName">string: The host name of the server expected on the TLS certificate. (optional unless <see cref="useTlsConnection"/> is true.)</param>
/// <param name="validateTlsCertificate">bool: Validate the server TLS certificate. (optional, defaults to false. Used if <see cref="useTlsConnection"/> is true.)</param>
/// <param name="verboseLogging">bool: Verbose Logging True/False (optional, defaults to false)</param>
private void Connect(
UserCredentials credentials,
GossipSeed[] gossipSeeds,
bool useTlsConnection = false,
string tlsCertificateHostName = "",
bool validateTlsCertificate = false,
bool verboseLogging = false)
{
var settings = SetClientConnectionSettings(
credentials,
useTlsConnection,
tlsCertificateHostName,
validateTlsCertificate,
verboseLogging);
Connection = new EventStoreConnectionWrapper(
EventStoreConnection.Create(settings,
ClusterSettings.Create()
.DiscoverClusterViaGossipSeeds()
.SetGossipSeedEndPoints(gossipSeeds),
"Gossip Seeds-Cluster Connection"));
if (Connection != null)
{
return;
}
_log.Error($"EventStore Custer of {gossipSeeds.Length} Connection is null - Diagnostic Monitoring will be unavailable.");
}
public CorrelatedStreamStoreRepository(
IStreamNameBuilder streamNameBuilder,
IStreamStoreConnection streamStoreConnection,
IEventSerializer eventSerializer)
{
_repository = new StreamStoreRepository(streamNameBuilder, streamStoreConnection, eventSerializer);
}
public void Bootstrap()
{
IEventStoreConnection esConnection = EventStoreConnection.Create("ConnectTo=tcp://admin:changeit@localhost:1113");
conn = new EventStoreConnectionWrapper(esConnection);
esConnection.Connected += (_, __) => Console.WriteLine("Connected");
esConnection.ConnectAsync().Wait();
IStreamNameBuilder namer = new PrefixedCamelCaseStreamNameBuilder();
IEventSerializer ser = new JsonMessageSerializer();
repo = new StreamStoreRepository(namer, conn, ser);
cmdHandler = new AccountCommandHandler(repo);
AccountAggregate acct = null;
try
{
var command = new CreateAccountCommand()
{
AccountId = _accountId,
HolderName = _holderName
};
cmdHandler.Handle(command);
}
catch (Exception e)
{
}
listener = new StreamListener("AccountAggregate", conn, namer, ser);
_readModel = new BalanceReadModel(() => listener);
}
/// <summary>
/// Connect to an EventStore server using DNS Discovery
/// </summary>
/// <remarks>
/// Define a common DNS name relating it to all cluster node ID address(es).
/// EventStore will process the DNS into gossip seeds for use in the connection.
/// </remarks>
/// <param name="credentials">UserCredentials: Username-Password used for authentication and authorization</param>
/// <param name="clusterDns">string: Cluster DNS name representing all nodes in the EventStore cluster</param>
/// <param name="networkPort">int: External HTTP port used for cluster gossip communication.</param>
/// <param name="useTlsConnection">bool: Use an encrypted TLS connection to EventStore server. (optional, defaults to false.)</param>
/// <param name="tlsCertificateHostName">string: The host name of the server expected on the TLS certificate. (optional unless <see cref="useTlsConnection"/> is true.)</param>
/// <param name="validateTlsCertificate">bool: Validate the server TLS certificate. (optional, defaults to false. Used if <see cref="useTlsConnection"/> is true.)</param>
/// <param name="verboseLogging">bool: Verbose Logging True/False (optional, defaults to false)</param>
private void Connect(
UserCredentials credentials,
string clusterDns,
int networkPort,
bool useTlsConnection = false,
string tlsCertificateHostName = "",
bool validateTlsCertificate = false,
bool verboseLogging = false)
{
var settings = SetClientConnectionSettings(
credentials,
useTlsConnection,
tlsCertificateHostName,
validateTlsCertificate,
verboseLogging);
var esConn = EventStoreConnection.Create(settings,
ClusterSettings.Create()
.DiscoverClusterViaDns()
.SetClusterDns(clusterDns)
.SetClusterGossipPort(networkPort),
$"{clusterDns}-Cluster Connection");
Connection = new EventStoreConnectionWrapper(esConn);
if (Connection != null)
{
return;
}
_log.Error("EventStore Connection is null - Diagnostic Monitoring will be unavailable.");
}
public when_using_listener_start_with_custom_stream_synched_bus(StreamStoreConnectionFixture fixture)
{
conn = fixture.Connection;
conn.Connect();
// Build an origin stream from strings to which the the events are appended
var originStreamName = $"testStream-{Guid.NewGuid():N}";
var result = fixture.Connection.AppendToStream(
originStreamName,
ExpectedVersion.NoStream,
null,
_eventSerializer.Serialize(new TestEvent()));
Assert.True(result.NextExpectedVersion == 0);
// Wait for the stream to be written
CommonHelpers.WaitForStream(conn, originStreamName);
listener = new QueuedStreamListener(
originStreamName,
fixture.Connection,
new PrefixedCamelCaseStreamNameBuilder(),
_eventSerializer,
"BUS_NAME",
LiveProcessingStarted);
SubscriptionDisposer = listener.EventStream.Subscribe(new AdHocHandler <Event>(Handle));
listener.Start(originStreamName);
}
/// <summary>Constructs state for EventStoreCatchUpSubscription.</summary>
/// <param name="connection">The connection.</param>
/// <param name="log">The <see cref="T:ReactiveDomain.ILogger" /> to use.</param>
/// <param name="streamId">The stream name.</param>
/// <param name="userCredentials">User credentials for the operations.</param>
/// <param name="eventAppeared">Action invoked when events are received.</param>
/// <param name="liveProcessingStarted">Action invoked when the read phase finishes.</param>
/// <param name="subscriptionDropped">Action invoked if the subscription drops.</param>
/// <param name="settings">Settings for this subscription.</param>
protected CatchUpSubscription(
IStreamStoreConnection connection,
ILogger log,
string streamId,
UserCredentials userCredentials,
Func <CatchUpSubscription, RecordedEvent, Task> eventAppeared,
Action <CatchUpSubscription> liveProcessingStarted,
Action <CatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped,
CatchUpSubscriptionSettings settings)
{
Ensure.NotNull(connection, nameof(connection));
Ensure.NotNull(log, nameof(log));
Ensure.NotNull(eventAppeared, nameof(eventAppeared));
_connection = connection;
Log = log;
StreamId = string.IsNullOrEmpty(streamId) ? string.Empty : streamId;
_userCredentials = userCredentials;
ReadBatchSize = settings.ReadBatchSize;
MaxPushQueueSize = settings.MaxLiveQueueSize;
EventAppeared = eventAppeared;
_liveProcessingStarted = liveProcessingStarted;
_subscriptionDropped = subscriptionDropped;
Verbose = settings.VerboseLogging;
SubscriptionName = settings.SubscriptionName ?? string.Empty;
}
private void AppendEvents(int numEventsToBeSent, IStreamStoreConnection conn, string streamName, int startNumber = 0)
{
for (int evtNumber = startNumber; evtNumber < numEventsToBeSent + startNumber; evtNumber++)
{
var evt = new SubscriptionTestEvent(evtNumber);
conn.AppendToStream(streamName, ExpectedVersion.Any, null, _serializer.Serialize(evt));
}
}
public ConfiguredConnection(
IStreamStoreConnection conn,
IStreamNameBuilder namer,
IEventSerializer serializer)
{
Connection = conn;
StreamNamer = namer;
Serializer = serializer;
}
public AccountTest()
{
_mockStore = new InMemoryEventStore();
_mockStoreConnection = _mockStore.Connect("Accounts");
var eventSerializer = new JsonEventSerializer();
_repo = new StreamStoreRepository(new PrefixedCamelCaseStreamNameBuilder(), _mockStoreConnection, eventSerializer);
_service = new AccountHandler(_repo);
}
public StreamStoreRepository(
IStreamNameBuilder streamNameBuilder,
IStreamStoreConnection eventStoreConnection,
IEventSerializer eventSerializer)
{
_streamNameBuilder = streamNameBuilder;
_streamStoreConnection = eventStoreConnection;
_eventSerializer = eventSerializer;
}
public when_using_snapshot_read_model(StreamStoreConnectionFixture fixture)
{
_conn = fixture.Connection;
_conn.Connect();
_aggId = Guid.NewGuid();
_stream = _namer.GenerateForAggregate(typeof(SnapReadModelTestAggregate), _aggId);
AppendEvents(10, _conn, _stream, 2);
}
internal StreamCatchUpSubscription(IStreamStoreConnection connection, ILogger log, string streamId, long?fromEventNumberExclusive, UserCredentials userCredentials, Func <CatchUpSubscription, RecordedEvent, Task> eventAppeared, Action <CatchUpSubscription> liveProcessingStarted, Action <CatchUpSubscription, SubscriptionDropReason, Exception> subscriptionDropped, CatchUpSubscriptionSettings settings)
: base(connection, log, streamId, userCredentials, eventAppeared, liveProcessingStarted, subscriptionDropped, settings)
{
Ensure.NotNullOrEmpty(streamId, nameof(streamId));
long?nullable = fromEventNumberExclusive;
_lastProcessedEventNumber = nullable ?? -1L;
nullable = fromEventNumberExclusive;
_nextReadEventNumber = nullable ?? 0L;
}
private void AppendEvents(int numEventsToBeSent, IStreamStoreConnection conn, string streamName)
{
_toh.WriteLine(
$"Appending {numEventsToBeSent} events to stream \"{streamName}\" with connection {conn.ConnectionName}");
for (int evtNumber = 0; evtNumber < numEventsToBeSent; evtNumber++)
{
var evt = new ReadTestEvent(evtNumber);
conn.AppendToStream(streamName, ExpectedVersion.Any, null, _serializer.Serialize(evt));
}
}
public QueuedStreamListener(
string name,
IStreamStoreConnection connection,
IStreamNameBuilder streamNameBuilder,
IEventSerializer serializer,
string busName = null,
Action <Unit> liveProcessingStarted = null,
Action <SubscriptionDropReason, Exception> subscriptionDropped = null) :
base(name, connection, streamNameBuilder, serializer, busName, liveProcessingStarted, subscriptionDropped)
{
SyncQueue = new QueuedHandler(this, "SyncListenerQueue");
}
public CorrelatedStreamStoreRepository(
IStreamNameBuilder streamNameBuilder,
IStreamStoreConnection streamStoreConnection,
IEventSerializer eventSerializer,
Func <IRepository, IAggregateCache> cacheFactory = null)
{
_repository = new StreamStoreRepository(streamNameBuilder, streamStoreConnection, eventSerializer);
if (cacheFactory != null)
{
_cache = cacheFactory(_repository);
}
}
private void AppendEvents(
int numEventsToBeSent,
IStreamStoreConnection conn,
string streamName,
int value)
{
for (int evtNumber = 0; evtNumber < numEventsToBeSent; evtNumber++)
{
var evt = new ReadModelTestEvent(evtNumber, value);
conn.AppendToStream(streamName, ExpectedVersion.Any, null, Serializer.Serialize(evt));
}
}
/// <summary>
/// Create a stream Reader
/// </summary>
/// <param name="name">Name of the reader</param>
/// <param name="streamStoreConnection">The stream store to subscribe to</param>
/// <param name="streamNameBuilder">The source for correct stream names based on aggregates and events</param>
/// <param name="serializer">the serializer to apply to the evenets in the stream</param>
/// <param name="busName">The name to use for the internal bus (helpful in debugging)</param>
public StreamReader(
string name,
IStreamStoreConnection streamStoreConnection,
IStreamNameBuilder streamNameBuilder,
IEventSerializer serializer,
string busName = null)
{
ReaderName = name ?? nameof(StreamReader);
_streamStoreConnection = streamStoreConnection ?? throw new ArgumentNullException(nameof(streamStoreConnection));
_streamNameBuilder = streamNameBuilder ?? throw new ArgumentNullException(nameof(streamNameBuilder));
Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
Bus = new InMemoryBus(busName ?? $"{ReaderName} {nameof(EventStream)}");
}
protected with_message_logging_enabled(IStreamStoreConnection connection)
{
Connection = connection;
Bus = new Dispatcher(nameof(with_message_logging_enabled));
StreamNameBuilder = new PrefixedCamelCaseStreamNameBuilder("UnitTest");
EventSerializer = new JsonMessageSerializer();
Repo = new StreamStoreRepository(StreamNameBuilder, Connection, new JsonMessageSerializer());
// instantiate Logger class that inherits from QueuedSubscriber
Logging = new EventStoreMessageLogger(Bus,
Connection,
StreamName,
true);
}
private async Task ReadEventsInternalAsync(IStreamStoreConnection connection, UserCredentials userCredentials, long?lastEventNumber)
{
StreamEventsSlice slice;
do
{
slice = connection.ReadStreamForward(
StreamId,
_nextReadEventNumber,
ReadBatchSize,
userCredentials);
}while (!await ReadEventsCallbackAsync(slice, lastEventNumber).ConfigureAwait(false));
}
/// <summary>
/// Create a stream Reader
/// </summary>
/// <param name="name">Name of the reader</param>
/// <param name="streamStoreConnection">The stream store to subscribe to</param>
/// <param name="streamNameBuilder">The source for correct stream names based on aggregates and events</param>
/// <param name="serializer">the serializer to apply to the events in the stream</param>
/// <param name="handle">The target handle that read events are passed to</param>
public StreamReader(
string name,
IStreamStoreConnection streamStoreConnection,
IStreamNameBuilder streamNameBuilder,
IEventSerializer serializer,
Action <IMessage> handle)
{
ReaderName = name ?? nameof(StreamReader);
_streamStoreConnection = streamStoreConnection ?? throw new ArgumentNullException(nameof(streamStoreConnection));
_streamNameBuilder = streamNameBuilder ?? throw new ArgumentNullException(nameof(streamNameBuilder));
Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
Handle = handle;
}
/// <summary>
/// For listening to generic streams
/// </summary>
/// <param name="listenerName"></param>
/// <param name="eventStoreConnection">The event store to subscribe to</param>
/// <param name="streamNameBuilder">The source for correct stream names based on aggregates and events</param>
/// <param name="serializer"></param>
/// <param name="busName">The name to use for the internal bus (helpful in debugging)</param>
public StreamListener(
string listenerName,
IStreamStoreConnection eventStoreConnection,
IStreamNameBuilder streamNameBuilder,
IEventSerializer serializer,
string busName = null)
{
_bus = new InMemoryBus(busName ?? "Stream Listener");
_eventStoreConnection = eventStoreConnection ?? throw new ArgumentNullException(nameof(eventStoreConnection));
ListenerName = listenerName;
_streamNameBuilder = streamNameBuilder;
_serializer = serializer;
}
private void AppendEventArray(int numEventsToBeSent, IStreamStoreConnection conn, string streamName)
{
_toh.WriteLine(
$"Appending {numEventsToBeSent} events to stream \"{streamName}\" with connection {conn.ConnectionName}");
var events = new IMessage[numEventsToBeSent];
for (int evtNumber = 0; evtNumber < numEventsToBeSent; evtNumber++)
{
events[evtNumber] = new ReadTestEvent(evtNumber);
}
conn.AppendToStream(streamName, ExpectedVersion.Any, null,
events.Select(x => _serializer.Serialize(x)).ToArray());
}
public SynchronizableStreamListener(
string name,
IStreamStoreConnection connection,
IStreamNameBuilder streamNameBuilder,
IEventSerializer serializer,
bool sync = false,
string busName = null) :
base(name, connection, streamNameBuilder, serializer, busName)
{
Sync = sync;
if (Sync)
{
SyncQueue = new QueuedHandler(this, "SyncListenerQueue");
}
}
public when_using_read_model_base(StreamStoreConnectionFixture fixture)
: base(nameof(when_using_read_model_base), GetListener)
{
//_conn = new MockStreamStoreConnection("mockStore");
_conn = fixture.Connection;
_conn.Connect();
// ReSharper disable once RedundantTypeArgumentsOfMethod
EventStream.Subscribe <ReadModelTestEvent>(this);
_stream1 = Namer.GenerateForAggregate(typeof(TestAggregate), Guid.NewGuid());
_stream2 = Namer.GenerateForAggregate(typeof(TestAggregate), Guid.NewGuid());
AppendEvents(10, _conn, _stream1, 2);
AppendEvents(10, _conn, _stream2, 3);
}
public void Bootstrap()
{
IEventStoreConnection esConnection = EventStoreConnection.Create("ConnectTo=tcp://admin:changeit@localhost:1113");
conn = new EventStoreConnectionWrapper(esConnection);
esConnection.Connected += (_, __) => Console.WriteLine("Connected");
esConnection.ConnectAsync().Wait();
IStreamNameBuilder namer = new PrefixedCamelCaseStreamNameBuilder();
IEventSerializer ser = new JsonMessageSerializer();
repo = new StreamStoreRepository(namer, conn, ser);
OrderAggregate order = null;
IListener listener = new StreamListener("Order", conn, namer, ser);
_readModel = new OrderReadModel(() => listener);
}
internal static void WaitForStream(IStreamStoreConnection conn, string streamName)
{
//wait for the category projection to be written
AssertEx.IsOrBecomesTrue(
() =>
{
try
{
return(conn.ReadStreamForward(streamName, 0, 1) != null);
}
catch
{
return(false);
}
},
2000,
$"Stream '{streamName}' not created");
}
/// <summary>
/// For listening to generic streams
/// </summary>
/// <param name="listenerName"></param>
/// <param name="streamStoreConnection">The event store to subscribe to</param>
/// <param name="streamNameBuilder">The source for correct stream names based on aggregates and events</param>
/// <param name="serializer"></param>
/// <param name="busName">The name to use for the internal bus (helpful in debugging)</param>
/// <param name="liveProcessingStarted"></param>
/// <param name="subscriptionDropped"></param>
public StreamListener(
string listenerName,
IStreamStoreConnection streamStoreConnection,
IStreamNameBuilder streamNameBuilder,
IEventSerializer serializer,
string busName = null,
Action <Unit> liveProcessingStarted = null,
Action <SubscriptionDropReason, Exception> subscriptionDropped = null)
{
Bus = new InMemoryBus(busName ?? "Stream Listener");
_streamStoreConnection = streamStoreConnection ?? throw new ArgumentNullException(nameof(streamStoreConnection));
Settings = CatchUpSubscriptionSettings.Default;
ListenerName = listenerName;
_streamNameBuilder = streamNameBuilder;
Serializer = serializer;
_liveProcessingStarted = liveProcessingStarted;
_subscriptionDropped = subscriptionDropped;
}
public when_using_read_model_base_with_reader(StreamStoreConnectionFixture fixture)
: base(nameof(when_using_read_model_base),
new ConfiguredConnection(fixture.Connection, Namer, Serializer))
{
_conn = fixture.Connection;
_conn.Connect();
// ReSharper disable once RedundantTypeArgumentsOfMethod
EventStream.Subscribe <ReadModelTestEvent>(this);
_stream1 = Namer.GenerateForAggregate(typeof(TestAggregate), Guid.NewGuid());
_stream2 = Namer.GenerateForAggregate(typeof(TestAggregate), Guid.NewGuid());
AppendEvents(10, _conn, _stream1, 2);
AppendEvents(10, _conn, _stream2, 3);
_conn.TryConfirmStream(_stream1, 10);
_conn.TryConfirmStream(_stream2, 10);
_conn.TryConfirmStream(Namer.GenerateForCategory(typeof(TestAggregate)), 20);
}
private void ConnectToLiveES()
{
var userCredentials = new ReactiveDomain.UserCredentials(username: "******", password: "******");
var eventStoreLoader = new EventStoreLoader();
eventStoreLoader.Connect(
credentials: userCredentials,
server: IPAddress.Parse("127.0.0.1"),
tcpPort: 1113);
Connection = eventStoreLoader.Connection;
// ReSharper disable once PossibleNullReferenceException
_connection = (IEventStoreConnection)typeof(EventStoreConnectionWrapper)
.GetField("_conn", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(eventStoreLoader.Connection);
log.Info("Connected to ES");
}
public void Connect(
UserCredentials credentials,
IPAddress server,
int tcpPort)
{
var tcpEndpoint = new IPEndPoint(server, tcpPort);
var settings = ConnectionSettings.Create()
.SetDefaultUserCredentials(new global::EventStore.ClientAPI.SystemData.UserCredentials(credentials.Username, credentials.Password))
.KeepReconnecting()
.KeepRetrying()
.UseConsoleLogger()
//.EnableVerboseLogging()
.Build();
Connection = new EventStoreConnectionWrapper(EventStoreConnection.Create(settings, tcpEndpoint, "Default Connection"));
if (Connection == null)
{
_log.Error("EventStore Connection is null - Diagnostic Monitoring will be unavailable.");
TeardownEventStore(false);
return;
}
Connection.Connect();
int retry = 8;
int count = 0;
do
{
try {
Connection.ReadStreamForward("by_event_type", 0, 1);
return;
}
catch {
//ignore
}
Thread.Sleep(100);
count++;
} while (count < retry);
throw new Exception("Unable to start Eventstore");
}
