public static void Configure(Configure args)
{
//set connection etc fluent API
_name = args._name;
_connection = new EventStoreConnection(new IPEndPoint(args._address, args._port));
}
public ViewBuilderService(EventStoreConnection eventStoreConnection, IEventStoreSerializer serializer, IDocumentStore store, IModelUpdateNotifier updateNotifier)
{
_eventStoreConnection = eventStoreConnection;
_serializer = serializer;
_store = store;
_updateNotifier = updateNotifier;
}
/// <summary>
/// Constructs a new <see cref="EventStoreTransaction"/>
/// </summary>
/// <param name="transactionId">The transaction id of the transaction</param>
/// <param name="connection">The connection the transaction is hooked to</param>
internal EventStoreTransaction(long transactionId, EventStoreConnection connection)
{
Ensure.Nonnegative(transactionId, "transactionId");
TransactionId = transactionId;
_connection = connection;
}
public Event_Publisher(EventStoreConnection eventStoreConnection, string storeId)
{
_eventStoreConnection = eventStoreConnection;
_storeId = storeId;
_fileName = "checkpoint_" + _storeId;
_batch = 100;
}
public void which_supposed_to_be_system_should_succees__but_on_your_own_risk()
{
const string stream = "$which_supposed_to_be_system_should_succees__but_on_your_own_risk";
using (var connection = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = connection.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
}
}
public void which_does_not_exist_should_be_successfull()
{
const string stream = "which_does_not_exist_should_be_successfull";
using (var connection = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = connection.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
}
}
public static void Enable(EventStoreConnection store, string[] commandArgs)
{
var names = GetProjectionNames(commandArgs);
foreach (var name in names)
{
Log("Enabling {0}...", name);
store.Projections.Enable(name);
Log("{0} enabled", name);
}
}
public static void Delete(EventStoreConnection store, string[] commandArgs)
{
var names = GetProjectionNames(commandArgs);
foreach (var name in names)
{
Log("Deleting {0}...", name);
store.Projections.Delete(name);
Log("{0} deleted", name);
}
}
public void which_does_not_exist_should_fail()
{
const string stream = "which_does_not_exist_should_fail";
using (var connection = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var delete = connection.DeleteStreamAsync(stream, ExpectedVersion.Any);
Assert.Inconclusive();
//Assert.That(() => delete.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<WrongExpectedVersionException>());
}
}
public void which_already_exists_should_success_when_passed_empty_stream_expected_version()
{
const string stream = "which_already_exists_should_success_when_passed_empty_stream_expected_version";
using (var connection = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = connection.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
var delete = connection.DeleteStreamAsync(stream, ExpectedVersion.EmptyStream);
Assert.DoesNotThrow(delete.Wait);
}
}
public void should_append_with_correct_exp_ver_to_existing_stream()
{
const string stream = "should_append_with_correct_exp_ver_to_existing_stream";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = store.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, new[] { new TestEvent() });
Assert.DoesNotThrow(append.Wait);
}
}
private static void Execute(EventStoreConnection store, string[] args)
{
var command = args[0].Trim().ToLower();
var commandArgs = args.Skip(1).ToArray();
Action<EventStoreConnection, string[]> executor;
if(Commands.TryGetValue(command, out executor))
executor(store, commandArgs);
else
Log("{0} is not a recognized command", args[0]);
}
public static int Count(EventStoreConnection store, string stream)
{
var result = 0;
while (true)
{
var slice = store.ReadStreamEventsForward(stream, result, SliceSize, false);
result += slice.Events.Length;
if (slice.IsEndOfStream)
break;
}
return result;
}
public void with_invalid_expected_version_should_fail()
{
const string stream = "with_invalid_expected_version_should_fail";
using (var connection = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = connection.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
var delete = connection.DeleteStreamAsync(stream, 1);
Assert.That(() => delete.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<WrongExpectedVersionException>());
}
}
public void can_append_multiple_events_at_once()
{
const string stream = "can_append_multiple_events_at_once";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = store.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
var events = Enumerable.Range(0, 100).Select(i => new TestEvent(i.ToString(), i.ToString()));
var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, events);
Assert.DoesNotThrow(append.Wait);
}
}
public void which_already_exists_should_fail()
{
const string stream = "which_already_exists_should_fail";
using (var connection = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var initialCreate = connection.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(initialCreate.Wait);
var secondCreate = connection.CreateStreamAsync(stream, new byte[0]);
Assert.Inconclusive();
//Assert.That(() => secondCreate.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<WrongExpectedVersionException>());
}
}
public void should_create_stream_with_no_stream_exp_ver_on_first_write_if_does_not_exist()
{
const string stream = "should_create_stream_with_no_stream_exp_ver_on_first_write_if_does_not_exist";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var append = store.AppendToStreamAsync(stream, ExpectedVersion.NoStream, new[] {new TestEvent()});
Assert.DoesNotThrow(append.Wait);
var read = store.ReadEventStreamForwardAsync(stream, 0, 2);
Assert.DoesNotThrow(read.Wait);
Assert.That(read.Result.Events.Length, Is.EqualTo(2));
}
}
public void which_was_allready_deleted_should_fail()
{
const string stream = "which_was_allready_deleted_should_fail";
using (var connection = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = connection.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
var delete = connection.DeleteStreamAsync(stream, ExpectedVersion.EmptyStream);
Assert.DoesNotThrow(delete.Wait);
var secondDelete = connection.DeleteStreamAsync(stream, ExpectedVersion.Any);
Assert.That(() => secondDelete.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<StreamDeletedException>());
}
}
public static void Create(EventStoreConnection store, string[] commandArgs)
{
if (commandArgs.Length < 2)
{
Log("Invalid argument value (projection type)");
return;
}
var type = commandArgs[0].Trim().ToLower();
string pname;
var query = GetQuery(commandArgs.Skip(1).ToArray(), out pname);
if(query == null || (type != "onetime" && string.IsNullOrEmpty(pname)))
{
Log("Invalid arguments");
return;
}
switch (type)
{
case "onetime":
Log("Creating onetime projection...");
store.Projections.CreateOneTime(query);
Log("Created");
break;
case "adhoc":
Log("Creating adhoc projection {0}...", pname);
store.Projections.CreateAdHoc(pname, query);
Log("Created");
break;
case "continuous":
Log("Creating continuous projection {0}...", pname);
store.Projections.CreateContinuous(pname, query);
Log("Created");
break;
case "persistent":
Log("Creating persistent projection {0}...", pname);
store.Projections.CreatePersistent(pname, query);
Log("Created");
break;
default:
Log("projection type not recognized");
break;
}
}
public void write_to_and_delete()
{
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
using (var connection = new EventStoreConnection(endpoint))
{
var ev = new TestEvent("Some data");
var stream = string.Format("test-delete-{0}", Guid.NewGuid());
var appendTask = connection.AppendToStreamAsync(stream, -2, new[] { ev });
appendTask.Wait();
Assert.IsTrue(appendTask.Result.IsSuccessful, "Failed to append data to stream.");
var data = connection.ReadEventStream(stream, 0, int.MaxValue);
var lastEventVersion = data.Events[data.Events.Length - 1].EventNumber;
var deleteTask = connection.DeleteStreamAsync(stream, lastEventVersion);
deleteTask.Wait();
Assert.IsTrue(deleteTask.Result.IsSuccessful, "Failed to delete stream.");
}
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_firstEvent = TestEvent.NewTestEvent();
_connection = EventStoreConnection.Create();
_connection.Connect(_node.TcpEndPoint);
_connection.AppendToStream("test-stream",
ExpectedVersion.NoStream,
_firstEvent,
TestEvent.NewTestEvent(),
TestEvent.NewTestEvent());
using (var transaction = _connection.StartTransaction("test-stream", 3))
{
transaction.Commit();
}
}
public IEventStoreConnection CreateConnectionWithConnectionString(
bool useSsl,
string configureSettings = default,
int port = 2113,
bool useDnsEndPoint = false)
{
var settings = configureSettings ?? DefaultConfigureSettingsForConnectionString;
var host = useDnsEndPoint ? "localhost" : IPAddress.Loopback.ToString();
if (useSsl)
{
settings += "UseSslConnection=true;ValidateServer=false;";
}
else
{
settings += "UseSslConnection=false;";
}
var gossipSeeds = GetGossipSeedEndPointsExceptFor(-1, port, useDnsEndPoint);
var gossipSeedsString = "";
for (var i = 0; i < gossipSeeds.Length; i++)
{
if (i > 0)
{
gossipSeedsString += ",";
}
gossipSeedsString += host + ":" + gossipSeeds[i].GetPort();
}
settings += "CustomHttpMessageHandler=SkipCertificateValidation;";
var connectionString = $"GossipSeeds={gossipSeedsString};{settings}";
return(EventStoreConnection.Create(connectionString));
}
public IEventStoreConnection CreateConnectionWithGossipSeeds(
Func <ConnectionSettingsBuilder, ConnectionSettingsBuilder> configureSettings = default,
int port = 2113,
bool useDnsEndPoint = false,
int maxDiscoverAttempts = 1)
{
var settings = (configureSettings ?? DefaultConfigureSettings)(DefaultBuilder)
.Build();
var gossipSeeds = GetGossipSeedEndPointsExceptFor(-1, port, useDnsEndPoint);
var clusterSettings = new ClusterSettingsBuilder()
.DiscoverClusterViaGossipSeeds()
.SetGossipSeedEndPoints(true, gossipSeeds);
if (maxDiscoverAttempts == -1)
{
clusterSettings = clusterSettings.KeepDiscovering();
}
else
{
clusterSettings = clusterSettings.SetMaxDiscoverAttempts(maxDiscoverAttempts);
}
return(EventStoreConnection.Create(settings, clusterSettings.Build()));
}
public void should_create_stream_if_commits_no_events_to_empty_stream()
{
const string stream = "should_create_stream_if_commits_no_events_to_empty_stream";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var start = store.StartTransactionAsync(stream, ExpectedVersion.NoStream);
Assert.DoesNotThrow(start.Wait);
var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream);
Assert.DoesNotThrow(commit.Wait);
var streamCreated = store.ReadEventStreamForwardAsync(stream, 0, 1);
Assert.DoesNotThrow(streamCreated.Wait);
Assert.That(streamCreated.Result.Events.Length, Is.EqualTo(1));//stream created event
}
}
public void should_validate_expectations_on_commit()
{
const string stream = "should_validate_expectations_on_commit";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var start = store.StartTransactionAsync(stream, 100500);
Assert.DoesNotThrow(start.Wait);
var write = store.TransactionalWriteAsync(start.Result.TransactionId, stream, new[] { new TestEvent() });
Assert.DoesNotThrow(write.Wait);
var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream);
Assert.That(() => commit.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<WrongExpectedVersionException>());
}
}
public void should_start_on_non_existing_stream_with_exp_ver_any_and_create_stream_on_commit()
{
const string stream = "should_start_on_non_existing_stream_with_exp_ver_any_and_create_stream_on_commit";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var start = store.StartTransactionAsync(stream, ExpectedVersion.Any);
Assert.DoesNotThrow(start.Wait);
var write = store.TransactionalWriteAsync(start.Result.TransactionId, stream, new[] {new TestEvent()});
Assert.DoesNotThrow(write.Wait);
var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream);
Assert.DoesNotThrow(commit.Wait);
}
}
public void should_commit_when_writing_with_exp_ver_any_even_while_somene_is_writing_in_parallel()
{
const string stream = "should_commit_when_writing_with_exp_ver_any_even_while_somene_is_writing_in_parallel";
var transWritesCompleted = new AutoResetEvent(false);
var writesToSameStreamCompleted = new AutoResetEvent(false);
var totalTranWrites = 500;
var totalPlainWrites = 500;
//excplicitly creating stream
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
store.CreateStream(stream, new byte[0]);
//500 events during transaction
ThreadPool.QueueUserWorkItem(_ =>
{
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var transaction = store.StartTransaction(stream, ExpectedVersion.Any);
var writes = new List<Task>();
for (int i = 0; i < totalTranWrites; i++)
{
if (i % 10 == 0)
writes.RemoveAll(write => write.IsCompleted);
writes.Add(store.TransactionalWriteAsync(transaction.TransactionId,
transaction.Stream,
new[] { new TestEvent((i + 1).ToString(), "trans write") }));
}
Task.WaitAll(writes.ToArray());
store.CommitTransaction(transaction.TransactionId, transaction.Stream);
transWritesCompleted.Set();
}
});
//500 events to same stream in parallel
ThreadPool.QueueUserWorkItem(_ =>
{
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var writes = new List<Task>();
for (int i = 0; i < totalPlainWrites; i++)
{
if (i % 10 == 0)
writes.RemoveAll(write => write.IsCompleted);
writes.Add(store.AppendToStreamAsync(stream,
ExpectedVersion.Any,
new[] {new TestEvent((i + 1).ToString(), "plain write")}));
}
Task.WaitAll(writes.ToArray());
writesToSameStreamCompleted.Set();
}
});
transWritesCompleted.WaitOne();
writesToSameStreamCompleted.WaitOne();
//check all written
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var slice = store.ReadEventStreamForward(stream, 0, totalTranWrites + totalPlainWrites + 1);
Assert.That(slice.Events.Length, Is.EqualTo(totalTranWrites + totalPlainWrites + 1));
Assert.That(slice.Events.Count(ent => Encoding.UTF8.GetString(ent.Metadata) == "trans write"), Is.EqualTo(totalTranWrites));
Assert.That(slice.Events.Count(ent => Encoding.UTF8.GetString(ent.Metadata) == "plain write"), Is.EqualTo(totalPlainWrites));
}
}
public void should_not_fail_to_commit_if_started_with_wrong_ver_but_committing_with_correct_ver()
{
const string stream = "should_not_fail_to_commit_if_started_with_wrong_ver_but_committing_with_correct_ver";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
store.CreateStream(stream, new byte[0]);
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var start = store.StartTransactionAsync(stream, 1);
Assert.DoesNotThrow(start.Wait);
var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, new[] { new TestEvent() });
Assert.DoesNotThrow(append.Wait);
var write = store.TransactionalWriteAsync(start.Result.TransactionId, start.Result.Stream, new[] { new TestEvent() });
Assert.DoesNotThrow(write.Wait);
var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream);
Assert.DoesNotThrow(commit.Wait);
}
}
public void should_fail_to_commit_if_started_with_correct_ver_but_on_commit_stream_was_deleted()
{
const string stream = "should_fail_to_commit_if_started_with_correct_ver_but_on_commit_stream_was_deleted";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
store.CreateStream(stream, new byte[0]);
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var start = store.StartTransactionAsync(stream, ExpectedVersion.EmptyStream);
Assert.DoesNotThrow(start.Wait);
var write = store.TransactionalWriteAsync(start.Result.TransactionId, start.Result.Stream, new[] { new TestEvent() });
Assert.DoesNotThrow(write.Wait);
var delete = store.DeleteStreamAsync(stream, ExpectedVersion.EmptyStream);
Assert.DoesNotThrow(delete.Wait);
var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream);
Assert.That(() => commit.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<StreamDeletedException>());
}
}
public EventStoreWrapper(EventStoreConnection eventStoreConnection, Func<Dictionary<string, object>> writeMetaData)
{
this.eventStoreConnection = eventStoreConnection;
this.writeMetaData = writeMetaData;
}
public static void Configure(Configure args)
{
_name = args._name;
_connection = new EventStoreConnection(new IPEndPoint(args._address, args._port));
}
public StreamWriter(EventStoreConnection store, string stream, int version)
{
_store = store;
_stream = stream;
_version = version;
}
public TransactionalWriter(EventStoreConnection store, string stream)
{
_store = store;
_stream = stream;
}
public void SetUp()
{
_connection = EventStoreConnection.Create();
_connection.Connect(IntegrationTestTcpEndPoint);
_repo = new GetEventStoreRepository(_connection);
}