public static void Configure(ProjectionGatewayConfiguration projectionGatewayConfiguration, IPEndPoint httpEndPoint, UserCredentials credentials)
{
var projectionManager = new ProjectionsManager(new ConsoleLogger(), httpEndPoint, new TimeSpan(1, 0, 0, 0));
var byCategoryProjectionStatus = ((JObject)JsonConvert.DeserializeObject(projectionManager.GetStatusAsync("$by_category", credentials).Result))["status"].ToString();
var streamByCategoryProjectionStatus = ((JObject)JsonConvert.DeserializeObject(projectionManager.GetStatusAsync("$stream_by_category", credentials).Result))["status"].ToString();
if (byCategoryProjectionStatus == "Stopped")
{
projectionManager.EnableAsync("$by_category", credentials).Wait();
}
if (streamByCategoryProjectionStatus == "Stopped")
{
projectionManager.EnableAsync("$stream_by_category", credentials).Wait();
}
const string projectionPattern = @"fromCategory('{0}')
.foreachStream()
.whenAny(function(state, event){{
linkTo('{1}', event);
}})";
foreach (var aggregateRootName in projectionGatewayConfiguration.Subscriptions.Keys)
{
projectionManager.CreateContinuousAsync(
string.Format("{0}Projection", aggregateRootName),
string.Format(projectionPattern, aggregateRootName, aggregateRootName + "View"), credentials).Wait();
}
}
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 Create(ProjectionsManager manager, 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...");
manager.CreateOneTime(query);
Log("Created");
break;
case "continuous":
Log("Creating continuous projection {0}...", pname);
manager.CreateContinuous(pname, query);
Log("Created");
break;
default:
Log("projection type not recognized");
break;
}
}
public void It_can_send_and_receive_messages()
{
var projectionsManager = new ProjectionsManager(new NoopLogger(), HttpEndPoint);
projectionsManager.Enable("$by_category", AdminCredentials);
var sinkProjectionCreator = new ReceiverSinkProjectionCreator
{
ConnectionManager = new DefaultConnectionManager(ConnectionConfiguration)
};
sinkProjectionCreator.RegisterProjectionsFor(ReceiverAddress,"");
var routerProjectionCreattor = new TransactionalModeRouterProjectionCreator()
{
ConnectionManager = new DefaultConnectionManager(ConnectionConfiguration)
};
routerProjectionCreattor.RegisterProjectionsFor(SenderAddress,"");
var transactionalSender = CreateSender();
using (var tx = new TransactionScope())
{
SendMessages(transactionalSender, 5);
tx.Complete();
}
if (!ExpectReceive(5, TimeSpan.FromSeconds(5)))
{
Assert.Fail("Received {0} messages out of 5", Count);
}
}
public static void List(ProjectionsManager manager, string[] commandArgs)
{
if (commandArgs.Length != 1)
{
Log("Invalid argument value for list mode");
return;
}
var mode = commandArgs[0].Trim().ToLower();
switch (mode)
{
case "all":
Log("Listing all projections...");
LogUnformatted(manager.ListAll());
Log("All projections listed");
break;
case "onetime":
Log("Listing onetime projections...");
LogUnformatted(manager.ListOneTime());
Log("Onetime projections listed");
break;
case "continuous":
Log("Listing continuous projections...");
LogUnformatted(manager.ListContinuous());
Log("Continuous projections listed");
break;
default:
Log("List mode not recognized");
break;
}
}
public static void Enable(ProjectionsManager manager, string[] commandArgs)
{
var nameAndCredentials = GetProjectionNameAndCredentials(commandArgs);
var name = nameAndCredentials.Item1;
Log("Enabling {0}...", name);
manager.Enable(name, nameAndCredentials.Item2);
Log("{0} enabled", name);
}
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 static void Disable(ProjectionsManager manager, string[] commandArgs)
{
var names = GetProjectionNames(commandArgs);
foreach (var name in names)
{
Log("Disabling {0}...", name);
manager.Disable(name);
Log("{0} disabled", name);
}
}
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
}
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 override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
#if DEBUG
QueueStatsCollector.InitializeIdleDetection();
#else
throw new NotSupportedException("These tests require DEBUG conditional");
#endif
CreateNode();
_conn = EventStoreConnection.Create(_node.TcpEndPoint);
_conn.Connect();
_manager = new ProjectionsManager(new ConsoleLogger(), _node.HttpEndPoint);
if (GivenStandardProjectionsRunning())
EnableStandardProjections();
QueueStatsCollector.WaitIdle();
Given();
When();
}
public EventStoreAdapter(string ipAddress)
{
var connectionSettings = ConnectionSettings.Create ()
.SetDefaultUserCredentials (new UserCredentials ("admin", "changeit"))
.OnAuthenticationFailed ((connection, message) => Console.WriteLine ("Authentication failed. {0}", message))
.OnConnected ((connection, endPoint) => Console.WriteLine ("Connected. {0}:{1}", endPoint.Address, endPoint.Port))
.OnClosed ((connection, message) => Console.WriteLine ("Closed. {0}", message))
.OnDisconnected ((connection, endPoint) => Console.WriteLine ("Disconnected. {0}:{1}", endPoint.Address, endPoint.Port))
.OnErrorOccurred ((connection, exception) => Console.WriteLine ("Error occured. {0}", exception))
.OnReconnecting (connection => Console.WriteLine ("Reconnecting."))
.EnableVerboseLogging ();
var iPEndPoint = new IPEndPoint (IPAddress.Parse (ipAddress), 1113);
this.connection = EventStoreConnection.Create (
connectionSettings,
iPEndPoint);
this.converter = new EventDataConverter ();
this.connection.Connect();
this.projectionsManager = new ProjectionsManager (new NoopLogger (), iPEndPoint);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
#if DEBUG
QueueStatsCollector.InitializeIdleDetection();
#else
throw new NotSupportedException("These tests require DEBUG conditional");
#endif
_projections = new ProjectionsSubsystem(1, runProjections: RunProjections.All);
_node = new MiniNode(
PathName, inMemDb: true, skipInitializeStandardUsersCheck: false,
subsystems: new ISubsystem[] {_projections});
_node.Start();
_conn = EventStoreConnection.Create(_node.TcpEndPoint);
_conn.Connect();
_manager = new ProjectionsManager(new ConsoleLogger(), _node.HttpEndPoint);
if (GivenStandardProjectionsRunning())
EnableStandardProjections();
QueueStatsCollector.WaitIdle();
Given();
When();
}
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 void It_can_send_and_receive_messages()
{
var projectionsManager = new ProjectionsManager(new NoopLogger(), HttpEndPoint);
projectionsManager.Enable("$by_category", AdminCredentials);
var sinkProjectionCreator = new ReceiverSinkProjectionCreator
{
ConnectionManager = new DefaultConnectionManager(ConnectionConfiguration)
};
sinkProjectionCreator.RegisterProjectionsFor(ReceiverAddress, "");
var routerProjectionCreattor = new EventSourcedModeRouterProjectionCreator()
{
ConnectionManager = new DefaultConnectionManager(ConnectionConfiguration)
};
routerProjectionCreattor.RegisterProjectionsFor(SenderAddress, "");
var unitOfWork = new EventSourcedUnitOfWork(new DefaultConnectionManager(ConnectionConfiguration))
{
EndpointAddress = SenderAddress
};
var sender = CreateSender();
unitOfWork.Begin();
unitOfWork.Initialize("58",ExpectedVersion.NoStream);
SendMessages(sender, 5);
unitOfWork.End();
if (!ExpectReceive(5, TimeSpan.FromSeconds(5)))
{
Assert.Fail("Received {0} messages out of 5", Count);
}
}
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 DefaultProjectionsManager(ProjectionsManager projectionsManager, UserCredentials userCredentials)
{
this.projectionsManager = projectionsManager;
this.userCredentials = userCredentials;
}
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 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 static void UpdateQuery(ProjectionsManager manager, string[] commandArgs)
{
string pname;
var query = GetQuery(commandArgs, out pname);
if (query != null)
{
Log("Updating query of {0}...", pname);
manager.UpdateQuery(pname, query);
Log("Query updated");
}
else
Log("Invalid arguments for command update query");
}
public static void ShowQuery(ProjectionsManager manager, string[] commandArgs)
{
var names = GetProjectionNames(commandArgs);
foreach (var name in names)
{
Log("{0}'s query :", name);
LogUnformatted(manager.GetQuery(name));
}
}
public static void State(ProjectionsManager manager, string[] commandArgs)
{
var names = GetProjectionNames(commandArgs);
foreach (var name in names)
{
Log("{0}'s state is : '{1}'", name, manager.GetState(name));
}
}
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 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 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 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);
}
