private void Connect()
{
var settings = ConnectionSettings.Create();
var ip = new IPEndPoint(_ipAddress, _port);
Log("Connecting to {0}:{1}...", _ipAddress, _port);
_connection = EventStoreConnection.Create(settings, ip);
_connection.Connect();
_connection.AppendToStream("hello", ExpectedVersion.Any, new EventData(Guid.NewGuid(), "Hello", false, new byte[0], new byte[0]));
Log("Connected.");
Log("Username to be used is: {0}", _userName);
_credentials = new UserCredentials(_userName, _password);
}
public TailWriter Append(params EventData[] events)
{
for (var i = 0; i < events.Length; i++)
{
var expVer = _version == ExpectedVersion.Any ? ExpectedVersion.Any : _version + i;
var nextExpVer = _store.AppendToStream(_stream, expVer, new[] { events[i] }).NextExpectedVersion;
if (_version != ExpectedVersion.Any)
{
Assert.AreEqual(expVer + 1, nextExpVer);
}
}
return(new TailWriter(_store, _stream));
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.Connect();
_connection.SetStreamMetadata(Stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetMaxCount(3));
_testEvents = Enumerable.Range(0, 5).Select(x => TestEvent.NewTestEvent(data: x.ToString())).ToArray();
_connection.AppendToStream(Stream, ExpectedVersion.EmptyStream, _testEvents);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.Connect();
_conn.SetStreamMetadata("$all", -1,
StreamMetadata.Build().SetReadRole(SystemRoles.All),
new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword));
_testEvents = Enumerable.Range(0, 20).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray();
_conn.AppendToStream("stream", ExpectedVersion.EmptyStream, _testEvents);
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.Connect();
_connection.SetStreamMetadata(Stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetMaxCount(3));
_testEvents = Enumerable.Range(0, 5).Select(x => TestEvent.NewTestEvent(data: x.ToString())).ToArray();
_connection.AppendToStream(Stream, ExpectedVersion.EmptyStream, _testEvents);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.Connect();
_conn.SetStreamMetadata("$all", -1,
StreamMetadata.Build().SetReadRole(SystemRoles.All),
new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword));
_testEvents = Enumerable.Range(0, 20).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray();
_conn.AppendToStream("stream", ExpectedVersion.EmptyStream, _testEvents);
}
private static void AppendToStream(UserCredentials credentials, IEventStoreConnection connection, UnitOfWork unitOfWork)
{
var affected = unitOfWork.GetChanges().Single();
connection.AppendToStream(
affected.Identifier,
affected.ExpectedVersion,
affected.Root.GetChanges().
Select(_ =>
new EventData(
Guid.NewGuid(),
_.GetType().Name,
true,
ToJsonByteArray(_),
new byte[0])),
credentials);
}
public void setting_metadata_for_existing_stream_works()
{
const string stream = "setting_metadata_for_existing_stream_works";
_connection.AppendToStream(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent());
var metadataBytes = Guid.NewGuid().ToByteArray();
_connection.SetStreamMetadata(stream, ExpectedVersion.EmptyStream, metadataBytes);
var meta = _connection.GetStreamMetadataAsRawBytes(stream);
Assert.AreEqual(stream, meta.Stream);
Assert.AreEqual(false, meta.IsStreamDeleted);
Assert.AreEqual(0, meta.MetastreamVersion);
Assert.AreEqual(metadataBytes, meta.StreamMetadata);
}
public void Write(IEnumerable <Aggregate> affected)
{
foreach (var aggregate in affected)
{
_connection.AppendToStream(
aggregate.Identifier,
aggregate.ExpectedVersion,
aggregate.Root.GetChanges().
Select(_ =>
new EventData(
Guid.NewGuid(),
_.GetType().Name,
true,
ToJsonByteArray(_),
new byte[0])));
}
}
public void Deliver(Message msg)
{
var actorId = msg.ActorId;
var json = _serializer.Serialize(msg);
var data = UTF8Encoding.Default.GetBytes(json);
var meta = BuildMetadataFor(msg);
var evnt = new EventData(msg.Id, msg.GetType().FullName, true, data, meta);
_connection.AppendToStream(actorId + "-input", ExpectedVersion.Any, evnt);
var worker = FindWorker(actorId);
worker.EnqueueKick(actorId);
}
private static void AppendToStream(UserCredentials credentials, IEventStoreConnection connection, UnitOfWork unitOfWork)
{
var affected = unitOfWork.GetChanges().Single();
connection.AppendToStream(
affected.Identifier,
affected.ExpectedVersion,
affected.Root.GetChanges().
Select(_ =>
new EventData(
Guid.NewGuid(),
_.GetType().Name,
true,
ToJsonByteArray(_),
new byte[0])),
credentials);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.Connect();
_eventId0 = Guid.NewGuid();
_eventId1 = Guid.NewGuid();
_conn.AppendToStream("test-stream",
-1,
new EventData(_eventId0, "event0", false, new byte[3], new byte[2]),
new EventData(_eventId1, "event1", false, new byte[7], new byte[10]));
_conn.DeleteStream("deleted-stream", -1);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.Connect();
_eventId0 = Guid.NewGuid();
_eventId1 = Guid.NewGuid();
_conn.AppendToStream("test-stream",
-1,
new EventData(_eventId0, "event0", false, new byte[3], new byte[2]),
new EventData(_eventId1, "event1", false, new byte[7], new byte[10]));
_conn.DeleteStream("deleted-stream", -1, hardDelete: true);
}
public void setting_metadata_for_existing_stream_works()
{
const string stream = "setting_metadata_for_existing_stream_works";
_connection.AppendToStream(stream, ExpectedVersion.EmptyStream, TestEvent.NewTestEvent());
var metadata = StreamMetadata.Create(17, TimeSpan.FromSeconds(0xDEADBEEF), TimeSpan.FromSeconds(0xABACABA));
_connection.SetStreamMetadata(stream, ExpectedVersion.EmptyStream, metadata);
var meta = _connection.GetStreamMetadata(stream);
Assert.AreEqual(stream, meta.Stream);
Assert.AreEqual(false, meta.IsStreamDeleted);
Assert.AreEqual(0, meta.MetastreamVersion);
Assert.AreEqual(metadata.MaxCount, meta.StreamMetadata.MaxCount);
Assert.AreEqual(metadata.MaxAge, meta.StreamMetadata.MaxAge);
Assert.AreEqual(metadata.CacheControl, meta.StreamMetadata.CacheControl);
}
public void Save(IAggregate aggregate, Guid commitId, Action <IDictionary <string, object> > updateHeaders)
{
var commitHeaders = new Dictionary <string, object>
{
{ CommitIdHeader, commitId },
{ AggregateClrTypeHeader, aggregate.GetType().AssemblyQualifiedName }
};
updateHeaders(commitHeaders);
var streamName = _aggregateIdToStreamName(aggregate.GetType(), aggregate.Id);
var newEvents = aggregate.GetUncommittedEvents().Cast <object>().ToList();
var originalVersion = aggregate.Version - newEvents.Count;
var expectedVersion = originalVersion == 0 ? ExpectedVersion.NoStream : originalVersion - 1;
var eventsToSave = newEvents.Select(e => ToEventData(Guid.NewGuid(), e, commitHeaders)).ToList();
if (eventsToSave.Count < WritePageSize)
{
_eventStoreConnection.AppendToStream(streamName, expectedVersion, eventsToSave);
}
else
{
var transaction = _eventStoreConnection.StartTransaction(streamName, expectedVersion);
var position = 0;
while (position < eventsToSave.Count)
{
var pageEvents = eventsToSave.Skip(position).Take(WritePageSize);
transaction.Write(pageEvents);
position += WritePageSize;
}
transaction.Commit();
}
foreach (var newEvent in newEvents)
{
_bus.Publish(newEvent);
}
aggregate.ClearUncommittedEvents();
}
private void PostActivities(CancellationToken token)
{
var users = postAs.Text.Split(',');
var acts = this.activities.Text.Split(',');
var random = new Random();
while (!token.IsCancellationRequested)
{
var user = users[random.Next(0, users.Length - 1)];
var activity = acts[random.Next(0, acts.Length - 1)];
var j = new JObject();
j["type"] = activity;
j["user"] = user;
j["description"] = "some user generated text";
var mentions = new HashSet <string>();
var mentionCount = random.Next(0, users.Length - 2);
while (mentions.Count < mentionCount)
{
mentions.Add(users[random.Next(0, users.Length - 1)]);
}
j["mentions"] = new JArray(mentions.ToArray());
var s = j.ToString(Formatting.None);
var b = Encoding.UTF8.GetBytes(s);
connection.AppendToStream("activities-" + user, ExpectedVersion.Any,
new EventData(Guid.NewGuid(), "ActivityCompleted", true, b, null));
Thread.Sleep(50); //calm stuff down so we can see
}
connection.Close();
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_firstEvent = TestEvent.NewTestEvent();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.Connect();
Assert.AreEqual(2, _connection.AppendToStream("test-stream",
ExpectedVersion.NoStream,
_firstEvent,
TestEvent.NewTestEvent(),
TestEvent.NewTestEvent()).NextExpectedVersion);
using (var transaction = _connection.StartTransaction("test-stream", 2))
{
Assert.AreEqual(2, transaction.Commit().NextExpectedVersion);
}
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_firstEvent = TestEvent.NewTestEvent();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.Connect();
Assert.AreEqual(2, _connection.AppendToStream("test-stream",
ExpectedVersion.NoStream,
_firstEvent,
TestEvent.NewTestEvent(),
TestEvent.NewTestEvent()).NextExpectedVersion);
using (var transaction = _connection.StartTransaction("test-stream", 2))
{
Assert.AreEqual(2, transaction.Commit().NextExpectedVersion);
}
}
public TailWriter Then(EventData @event, int expectedVersion)
{
_store.AppendToStream(_stream, expectedVersion, new[] { @event });
return(this);
}
protected void WriteStream(string streamId, string login, string password)
{
Connection.AppendToStream(streamId, ExpectedVersion.Any, CreateEvents(),
login == null && password == null ? null : new UserCredentials(login, password));
}
public void Enqueue(Message msg, IEventStoreConnection connection, string queue)
{
//todo
var evnt = new EventData(msg.Id, "type", true, null, null);
connection.AppendToStream(queue, ExpectedVersion.Any, evnt);
}
private void Connect()
{
var settings = ConnectionSettings.Create();
var ip = new IPEndPoint(_ipAddress, _port);
Log("Connecting to {0}:{1}...", _ipAddress, _port);
_connection = EventStoreConnection.Create(settings, ip);
_connection.Connect();
_connection.AppendToStream("hello", ExpectedVersion.Any, new EventData(Guid.NewGuid(), "Hello", false, new byte[0], new byte[0]));
Log("Connected.");
Log("Username to be used is: {0}", _userName);
_credentials = new UserCredentials(_userName, _password);
}
public void soft_deleted_stream_returns_no_stream_and_no_events_on_read()
{
const string stream = "soft_deleted_stream_returns_no_stream_and_no_events_on_read";
Assert.AreEqual(1, _conn.AppendToStream(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).NextExpectedVersion);
_conn.DeleteStream(stream, 1);
var res = _conn.ReadStreamEventsForward(stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.StreamNotFound, res.Status);
Assert.AreEqual(0, res.Events.Length);
Assert.AreEqual(1, res.LastEventNumber);
}
public void read_event_respects_truncatebefore()
{
const string stream = "read_event_respects_truncatebefore";
_connection.AppendToStream(stream, ExpectedVersion.EmptyStream, _testEvents);
_connection.SetStreamMetadata(stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetTruncateBefore(2));
var res = _connection.ReadEvent(stream, 1, false);
Assert.AreEqual(EventReadStatus.NotFound, res.Status);
res = _connection.ReadEvent(stream, 2, false);
Assert.AreEqual(EventReadStatus.Success, res.Status);
Assert.AreEqual(_testEvents[2].EventId, res.Event.Value.OriginalEvent.EventId);
}
protected void PostEvent(string stream, string eventType, string data)
{
_conn.AppendToStream(stream, ExpectedVersion.Any, new[] { event_by_type_index.with_existing_events.CreateEvent(eventType, data) });
}
protected void PostEvent(string stream, string eventType, string data)
{
_conn.AppendToStream(stream, ExpectedVersion.Any, new[] { CreateEvent(eventType, data) });
}
void SaveEventsAtOnce(string stream_name, int expected_version,
IEnumerable <Event> events, IEventSerializer serializer)
{
connection_.AppendToStream(stream_name, expected_version,
Serialize(events, serializer));
}
