public async Task Raise(string eventName, object content)
{
await connection.ConnectAsync().ConfigureAwait(false);
var contentJson = JsonConvert.SerializeObject(content);
var metaDataJson =
JsonConvert.SerializeObject(new EventMetadata
{
OccurredAt = DateTimeOffset.Now,
EventName = eventName
});
var eventData = new EventData(
Guid.NewGuid(),
"ShoppingCartEvent",
isJson: true,
data: Encoding.UTF8.GetBytes(contentJson),
metadata: Encoding.UTF8.GetBytes(metaDataJson)
);
await
connection.AppendToStreamAsync(
"ShoppingCart",
ExpectedVersion.Any,
eventData);
}
private Task EnsureConnected()
{
if (_connection != null)
{
return(Task.CompletedTask);
}
_connection = EventStoreConnection.Create(new Uri(_settings.ConnectionString));
_connection.Disconnected += delegate { _connection.ConnectAsync().GetAwaiter().GetResult(); };
return(_connection.ConnectAsync());
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IEventStoreConnection connection)
{
#region Dev
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
#region Swagger
// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger(c => { });
// Enable middleware to serve swagger-ui (HTML, JS, CSS etc.), specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Counter API V1");
});
#endregion
}
#endregion
#region Core2.1
app.UseMvc();
app.UseStatusCodePages();
#endregion
#region Event sourcing
// wait to complete the connection
connection.ConnectAsync().Wait();
#endregion
}
protected override void PreStart()
{
base.PreStart();
_serializerSettings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Simple,
Formatting = Formatting.Indented,
Converters =
{
new ActorRefConverter(Context)
}
};
_connection = new Lazy <Task <IEventStoreConnection> >(async() =>
{
try
{
IEventStoreConnection connection = EventStoreConnection.Create(_extension.EventStoreJournalSettings.ConnectionString, _extension.EventStoreJournalSettings.ConnectionName);
await connection.ConnectAsync();
return(connection);
}
catch (Exception exc)
{
_log.Error(exc.ToString());
return(null);
}
});
}
public EventStoreFacade(string httpUrl, string tcpUrl, string user, string password)
{
if (httpUrl.StartsWith("http://"))
{
throw new InvalidOperationException("Ssl is required to work.");
}
var tcpUri = new Uri(tcpUrl);
ConnectionSettings tcpSettings = ConnectionSettings.Create()
.UseSslConnection(false)
.KeepReconnecting()
.KeepRetrying()
.LimitReconnectionsTo(1000)
.LimitRetriesForOperationTo(100)
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(5))
.SetDefaultUserCredentials(new ApiCredentials(user, password))
.Build();
this._tcp = EventStoreConnection.Create(tcpSettings, tcpUri);
_tcp.ConnectAsync().GetAwaiter().GetResult();
Log.Debug("TCP: Connected.");
var httpSettings = new EventStoreClientSettings();
httpSettings.ConnectivitySettings.Address = new Uri(httpUrl);
DefaultCredentials = new UserCredentials(user, password);
_httpClient = new HttpEventStoreChannel(new EventStoreClient(httpSettings));
_tcpClient = new TcpEventStoreChannel(_tcp);
_client = _tcpClient;
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_supervisor.Initialize();
await _esConnection.ConnectAsync();
_pid = RootContext.Empty.Spawn(_subscriptionManager);
}
static void Main(string[] args)
{
Nodes.ForEach(n => n.Start());
_connection = EventStoreConnection.Create(ConnectionSettings.Default,
ClusterSettings.Create()
.DiscoverClusterViaGossipSeeds()
.SetGossipSeedEndPoints(new[]
{
new IPEndPoint(IPAddress.Loopback, 10004), new IPEndPoint(IPAddress.Loopback, 20004),
new IPEndPoint(IPAddress.Loopback, 30004)
}));
_connection.ConnectAsync().Wait();
Console.WriteLine("Waiting for nodes to start");
Console.WriteLine("CBA to write code for this - Go sort out projections then press enter to begin");
Console.ReadLine();
Node master = GetMaster();
while (!AreProjectionsFuckedYet())
{
master = GetMaster();
master.FuckOff();
Thread.Sleep(15000);
}
Console.WriteLine("Projections f****d!!! (Master is {0}, previously {1})", GetMaster().Name, master.Name);
Console.ReadLine();
Nodes.ForEach(n => n.FuckOff());
}
public async Task Start()
{
_conn.Reconnecting += _conn_Reconnecting;
_conn.Disconnected += _conn_Disconnected;
_conn.Connected += _conn_Connected;
await _conn.ConnectAsync();
}
public override async Task TestFixtureSetUp()
{
try {
await base.TestFixtureSetUp();
} catch (Exception ex) {
throw new Exception("TestFixtureSetUp Failed", ex);
}
try {
_node = new MiniNode <TLogFormat, TStreamId>(PathName);
await _node.Start();
_conn = BuildConnection(_node);
await _conn.ConnectAsync();
} catch (Exception ex) {
throw new Exception("MiniNodeSetUp Failed", ex);
}
try {
await Given().WithTimeout(Timeout);
} catch (Exception ex) {
throw new Exception("Given Failed", ex);
}
try {
await When().WithTimeout(Timeout);
} catch (Exception ex) {
throw new Exception("When Failed", ex);
}
}
public void Connect()
{
connection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113));
connection.ConnectAsync().GetAwaiter().GetResult();
persister = new SagaPersister();
}
public void Establish()
{
s_eventStoreNodeStarted = false;
s_eventStoreClientConnected = false;
var noneIp = new IPEndPoint(IPAddress.None, 0);
s_eventStoreNode = EmbeddedVNodeBuilder
.AsSingleNode()
.RunInMemory()
.WithExternalTcpOn(noneIp)
.WithInternalTcpOn(noneIp)
.WithExternalHttpOn(noneIp)
.WithInternalHttpOn(noneIp)
.Build();
s_eventStoreNode.NodeStatusChanged +=
(sender, e) => { if (e.NewVNodeState == VNodeState.Master)
{
s_eventStoreNodeStarted = true;
}
};
s_eventStoreNode.Start();
s_eventStore = EmbeddedEventStoreConnection.Create(s_eventStoreNode);
s_eventStore.Connected += (sender, e) => { s_eventStoreClientConnected = true; };
s_eventStore.ConnectAsync().Wait();
s_eventStoreMessageStore = new EventStoreMessageStore(s_eventStore);
EnsureEventStoreNodeHasStartedAndTheClientHasConnected();
}
public EventStoreProxy(IComponentContext container)
{
_container = container;
//Ensure we only set up the connection once
lock (CreateConnectionLock)
{
if (_eventStoreConn == null)
{
var connSettings = ConnectionSettings.Create()
.KeepReconnecting()
.KeepRetrying();
//TODO: get config value for address, port and user account
_eventStoreConn = EventStoreConnection.Create(connSettings, new IPEndPoint(IPAddress.Loopback, 1113));
_eventStoreConn.Disconnected += EventStoreConnDisconnected;
_eventStoreConn.ErrorOccurred += EventStoreConnErrorOccurred;
_eventStoreConn.Reconnecting += EventStoreConnReconnecting;
_eventStoreConn.Connected += EventStoreConnConnected;
_eventStoreConn.ConnectAsync().Wait();
SubscribeToStreamComment();
SubscribeToStreamTodo();
}
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
await _connection.ConnectAsync();
_subscription = new EventStoreSubscription(_connection, _projections);
_subscription.Start();
}
public void Connect(string connectionString, string user, string password, string certificateCommonName, bool useSsl = false, int reconnectAttempts = -1, int heartbeatInterval = 30, int heartbeatTimeout = 120)
{
var settings = ConnectionSettings
.Create()
.KeepReconnecting()
.UseConsoleLogger();
_creds = new UserCredentials(user, password);
settings.SetDefaultUserCredentials(new UserCredentials(user, password));
settings.SetHeartbeatInterval(TimeSpan.FromSeconds(heartbeatInterval));
settings.SetHeartbeatTimeout(TimeSpan.FromSeconds(heartbeatTimeout));
if (useSsl && !String.IsNullOrEmpty(certificateCommonName))
{
settings.UseSslConnection(certificateCommonName, true);
}
if (reconnectAttempts > 0)
{
settings.LimitReconnectionsTo(reconnectAttempts);
KeepReconnecting = false;
}
var connectUri = new Uri(connectionString);
_eventStoreConnection = EventStoreConnection.Create(settings, connectUri);
_eventStoreConnection.ConnectAsync().Wait();
}
public EventRepository()
{
var connectionString = "ConnectTo=tcp://user:password@localhost:1113; HeartBeatTimeout=500";
Connection = EventStoreConnection.Create(connectionString);
Connection.ConnectAsync().GetAwaiter().GetResult();
}
public EventStore(ILogger <EventStore> logger, IEventPublisher publisher, IOptions <EventStoreOptions> options)
{
_publisher = publisher;
var assemblyNameFilter = options.Value.EventAssembliesPrefix ?? DefaultEventAssembliesPrefix;
_eventSerializer = new EventSerializer(
new DependencyContextFinder(assemblyNameFilter)); // Preferred since it doesn't require a path but will be incompatible with .NET Standard 2.0
//new RuntimeLoaderFinder(new System.IO.DirectoryInfo(@".\bin\Debug\netcoreapp1.0"), assemblyNameFilter));
try
{
Connection = EventStoreConnection.Create(Settings, new Uri(options.Value.ServerUri ?? DefaultServerUri));
Connection.Disconnected += (s, e) =>
logger.LogError("EventStore Disconnected");
Connection.Reconnecting += (s, e) =>
logger.LogError("EventStore Reconnecting");
Connection.ErrorOccurred += (s, e) =>
logger.LogError("EventStore ErrorOccurred");
Connection.ConnectAsync().Wait();
}
catch (Exception ex)
{
logger.LogError(0, ex, "EventStore Exception");
}
}
public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
_node = CreateMiniNode();
await _node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
await _connection.ConnectAsync();
_lastResponse = null;
_lastResponseBody = null;
_lastResponseBytes = null;
_lastJsonException = null;
try {
await Given().WithTimeout();
} catch (Exception ex) {
throw new Exception("Given Failed", ex);
}
try {
await When().WithTimeout();
} catch (Exception ex) {
throw new Exception("When Failed", ex);
}
}
public PersistentSubcription(ICardRepository cardRepository)
{
_cardRepository = cardRepository;
try
{
ConnectionSettings connectionSettings =
ConnectionSettings.Create()
.SetDefaultUserCredentials(new UserCredentials("admin", "changeit"))
//.EnableVerboseLogging()
.UseConsoleLogger()
.Build();
IPEndPoint ipendpoint = new IPEndPoint(IPAddress.Parse(EVENTSTORE_IP), EVENSTORE_PORT);
_connection = EventStoreConnection.Create(connectionSettings,
ipendpoint, STREAM);
_connection.ConnectAsync().Wait();
}
catch (Exception e)
{
Console.WriteLine($"Error in ReadFromEventStore() ctor: {e.Message}");
throw e;
}
}
public static void SetupEventStore()
{
var tcp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
var http = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2113);
Connection = EventStoreConnection.Create(tcp);
Connection.ConnectAsync().Wait();
var pManager = new ProjectionsManager(new NullLogger(), http, TimeSpan.FromSeconds(5));
var creds = new UserCredentials("admin", "changeit");
bool ready = false;
int retry = 0;
while (!ready)
{
try
{
pManager.EnableAsync("$streams", creds).Wait();
pManager.EnableAsync("$by_event_type", creds).Wait();
pManager.EnableAsync("$by_category", creds).Wait();
pManager.EnableAsync("$stream_by_category", creds).Wait();
ready = true;
}
catch
{
retry++;
if (retry > 8)
{
throw new Exception("EventStore Projection Start Error.");
}
System.Threading.Thread.Sleep(250);
}
}
}
public async Task <bool> Connect()
{
_logger.LogInformation("Attempting connection to EventStore ...");
try
{
ConnectionSettings connectionSettings = ConnectionSettings
.Create()
.SetReconnectionDelayTo(TimeSpan.FromMilliseconds(1000))
.SetHeartbeatTimeout(TimeSpan.FromMilliseconds(500))
.SetDefaultUserCredentials(new UserCredentials("admin", "changeit"))
.EnableVerboseLogging()
.UseConsoleLogger()
.Build();
IPEndPoint ipendpoint = new IPEndPoint(IPAddress.Parse(_configuration["EventStoreSettings:ServerIP"]),
int.Parse(_configuration["EventStoreSettings:Port"]));
connection = EventStoreConnection.Create(connectionSettings,
ipendpoint,
_stream);
await connection.ConnectAsync();
return(true);
}
catch (Exception e)
{
_logger.LogError($"Error in connecting to EventStore ... {e.Message}");
Console.WriteLine($"Error in connecting to EventStore ... {e.Message}");
throw e;
}
}
static void Main(string[] args)
{
using (_conn = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113)))
{
_conn.ConnectAsync().Wait();
var config = ConfigurationFactory.ParseString(@"akka {
actor {
provider = ""Akka.Remote.RemoteActorRefProvider, Akka.Remote""
}
remote {
helios.tcp {
port = 50000 #bound to a static port
hostname = localhost
}
}
}");
var system = ActorSystem.Create("atBatWriter", config); //akka.tcp://localhost:50000@atBatWriter/user
var supervisor = system.ActorOf(AtBatSupervisor.Create(), "supervisor");
Console.ReadLine();
}
}
/// <summary>
/// Mains the specified arguments.
/// </summary>
/// <param name="args">The arguments.</param>
private static async Task Main(String[] args)
{
// This example assumes you have an event store running locally on the default ports with the default username and password
// If your event store connection information is different then update this connection string variable to point to your event store
String connectionString = $"ConnectTo=tcp://admin:changeit@{Program.IpAddress}:1113;VerboseLogging=true;";
// The subscription service requires an open connection to operate so create and open the connection here
IEventStoreConnection eventStoreConnection = EventStoreConnection.Create(connectionString);
await eventStoreConnection.ConnectAsync();
await Program.AddEvents(eventStoreConnection, "Stream1-1", 1000);
await Program.AddEvents(eventStoreConnection, "Stream2-1", 1000);
await Program.StartProjection("TestProjection1");
//await TruncateStreamTcp(eventStoreConnection, "$ce-Stream1", 100); //works
//await TruncateStreamTcp(eventStoreConnection, "$ce-Stream1", 101); //works
// await Program.TruncateStreamTcp(eventStoreConnection, "$ce-Stream1", 110); //works
//Both tcp and http truncate fails from 111
await Program.TruncateStreamTcp(eventStoreConnection, "$ce-Stream1", 111); //fails
// await TruncateStreamHttp("$ce-Stream1", 111); //http truncate also fails
//This projection no longer works (all stream position at -1)
await Program.ResetProjection("TestProjection1");
//This new projection does not work (all stream position at -1)
await Program.StartProjection("TestProjection2");
Console.ReadKey();
}
static void Main(string[] args)
{
var system = ActorSystem.Create("playerComposition");
var searcher = system.ActorOf(PlayerSearchSupervisor.Create(), "supervisor");
// akka://playerCOmposition/user/supervisor
using (_conn = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113)))
{
_conn.ConnectAsync().Wait();
Console.WriteLine("Player ID: ");
var playerId = Console.ReadLine();
for (int balls = 0; balls < 4; balls++)
{
for (int strikes = 0; strikes < 3; strikes++)
{
var count = $"{balls}{strikes}";
searcher.Tell(new FindPlayerAndCount(playerId, count));
}
}
Console.ReadLine();
}
}
public EventStoreJournal()
{
_serializerSettings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Objects,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Simple,
Formatting = Formatting.Indented,
Converters =
{
new ActorRefConverter(Context)
}
};
_connection = new Lazy <Task <IEventStoreConnection> >(async() =>
{
var settings = ConnectionSettings.Create()
.UseConsoleLogger()
.SetDefaultUserCredentials(new UserCredentials("admin", "changeit"));
var endPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
IEventStoreConnection connection = EventStoreConnection.Create(settings, endPoint, "akka.net-journal");
await connection.ConnectAsync();
return(connection);
});
}
public EventStoreService(IConfiguration configuration)
{
_connection = EventStoreConnection.Create(
configuration.GetConnectionString("EventStoreConnection"));
_connection.ConnectAsync();
}
public void OneTimeSetUp()
{
_conn = BuildConnection();
_conn.ConnectAsync().Wait();
Given();
When();
}
public override async Task SetUp()
{
await base.SetUp();
_node = new MiniNode <TLogFormat, TStreamId>(PathName);
await _node.Start();
_conn = BuildConnection(_node);
await _conn.ConnectAsync();
await _conn.SetStreamMetadataAsync("$all", -1,
StreamMetadata.Build().SetReadRole(SystemRoles.All),
new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword));
_testEvents = Enumerable
.Range(0, 5)
.Select(x => TestEvent.NewTestEvent(x.ToString(), eventName: "AEvent"))
.ToList();
_testEvents.AddRange(
Enumerable
.Range(0, 5)
.Select(x => TestEvent.NewTestEvent(x.ToString(), eventName: "BEvent")).ToList());
_fakeSystemEvents = Enumerable
.Range(0, 5)
.Select(x => TestEvent.NewTestEvent(x.ToString(), eventName: "$systemEvent"))
.ToList();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IHostApplicationLifetime appLifeTime, IEventStoreConnection connection)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
connection.ConnectAsync().Wait();
connection.Disconnected += (sender, args) => appLifeTime.StopApplication();
app.UseRouting();
app.UseSwagger();
app.UseSwaggerUI(c => //Swagger UI should be served from static container not service
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});
//app.UseAuthorization(); // maybe done by gateway
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
_credentials = new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword);
_timeout = TimeSpan.FromSeconds(20);
// Check if a node is running in ProjectionsManagerTestSuiteMarkerBase
_tag = "_1";
_node = CreateNode();
await _node.Start().WithTimeout(_timeout);
await _systemProjectionsCreated.WithTimeout(_timeout);
_connection = TestConnection.Create(_node.TcpEndPoint);
await _connection.ConnectAsync();
_projManager = new ProjectionsManager(new ConsoleLogger(), _node.ExtHttpEndPoint, _timeout, _node.HttpMessageHandler);
try {
await Given().WithTimeout(_timeout);
} catch (Exception ex) {
throw new Exception("Given Failed", ex);
}
try {
await When().WithTimeout(_timeout);
} catch (Exception ex) {
throw new Exception("When Failed", ex);
}
}
static async Task Main(string[] args)
{
_stateDbContext = new StateDbContext();
await _stateDbContext.Database.EnsureCreatedAsync();
_subscriptionConnection = EventStoreConnectionFactory.Create(
new EventStoreSingleNodeConfiguration(),
new ConsoleLogger(),
"admin", "changeit");
_writeConnection = EventStoreConnectionFactory.Create(
new EventStoreSingleNodeConfiguration(),
new ConsoleLogger(),
"admin", "changeit");
await _subscriptionConnection.ConnectAsync();
await _writeConnection.ConnectAsync();
_eventStore = new Bank.Persistence.EventStore.EventStore(_writeConnection, new List <IEventSchema>
{
new InvoiceSchema()
});
_repository = new InvoiceRepository(_eventStore);
//await StartMultipleSubscriptions();
await StartCategoryGeneration();
Console.ReadLine();
}
public async Task TheExampleCanRun()
{
await _eventStoreConnection.ConnectAsync();
await WriteBytesToStream("test-stream", "testEvent", "some data");
var streamEvents = await
_eventStoreConnection.ReadStreamEventsBackwardAsync("test-stream", StreamPosition.End, 1, false);
var returnedEvent = streamEvents.Events[0].Event;
var returnedData = Encoding.UTF8.GetString(returnedEvent.Data);
var returnedMetaData = Encoding.UTF8.GetString(returnedEvent.Metadata);
Assert.Equal("some data", returnedData);
Assert.Equal("some metadata", returnedMetaData);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env,
IEventStoreConnection conn, IRepository <Product> productRepository,
IRepository <Customer> customerRepository, MongoClient mongoClient)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Carts}/{action=IndexAsync}/{id?}");
});
conn.ConnectAsync().Wait();
if (!productRepository.FindAllAsync(x => true).Result.Any() &&
!customerRepository.FindAllAsync(x => true).Result.Any())
{
SeedReadModel(productRepository, customerRepository);
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.ConnectAsync().Wait();
When();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = BuildConnection(_node);
_connection.ConnectAsync().Wait();
}
public DispatcherBase(IMongoRepository mongoRepository, IGESConnection gesConnection, List<IHandler> eventHandlers)
{
_mongoRepository = mongoRepository;
_gesConnection = gesConnection.BuildConnection();
_gesConnection.ConnectAsync();
_eventHandlers = eventHandlers;
// add all handlers to the broadcast block so they receive news of events
RegisterHandlers();
// gets last event processed to avoid re processing events after a shut down.
GetLastEventProcessedForHandlers();
}
public async Task<IEventStoreConnection> GetConnectionAsync() {
if (Connection != null) return Connection;
lock (BlockAllOtherThreads) {
Connection = Factory.ConstructConnection();
}
Connection.Closed += OnClosed;
await Connection.ConnectAsync().ConfigureAwait(false);
return Connection;
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_HttpEndPoint = _node.HttpEndPoint;
_conn = BuildConnection(_node);
_conn.ConnectAsync().Wait();
Given();
When();
}
public void SetUp()
{
var typeName = GetType().Name.Length > 30 ? GetType().Name.Substring(0, 30) : GetType().Name;
PathName = Path.Combine(Path.GetTempPath(), string.Format("{0}-{1}", Guid.NewGuid(), typeName));
Directory.CreateDirectory(PathName);
Counter = 0;
CreateNode();
Connection = TestConnection.Create(Node.TcpEndPoint);
Connection.ConnectAsync().Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_credentials = new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword);
var createdMiniNode = false;
_timeout = TimeSpan.FromSeconds(10);
// Check if a node is running in ProjectionsManagerTestSuiteMarkerBase
if (SetUpFixture.Connection != null && SetUpFixture.Node != null)
{
_tag = "_" + (++SetUpFixture.Counter);
_node = SetUpFixture.Node;
_connection = SetUpFixture.Connection;
}
else
{
createdMiniNode = true;
_tag = "_1";
_node = CreateNode();
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
}
try
{
_projManager = new ProjectionsManager(new ConsoleLogger(), _node.ExtHttpEndPoint, _timeout);
Given();
When();
}
catch
{
if (createdMiniNode)
{
if (_connection != null)
{
try {
_connection.Close();
} catch {
}
}
if (_node != null)
{
try {
_node.Shutdown();
} catch {
}
}
}
throw;
}
}
public void SetUp()
{
WebRequest.DefaultWebProxy = new WebProxy();
_counter = 0;
_directory = new SpecificationWithDirectoryPerTestFixture();
_directory.TestFixtureSetUp();
_node = new MiniNode(_directory.PathName, skipInitializeStandardUsersCheck: false, enableTrustedAuth: true);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
}
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.ConnectAsync();
_connection.AppendToStreamAsync("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 override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName, skipInitializeStandardUsersCheck: false);
_node.Start();
_conn = TestConnection.Create(_node.TcpEndPoint);
_conn.ConnectAsync().Wait();
_conn.SetStreamMetadataAsync("$all", -1,
StreamMetadata.Build().SetReadRole(SystemRoles.All),
new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword)).Wait();
}
public void Start()
{
HasLoaded = false;
_connection = EventStore.ClientAPI.EventStoreConnection.Create(_endpoint);
var ct = _connection.ConnectAsync();
ct.Wait();
_checkPoint = Position.Start;
if (string.IsNullOrEmpty(_streamName))
_subscription = _connection.SubscribeToAllFrom(_checkPoint, false, EventAppeared, Live, SubscriptionDropped, _credentials);
else
_subscription = _connection.SubscribeToStreamFrom(_streamName, _lastEventNumber, true, EventAppeared, Live, SubscriptionDropped, _credentials);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
#if (!DEBUG)
throw new NotSupportedException("These tests require DEBUG conditional");
#else
QueueStatsCollector.InitializeIdleDetection();
_nodeEndpoints[0] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodeEndpoints[1] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
_nodeEndpoints[2] = new Endpoints(
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback),
PortsHelper.GetAvailablePort(IPAddress.Loopback), PortsHelper.GetAvailablePort(IPAddress.Loopback));
PortsHelper.GetAvailablePort(IPAddress.Loopback);
_nodes[0] = CreateNode(0,
_nodeEndpoints[0], new IPEndPoint[] {_nodeEndpoints[1].InternalHttp, _nodeEndpoints[2].InternalHttp});
_nodes[1] = CreateNode(1,
_nodeEndpoints[1], new IPEndPoint[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[2].InternalHttp });
_nodes[2] = CreateNode(2,
_nodeEndpoints[2], new IPEndPoint[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[1].InternalHttp });
_nodes[0].Start();
_nodes[1].Start();
_nodes[2].Start();
WaitHandle.WaitAll(new[] { _nodes[0].StartedEvent, _nodes[1].StartedEvent, _nodes[2].StartedEvent });
QueueStatsCollector.WaitIdle(waitForNonEmptyTf: true);
_conn = EventStoreConnection.Create(_nodes[0].ExternalTcpEndPoint);
_conn.ConnectAsync().Wait();
_manager = new ProjectionsManager(
new ConsoleLogger(),
_nodes[0].ExternalHttpEndPoint,
TimeSpan.FromMilliseconds(10000));
if (GivenStandardProjectionsRunning())
EnableStandardProjections();
QueueStatsCollector.WaitIdle();
Given();
When();
#endif
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
_connection.SetStreamMetadataAsync(Stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetMaxCount(3)).Wait();
_testEvents = Enumerable.Range(0, 5).Select(x => TestEvent.NewTestEvent(data: x.ToString())).ToArray();
_connection.AppendToStreamAsync(Stream, ExpectedVersion.EmptyStream, _testEvents).Wait();
}
public static Task ConnectAsync(string ip, int port, string user, string password)
{
credentials = new UserCredentials(user, password);
connection = EventStoreConnection.Create(
ConnectionSettings.Create()
.SetDefaultUserCredentials(credentials)
.UseConsoleLogger()
.UseDebugLogger()
.KeepReconnecting()
.FailOnNoServerResponse()
.KeepRetrying(),
new IPEndPoint(IPAddress.Loopback, 1113));
return connection.ConnectAsync();
}
protected override void Given()
{
_serverEndPoint = new IPEndPoint(IPAddress.Loopback, PortsHelper.GetAvailablePort(IPAddress.Loopback));
_url = _HttpEndPoint.ToHttpUrl("/stats/tcp");
var settings = ConnectionSettings.Create();
_connection = EventStoreConnection.Create(settings, _node.TcpEndPoint);
_connection.ConnectAsync().Wait();
var testEvent = new EventData(Guid.NewGuid(),"TestEvent",true,Encoding.ASCII.GetBytes("{'Test' : 'OneTwoThree'}"),null);
_connection.AppendToStreamAsync("tests",ExpectedVersion.Any,testEvent).Wait();
_portableServer = new PortableServer(_serverEndPoint);
_portableServer.SetUp();
}
public void Start()
{
//uncommet to enable verbose logging in client.
var settings = ConnectionSettings.Create(); //.EnableVerboseLogging().UseConsoleLogger();
using (_conn = EventStoreConnection.Create(settings, new IPEndPoint(IPAddress.Loopback, DEFAULTPORT)))
{
_conn.ConnectAsync().Wait();
CreateSubscription();
ConnectToSubscription();
Console.WriteLine("waiting for events. press enter to exit");
Console.ReadLine();
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, inMemDb: true);
_node.Start();
_conn = BuildConnection(_node);
_conn.ConnectAsync().Wait();
//Create 80000 events
for(var i = 0; i < 80; i++)
{
_conn.AppendToStreamAsync(_streamName, ExpectedVersion.Any, CreateThousandEvents()).Wait();
}
_settings = new CatchUpSubscriptionSettings(100, 1, false, true);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
#if (!DEBUG)
Assert.Ignore("These tests require DEBUG conditional");
#else
QueueStatsCollector.InitializeIdleDetection();
CreateNode();
try
{
_conn = EventStoreConnection.Create(_node.TcpEndPoint);
_conn.ConnectAsync().Wait();
_manager = new ProjectionsManager(
new ConsoleLogger(),
_node.HttpEndPoint,
TimeSpan.FromMilliseconds(10000));
WaitIdle();
if (GivenStandardProjectionsRunning())
EnableStandardProjections();
QueueStatsCollector.WaitIdle();
Given();
When();
}
catch
{
try
{
if (_conn != null)
_conn.Close();
}
catch
{
}
try
{
if (_node != null)
_node.Shutdown();
}
catch
{
}
throw;
}
#endif
}
public override void SetUp()
{
base.SetUp();
_node = new MiniNode(PathName);
_node.Start();
_firstEvent = TestEvent.NewTestEvent();
_connection = TestConnection.Create(_node.TcpEndPoint);
_connection.ConnectAsync().Wait();
Assert.AreEqual(2, _connection.AppendToStreamAsync("test-stream",
ExpectedVersion.NoStream,
_firstEvent,
TestEvent.NewTestEvent(),
TestEvent.NewTestEvent()).Result.NextExpectedVersion);
using (var transaction = _connection.StartTransactionAsync("test-stream", 2).Result)
{
Assert.AreEqual(2, transaction.Commit().NextExpectedVersion);
}
}
//TODO: Need restore point configuration
private static void Start(ProjectionGatewayConfiguration projectionGatewayConfiguration, IEventStoreConnection eventStoreConnection)
{
projectionGatewayConfiguration.Locator.Register(() => eventStoreConnection);
eventStoreConnection.ConnectAsync().Wait();
foreach (var subscription in projectionGatewayConfiguration.Subscriptions)
{
var eventHandlers = subscription.Value;
eventStoreConnection.SubscribeToStreamFrom(
stream: subscription.Key + "View",
lastCheckpoint: StreamCheckpoint.StreamStart,
resolveLinkTos: true,
eventAppeared: (upSubscription, @event) =>
{
var eventType = Type.GetType(@event.Event.EventType);
var deserializedEvent = JsonConvert.DeserializeObject(Encoding.UTF8.GetString(@event.Event.Data), eventType);
eventHandlers
.Single(x => x.EventType == eventType)
.EventHandler(deserializedEvent);
});
}
}
public MessageBinderBase(IEventStoreConnection eventStoreConnection)
{
_eventStoreConnection = eventStoreConnection;
_eventStoreConnection.ConnectAsync();
}
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);
}
public static void SetupEventStore(StartConflictOption opt = StartConflictOption.Connect)
{
//TODO: Convert to Embedded when I can figure out loading the miniWeb component
var runningEventStores = Process.GetProcessesByName("EventStore.ClusterNode");
if (runningEventStores.Length != 0)
{
switch (opt)
{
case StartConflictOption.Connect:
_process = runningEventStores[0];
break;
case StartConflictOption.Kill:
foreach (var es in runningEventStores)
{
es.Kill();
}
break;
case StartConflictOption.Error:
throw new Exception("Conflicting EventStore running.");
default:
throw new ArgumentOutOfRangeException(nameof(opt), opt, null);
}
}
if (_process == null)
{
_process = new Process
{
StartInfo =
{
UseShellExecute = false, CreateNoWindow = true, FileName = Path, Arguments = Args, Verb = "runas"
}
};
_process.Start();
}
var tcp = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
var http = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2113);
Connection = EventStoreConnection.Create(tcp);
Connection.ConnectAsync().Wait();
var pManager = new ProjectionsManager(new NullLogger(), http, TimeSpan.FromSeconds(5));
var creds = new UserCredentials("admin", "changeit");
bool ready = false;
int retry = 0;
while (!ready)
{
try
{
pManager.EnableAsync("$streams", creds).Wait();
pManager.EnableAsync("$by_event_type", creds).Wait();
pManager.EnableAsync("$by_category", creds).Wait();
pManager.EnableAsync("$stream_by_category", creds).Wait();
ready = true;
}
catch
{
retry++;
if (retry > 8)
throw new Exception("EventStore Projection Start Error.");
System.Threading.Thread.Sleep(250);
}
}
}
