public static void List(ProjectionsManager manager, string[] commandArgs)
{
if (commandArgs.Length != 1 && commandArgs.Length != 3)
{
Log("Invalid argument value for list mode");
return;
}
var userCredentials = commandArgs.Length == 3 ? new UserCredentials(commandArgs[1], commandArgs[2]) : null;
var mode = commandArgs[0].Trim().ToLower();
switch (mode)
{
case "all":
Log("Listing all projections...");
LogUnformatted(manager.ListAllAsync(userCredentials).Result);
Log("All projections listed");
break;
case "onetime":
Log("Listing onetime projections...");
LogUnformatted(manager.ListOneTimeAsync(userCredentials).Result);
Log("Onetime projections listed");
break;
case "continuous":
Log("Listing continuous projections...");
LogUnformatted(manager.ListContinuousAsync(userCredentials).Result);
Log("Continuous projections listed");
break;
default:
Log("List mode not recognized");
break;
}
}
public static void Disable(ProjectionsManager manager, string[] commandArgs)
{
var nameAndCredentials = GetProjectionNameAndCredentials(commandArgs);
var name = nameAndCredentials.Item1;
Log("Disabling {0}...", nameAndCredentials.Item1);
manager.DisableAsync(name, nameAndCredentials.Item2).Wait();
Log("{0} disabled", name);
}
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 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.IntHttpEndPoint,
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 void Should_throw_if_http_error()
{
var projectionName = Guid.NewGuid().ToString();
var projectionContent = Guid.NewGuid().ToString();
var response = new HttpResponse(HttpStatusCode.InternalServerError, String.Empty, String.Empty);
var httpClient = new FakeHttpClient(u => response, (u, d) => response, (u, d) => response);
var counter = new CountdownEvent(1);
httpClient.SetCounter(counter);
var manager = new ProjectionsManager(EventStoreAddress, httpClient);
manager.GetConfigAsync(projectionName);
Assert.IsTrue(counter.Wait(3000));
}
private static bool TryExecute(Dictionary<string, string> config, string[] args)
{
try
{
Log("Loading config values...");
var ip = IPAddress.Parse(config["ip"]);
var port = int.Parse(config["http-port"]);
var endPoint = new IPEndPoint(ip, port);
var manager = new ProjectionsManager(new ConsoleLogger(), endPoint, TimeSpan.FromMilliseconds(5000));
Execute(manager, args);
return true;
}
catch (Exception e)
{
Log("padmin execution failed : {0}", e);
return false;
}
}
public void Should_update_existing_projection()
{
var projectionName = Guid.NewGuid().ToString();
var projectionContent = Guid.NewGuid().ToString();
var httpClient = new FakeHttpClient(u => new HttpResponse(HttpStatusCode.OK, String.Empty, String.Empty), null, null);
var manager = new ProjectionsManager(EventStoreAddress, httpClient);
var counter = new CountdownEvent(1);
httpClient.SetCounter(counter);
manager.UpdateProjectionQueryAsync(projectionName, projectionContent);
Assert.IsTrue(counter.Wait(3000));
CollectionAssert.IsEmpty(httpClient.PostRequests);
CollectionAssert.IsEmpty(httpClient.GetRequests);
CollectionAssert.IsNotEmpty(httpClient.PutRequests);
StringAssert.Contains(projectionName, httpClient.PutRequests[0].Url);
}
public static void Create(ProjectionsManager manager, string[] commandArgs)
{
if (commandArgs.Length < 2)
{
Log("Invalid argument value (projection type)");
return;
}
var type = commandArgs[0].Trim().ToLower();
var queryInfo = GetQueryAndCredentials(commandArgs.Skip(1).ToArray());
if (queryInfo == null || (type != "onetime" && string.IsNullOrEmpty(queryInfo.Item1)))
{
Log("Invalid arguments");
return;
}
var pname = queryInfo.Item1;
var query = queryInfo.Item2;
var userCredentials = queryInfo.Item3;
switch (type)
{
case "onetime":
Log("Creating onetime projection...");
manager.CreateOneTimeAsync(query, userCredentials).Wait();
Log("Created");
break;
case "continuous":
Log("Creating continuous projection {0}...", pname);
manager.CreateContinuousAsync(pname, query, userCredentials).Wait();
Log("Created");
break;
default:
Log("projection type not recognized");
break;
}
}
public JSProjectionsFactory(ILogger <LoggerWrapper> logger)
{
Projections = new Dictionary <string, string>();
ProjectionManager = new ProjectionsManager(new LoggerWrapper(logger), ESConnectionConfig.HttpEndpoint, TimeSpan.FromSeconds(10));
}
static void Main(string[] args)
{
string eventStoreHost = "asadoDev.internal.noesislabs.com";
string eventStoreUsername = "******";
string eventStorePassword = "******";
int eventStoreTcpPort = 1113;
int eventStoreHttpPort = 2113;
var addresses = Dns.GetHostAddressesAsync(eventStoreHost).Result;
var projectionManager = new ProjectionsManager(new ConsoleLogger(), new IPEndPoint(addresses.First(), eventStoreHttpPort), TimeSpan.FromSeconds(5));
var testProjectionQuery = String.Format(@"
fromAll()
.when({{
DummyEventA: function(s, e) {{
linkTo('{0}', e);
}},
DummyEventB: function(s, e) {{
linkTo('{0}', e);
}}
}});
", PROJECTION_DEST_STREAM_NAME);
projectionManager.CreateContinuousAsync(TEST_PROJECTION_NAME, testProjectionQuery, new UserCredentials(eventStoreUsername, eventStorePassword)).Wait();
Thread.Sleep(3000);
var connectionSettings = ConnectionSettings.Create()
.SetReconnectionDelayTo(TimeSpan.FromSeconds(1))
.KeepReconnecting();
var uriBuilder = new UriBuilder
{
Scheme = "tcp",
UserName = eventStoreUsername,
Password = eventStorePassword,
Host = eventStoreHost,
Port = eventStoreTcpPort
};
var eventStoreConnection = EventStoreConnection.Create(connectionSettings, uriBuilder.Uri);
eventStoreConnection.ConnectAsync().Wait();
List <object> events = new List <object>
{
new DummyEventA(Guid.NewGuid()),
new DummyEventA(Guid.NewGuid()),
new DummyEventA(Guid.NewGuid()),
new DummyEventA(Guid.NewGuid()),
new DummyEventA(Guid.NewGuid()),
new DummyEventB(Guid.NewGuid()),
new DummyEventB(Guid.NewGuid()),
new DummyEventB(Guid.NewGuid()),
new DummyEventB(Guid.NewGuid()),
new DummyEventB(Guid.NewGuid())
};
int expectedVersion = -1;
foreach (var e in events)
{
var eventData = ToEventData(Guid.NewGuid(), e, new Dictionary <string, string>());
var result = eventStoreConnection.AppendToStreamAsync(PROJECTION_SOURCE_STREAM_NAME, expectedVersion, new EventData[] { eventData }).Result;
expectedVersion = result.NextExpectedVersion;
}
}
public static void UpdateQuery(ProjectionsManager manager, string[] commandArgs)
{
var queryInfo = GetQueryAndCredentials(commandArgs);
if (queryInfo == null)
{
Log("Invalid arguments for command update query");
return;
}
var pname = queryInfo.Item1;
var query = queryInfo.Item2;
var userCredentials = queryInfo.Item3;
Log("Updating query of {0}...", pname);
manager.UpdateQueryAsync(pname, query, userCredentials).Wait();
Log("Query updated");
}
public static void Delete(ProjectionsManager manager, string[] commandArgs)
{
var nameAndCredentials = GetProjectionNameAndCredentials(commandArgs);
if (nameAndCredentials == null)
{
Log("Invalid arguments, should be: <projection-name> [<login> <password>].");
return;
}
var name = nameAndCredentials.Item1;
Log("Deleting {0}...", name);
manager.DeleteAsync(name, nameAndCredentials.Item2).Wait();
Log("{0} deleted", name);
}
private static void Execute(ProjectionsManager manager, string[] args)
{
var command = args[0].Trim().ToLower();
var commandArgs = args.Skip(1).ToArray();
Action<ProjectionsManager, string[]> executor;
if(Commands.TryGetValue(command, out executor))
executor(manager, commandArgs);
else
Log("{0} is not a recognized command", args[0]);
}
public DefaultProjectionsManager(ProjectionsManager projectionsManager, UserCredentials userCredentials)
{
this.projectionsManager = projectionsManager;
this.userCredentials = userCredentials;
}
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.ExtHttpEndPoint,
TimeSpan.FromMilliseconds(10000));
_queryManager = new QueryManager(
new ConsoleLogger(),
_node.ExtHttpEndPoint,
TimeSpan.FromMilliseconds(10000),
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 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 static async Task <string> CreateProjectionAsync(this IEventStoreConnection connection, ProjectionsManager projectionsManager, string prefix, string streamFilter = null)
{
streamFilter = streamFilter ?? ".*";
var streamName = ParseFilter(prefix, streamFilter);
if (SubscriptionsCreated.TryAdd(streamName, true))
{
var projectionConfig =
$@"fromAll()
.when({{
$any: function (s, e) {{
if (e.streamId.indexOf('{prefix}') === 0 && /{streamFilter}/.test(e.streamId.substring({prefix.Length + 1}))) {{
linkTo('{streamName}', e);
}}
}}
}});";
try
{
var credentials = connection.Settings.DefaultUserCredentials;
await projectionsManager.CreateContinuousAsync($"${streamName}", projectionConfig, credentials);
}
catch (Exception ex)
{
if (!ex.Is <ProjectionCommandConflictException>())
{
throw;
}
}
}
return(streamName);
}
public void It_can_receive_subscribed_messages()
{
var publisher1Address = new Address("pub1", "node1");
var publisher2Address = new Address("pub2", "node1");
var projectionsManager = new ProjectionsManager(new NoopLogger(), HttpEndPoint);
projectionsManager.Enable("$by_category", AdminCredentials);
var sinkProjectionCreator = new ReceiverSinkProjectionCreator
{
ConnectionManager = new DefaultConnectionManager(ConnectionConfiguration)
};
sinkProjectionCreator.RegisterProjectionsFor(ReceiverAddress, "");
var transactionalModeRouterProjectionCreator = new TransactionalModeRouterProjectionCreator()
{
ConnectionManager = new DefaultConnectionManager(ConnectionConfiguration)
};
transactionalModeRouterProjectionCreator.RegisterProjectionsFor(publisher1Address, "");
transactionalModeRouterProjectionCreator.RegisterProjectionsFor(publisher2Address, "");
var subscriptionManager = new SubscriptionManager(new DefaultConnectionManager(ConnectionConfiguration))
{
EndpointAddress = ReceiverAddress
};
var publisher1 = CreatePublisher(publisher1Address);
var publisher2 = CreatePublisher(publisher2Address);
subscriptionManager.Subscribe(typeof(EventA), publisher1.EndpointAddress);
PublishMessages(publisher1, 1, typeof(EventA));
if (!ExpectReceive(1, TimeSpan.FromSeconds(5)))
{
Assert.Fail("Received {0} messages out of 1", Count);
}
subscriptionManager.Subscribe(typeof(EventB), publisher2.EndpointAddress);
PublishMessages(publisher2, 1, typeof(EventB));
if (!ExpectReceive(1, TimeSpan.FromSeconds(5)))
{
Assert.Fail("Received {0} messages out of 1", Count);
}
subscriptionManager.Subscribe(typeof(EventC), publisher2.EndpointAddress);
PublishMessages(publisher2, 1, typeof(EventC));
if (!ExpectReceive(1, TimeSpan.FromSeconds(5)))
{
Assert.Fail("Received {0} messages out of 1", Count);
}
subscriptionManager.Unsubscribe(typeof(EventC), publisher2.EndpointAddress);
PublishMessages(publisher2, 1, typeof(EventB));
PublishMessages(publisher2, 1, typeof(EventC));
if (!ExpectReceive(1, TimeSpan.FromSeconds(5)))
{
Assert.Fail("Received {0} messages out of 1", Count);
}
}
public async Task <List <Account> > GetAllAccounts(GetAllAccountsQuery query, CancellationToken cancellationToken)
{
var conn = await Connect();
List <Account> _accounts = new List <Account>();
ProjectionsManager pm = new ProjectionsManager(new ConsoleLogger(), new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2113), TimeSpan.FromMilliseconds(5000));
CreateProjection(pm);
var streams = await pm.GetStateAsync("getAllStreams", _adminCredentials);
var streamNames = JsonConvert.DeserializeObject <Streams>(streams);
foreach (var streamName in streamNames.StreamNames)
{
Account _account = new Account(AccountId.With(streamName));
var streamEvents = conn.ReadStreamEventsForwardAsync(streamName, 0, 100, true, _adminCredentials).Result;
foreach (var evt in streamEvents.Events)
{
var json = Encoding.UTF8.GetString(evt.Event.Data);
var account = JsonConvert.DeserializeObject <AccountReadModel>(json);
if (!string.IsNullOrEmpty(account.HolderName))
{
_account.HolderName = account.HolderName;
_account.Balance = account.Balance;
}
if (!string.IsNullOrEmpty(account.AccountState))
{
_account.AccountState = account.AccountState;
}
if (!account.Amount.Equals(default(float)))
{
if (evt.Event.EventType.ToLower().Contains("withdraw"))
{
_account.Balance -= account.Amount;
}
if (evt.Event.EventType.ToLower().Contains("deposit"))
{
if (evt.Event.EventType.ToLower().Contains("cash"))
{
_account.Balance += account.Amount;
}
if (evt.Event.EventType.ToLower().Contains("check"))
{
var date = evt.Event.Created;
var depositDate = date.AddDays(1);
while (!(depositDate.DayOfWeek >= DayOfWeek.Monday && depositDate.DayOfWeek <= DayOfWeek.Friday))
{
depositDate = depositDate.AddDays(1);
}
if (DateTime.UtcNow.Date >= depositDate.Date)
{
_account.Balance += account.Amount;
}
}
}
}
if (!account.DailyWireTransferLimit.Equals(default(float)))
{
_account.DailyWireTransferLimit = account.DailyWireTransferLimit;
}
if (!account.OverDraftLimit.Equals(default(float)))
{
_account.OverDraftLimit = account.OverDraftLimit;
}
}
_accounts.Add(_account);
}
conn.Close();
return(_accounts);
}
static void Main(string[] args)
{
var es = "localhost:1113";
if (args.Length > 0)
{
es = args[0];
}
var uri = new Uri($"tcp://{es}");
var conn = EventStoreConnection.Create(GetConnectionBuilder(), uri, "es-test-app");
var projectionsManager = new ProjectionsManager(new TestLogger(), new IPEndPoint(IPAddress.Loopback, 2113),
TimeSpan.FromSeconds(5));
var projectionName = "ProjectionTest";
var projectionMultistreamName = "ProjectionMultistreamTest";
var streamName = StreamName;
var stream2Name = "domainTest2Stream";
try
{
conn.Reconnecting += Conn_Reconnecting;
conn.ErrorOccurred += Conn_ErrorOccurred;
conn.ConnectAsync();
do
{
Console.Clear();
Console.WriteLine($"Connected to {uri}");
Console.WriteLine($"Press P to create projection {projectionName} ({streamName})");
Console.WriteLine($"Press M to create Multi Streams projection {projectionMultistreamName} ({streamName}, {stream2Name})");
Console.WriteLine($"Press S to send 1000 events to stream {streamName}");
Console.WriteLine($"Press X to send 1000 events to stream {stream2Name}");
Console.WriteLine($"Press O to send 1 event to stream {streamName}");
Console.WriteLine($"Press D to Disable projection {projectionName}");
Console.WriteLine($"Press F to Disable Multi Streams projection {projectionMultistreamName}");
Console.WriteLine($"Press E to Enable projection {projectionName}");
Console.WriteLine($"Press R to Enable Multi Streams projection {projectionMultistreamName}");
Console.WriteLine($"Press A to set $maxAge=2 to streams {streamName}, {stream2Name}");
Console.WriteLine($"Press C to set $maxCount=2 to streams {streamName}, {stream2Name}");
var key = Console.ReadKey();
if (key.Key == ConsoleKey.O || key.Key == ConsoleKey.NumPad0)
{
AppendToStreamAsync(conn, streamName, 1);
}
if (key.Key == ConsoleKey.S)
{
AppendToStreamAsync(conn, streamName, 1000);
}
if (key.Key == ConsoleKey.X)
{
AppendToStreamAsync(conn, stream2Name, 1000);
}
if (key.Key == ConsoleKey.P)
{
projectionsManager.CreateContinuousAsync(projectionName,
$"fromStream('{streamName}').when({{'$any': function(state, evnt) {{linkTo('OurTargetStreamName', evnt); }}}});",
new UserCredentials("admin", "changeit"));
}
if (key.Key == ConsoleKey.M)
{
projectionsManager.CreateContinuousAsync(projectionMultistreamName,
$"fromStreams('{streamName}', '{stream2Name}').when({{'$any': function(state, evnt) {{linkTo('OurTargetStreamName', evnt); }}}});",
new UserCredentials("admin", "changeit"));
}
if (key.Key == ConsoleKey.D)
{
projectionsManager.DisableAsync(projectionName, new UserCredentials("admin", "changeit")).Wait();
}
if (key.Key == ConsoleKey.F)
{
projectionsManager.DisableAsync(projectionMultistreamName, new UserCredentials("admin", "changeit")).Wait();
}
if (key.Key == ConsoleKey.E)
{
projectionsManager.EnableAsync(projectionName, new UserCredentials("admin", "changeit")).Wait();
}
if (key.Key == ConsoleKey.R)
{
projectionsManager.EnableAsync(projectionMultistreamName, new UserCredentials("admin", "changeit")).Wait();
}
if (key.Key == ConsoleKey.A)
{
SetStreamMetadata(conn, streamName, new Dictionary <string, int> {
{ "$maxAge", 2 }
});
SetStreamMetadata(conn, stream2Name, new Dictionary <string, int> {
{ "$maxAge", 2 }
});
}
if (key.Key == ConsoleKey.C)
{
SetStreamMetadata(conn, streamName, new Dictionary <string, int> {
{ "$maxCount", 2 }
});
SetStreamMetadata(conn, stream2Name, new Dictionary <string, int> {
{ "$maxCount", 2 }
});
}
} while (true);
}
catch (Exception e)
{
Console.WriteLine(e);
}
Console.WriteLine("Press enter to exit");
Console.ReadLine();
}
public ProjectionSynchronizer()
{
_logger = new ConsoleLogger();
_projectionsManager = new ProjectionsManager(_logger, new DnsEndPoint("127.0.0.1", 2113), new TimeSpan(0, 1, 0));
}
public static void Status(ProjectionsManager manager, string[] commandArgs)
{
var nameAndCredentials = GetProjectionNameAndCredentials(commandArgs);
if (nameAndCredentials == null)
{
Log("Invalid arguments, should be: <projection-name> [<login> <password>].");
return;
}
var name = nameAndCredentials.Item1;
Log("{0} is '{1}'", name, manager.GetStatusAsync(name, nameAndCredentials.Item2).Result);
}
public ResumeProjection(AreaMap area, ProjectionsManager manager, UserCredentials credentials)
{
_area = area;
_manager = manager;
_credentials = credentials;
}
public EventStore(IEventStoreConnection connection, ProjectionsManager projectionManager)
{
this.connection = connection;
this.projectionManager = projectionManager;
}
public static void ShowQuery(ProjectionsManager manager, string[] commandArgs)
{
var nameAndCredentials = GetProjectionNameAndCredentials(commandArgs);
if (nameAndCredentials == null)
{
Log("Invalid arguments, should be: <projection-name> [<login> <password>].");
return;
}
var name = nameAndCredentials.Item1;
Log("{0}'s query :", name);
LogUnformatted(manager.GetQueryAsync(name, nameAndCredentials.Item2).Result);
}
public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
#if (!DEBUG)
Assert.Ignore("These tests require DEBUG conditional");
#else
var projectionWorkerThreadCount = GivenWorkerThreadCount();
var configuration = new ProjectionSubsystemOptions(
projectionWorkerThreadCount,
ProjectionType.All,
false,
TimeSpan.FromMinutes(Opts.ProjectionsQueryExpiryDefault),
Opts.FaultOutOfOrderProjectionsDefault,
500,
250);
_projections = new ProjectionsSubsystem(configuration);
_node = new MiniNode <TLogFormat, TStreamId>(
PathName, inMemDb: true,
subsystems: new ISubsystem[] { _projections });
_projectionsCreated = SystemProjections.Created(_projections.LeaderMainBus);
await _node.Start();
_conn = EventStoreConnection.Create(new ConnectionSettingsBuilder()
.DisableServerCertificateValidation()
.Build(), _node.TcpEndPoint);
await _conn.ConnectAsync();
_manager = new ProjectionsManager(
new ConsoleLogger(),
_node.HttpEndPoint,
TimeSpan.FromMilliseconds(20000),
_node.HttpMessageHandler);
_queryManager = new QueryManager(
new ConsoleLogger(),
_node.HttpEndPoint,
TimeSpan.FromMilliseconds(20000),
TimeSpan.FromMilliseconds(20000),
_node.HttpMessageHandler);
WaitIdle();
if (GivenStandardProjectionsRunning())
{
await EnableStandardProjections();
}
WaitIdle();
try {
await Given().WithTimeout(TimeSpan.FromSeconds(10));
} catch (Exception ex) {
throw new Exception("Given Failed", ex);
}
try {
await When().WithTimeout(TimeSpan.FromSeconds(10));
} catch (Exception ex) {
throw new Exception("When Failed", ex);
}
#endif
}
public async Task Setup(string endpoint, int readsize, bool extraStats)
{
_endpoint = endpoint;
_readsize = readsize;
_extraStats = extraStats;
foreach (var client in _clients)
{
if (client.Settings.GossipSeeds == null || !client.Settings.GossipSeeds.Any())
{
throw new ArgumentException(
"Eventstore connection settings does not contain gossip seeds (even if single host call SetGossipSeedEndPoints and SetClusterGossipPort)");
}
var manager = new ProjectionsManager(client.Settings.Log,
new IPEndPoint(client.Settings.GossipSeeds[0].EndPoint.Address,
client.Settings.ExternalGossipPort), TimeSpan.FromSeconds(5));
await manager.EnableAsync("$by_category", client.Settings.DefaultUserCredentials).ConfigureAwait(false);
var discoveredEvents =
_registry.GetMessageTypes().Where(x => typeof(IEvent).IsAssignableFrom(x)).ToList();
// Dont use - we dont need category projection projecting our projection
var stream = $"{_endpoint}.{Assembly.GetEntryAssembly().GetName().Version}".Replace("-", "");
// Link all events we are subscribing to to a stream
var functions =
discoveredEvents
.Select(
eventType => $"'{eventType.AssemblyQualifiedName}': processEvent")
.Aggregate((cur, next) => $"{cur},\n{next}");
// Don't tab this '@' will create tabs in projection definition
var definition = @"
function processEvent(s,e) {{
linkTo('{1}.{0}', e);
}}
fromCategory('{0}').
when({{
{2}
}});";
var appDefinition = string.Format(definition, StreamTypes.Domain, stream, functions).Replace(Environment.NewLine, "\n");
var oobDefinition = string.Format(definition, StreamTypes.OOB, stream, functions).Replace(Environment.NewLine, "\n");
// Create a projection for domain events and one for OOB events, later we'll subscribe as PINNED to domain events
// and ROUNDROBIN for OOB events.
// OOB events by definition don't need ordering, so theres no reason to overload a single PINNED consumer
// if the user uses a ton of OOB events
try
{
var existing = await manager.GetQueryAsync($"{stream}.app.projection").ConfigureAwait(false);
if (existing != appDefinition)
{
Logger.Fatal(
$"Projection [{stream}] already exists and is a different version! If you've upgraded your code don't forget to bump your app's version!\nExisting:\n{existing}\nDesired:\n{appDefinition}");
throw new EndpointVersionException(
$"Projection [{stream}] already exists and is a different version! If you've upgraded your code don't forget to bump your app's version!");
}
}
catch (ProjectionCommandFailedException)
{
try
{
// Projection doesn't exist
await
manager.CreateContinuousAsync($"{stream}.app.projection", appDefinition, false,
client.Settings.DefaultUserCredentials)
.ConfigureAwait(false);
}
catch (ProjectionCommandFailedException)
{
}
}
try
{
var existing = await manager.GetQueryAsync($"{stream}.oob.projection").ConfigureAwait(false);
if (existing != oobDefinition)
{
Logger.Fatal(
$"Projection [{stream}] already exists and is a different version! If you've upgraded your code don't forget to bump your app's version!");
throw new EndpointVersionException(
$"Projection [{stream}] already exists and is a different version! If you've upgraded your code don't forget to bump your app's version!");
}
}
catch (ProjectionCommandFailedException)
{
try
{
// Projection doesn't exist
await
manager.CreateContinuousAsync($"{stream}.oob.projection", oobDefinition, false,
client.Settings.DefaultUserCredentials)
.ConfigureAwait(false);
}
catch (ProjectionCommandFailedException)
{
}
}
}
}
static void Main(string[] args)
{
var ciccio = EmbeddedVNodeBuilder.AsSingleNode().RunProjections(ProjectionType.All).Build();
ciccio.Start();
var conn = EventStoreConnection.Create(GetConnectionBuilder(), new Uri($"tcp://localhost:1113"));
var projectionsManager = new ProjectionsManager(new TestLogger(), new IPEndPoint(IPAddress.Loopback, 2113),
TimeSpan.FromSeconds(5));
var projectionName = "LockeshTest";
var streamName = "ciccio1";
try
{
conn.Reconnecting += Conn_Reconnecting;
conn.ErrorOccurred += Conn_ErrorOccurred;
conn.ConnectAsync();
do
{
Console.Clear();
Console.WriteLine($"Press P to create projection {projectionName}");
Console.WriteLine($"Press S to send 1000 events to stream {streamName}");
Console.WriteLine($"Press O to send 1 event to stream {streamName}");
Console.WriteLine($"Press D to Disable projection '{projectionName}'");
Console.WriteLine($"Press E to Enable projection '{projectionName}'");
Console.WriteLine($"Press A to set $maxAge=2 to stream {streamName}");
Console.WriteLine($"Press C to set $maxCount=2 to stream {streamName}");
var key = Console.ReadKey();
if (key.Key == ConsoleKey.O || key.Key == ConsoleKey.NumPad0)
{
AppendToStreamAsync(conn, streamName, 1);
}
if (key.Key == ConsoleKey.S)
{
AppendToStreamAsync(conn, streamName, 1000);
}
if (key.Key == ConsoleKey.P)
{
projectionsManager.CreateContinuousAsync(projectionName,
$"fromStream('{streamName}').when({{'$any': function(state, evnt) {{linkTo('OurTargetStreamName', evnt); }}}});",
new UserCredentials("admin", "changeit"));
}
if (key.Key == ConsoleKey.D)
{
projectionsManager.DisableAsync(projectionName, new UserCredentials("admin", "changeit")).Wait();
}
if (key.Key == ConsoleKey.E)
{
projectionsManager.EnableAsync(projectionName, new UserCredentials("admin", "changeit")).Wait();
}
if (key.Key == ConsoleKey.A)
{
SetStreamMetadata(conn, streamName, new Dictionary <string, int> {
{ "$maxAge", 2 }
});
}
if (key.Key == ConsoleKey.C)
{
SetStreamMetadata(conn, streamName, new Dictionary <string, int> {
{ "$maxCount", 2 }
});
}
} while (true);
}
catch (Exception e)
{
Console.WriteLine(e);
}
Console.WriteLine("Press enter to exit");
Console.ReadLine();
}
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);
}
}
}
public override async Task TestFixtureSetUp()
{
await base.TestFixtureSetUp();
#if (!DEBUG)
Assert.Ignore("These tests require DEBUG conditional");
#else
_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));
_nodes[0] = CreateNode(0,
_nodeEndpoints[0], new[] { _nodeEndpoints[1].InternalHttp, _nodeEndpoints[2].InternalHttp });
_nodes[1] = CreateNode(1,
_nodeEndpoints[1], new[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[2].InternalHttp });
_nodes[2] = CreateNode(2,
_nodeEndpoints[2], new[] { _nodeEndpoints[0].InternalHttp, _nodeEndpoints[1].InternalHttp });
WaitIdle();
var projectionsStarted = _projections.Select(p => SystemProjections.Created(p.LeaderMainBus)).ToArray();
foreach (var node in _nodes)
{
node.Start();
node.WaitIdle();
}
await Task.WhenAll(_nodes.Select(x => x.Started)).WithTimeout(TimeSpan.FromSeconds(30));
_conn = EventStoreConnection.Create(_nodes[0].ExternalTcpEndPoint);
await _conn.ConnectAsync().WithTimeout();
_manager = new ProjectionsManager(
new ConsoleLogger(),
_nodes.Single(x => x.NodeState == VNodeState.Leader).ExternalHttpEndPoint,
TimeSpan.FromMilliseconds(10000));
if (GivenStandardProjectionsRunning())
{
await Task.WhenAny(projectionsStarted).WithTimeout(TimeSpan.FromSeconds(10));
await EnableStandardProjections().WithTimeout(TimeSpan.FromMinutes(2));
}
WaitIdle();
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);
}
#endif
}
/// <summary>
/// Initializes a new <see cref="ProjectionsInitializationTask"/>
/// </summary>
/// <param name="logger">The service used to perform logging</param>
/// <param name="applicationOptions">The service used to access the current <see cref="Infrastructure.Configuration.ApplicationOptions"/></param>
/// <param name="startupTaskManager">The service used to manage <see cref="IStartupTask"/>s</param>
/// <param name="projectionsManager">The service used to manage EventStore projections</param>
public ProjectionsInitializationTask(ILogger <ProjectionsInitializationTask> logger, IOptions <ApplicationOptions> applicationOptions, IStartupTaskManager startupTaskManager, ProjectionsManager projectionsManager)
: base(startupTaskManager)
{
this.Logger = logger;
this.ApplicationOptions = applicationOptions.Value;
this.ProjectionsManager = projectionsManager;
}
