public TexoEngineBuilder()
{
ServiceMessageBus defaultMessageBus = new ServiceMessageBus();
messageBus = defaultMessageBus;
registerToMessageBus = defaultMessageBus;
actions = new ActionFactories();
}
public async Task PublishMessageToNotExistHubThrows()
{
var dr = GetDefaultResolver(new string[] { }, out _);
using (var bus = new ServiceMessageBus(dr, NullLogger <ServiceMessageBus> .Instance))
{
await Assert.ThrowsAsync <KeyNotFoundException>(() => bus.Publish("test", "h-key", "1"));
}
}
public async Task PublishInvalidMessageThrows()
{
var dr = GetDefaultResolver(new string[] { }, out _);
using (var bus = new ServiceMessageBus(dr, NullLogger <ServiceMessageBus> .Instance))
{
await Assert.ThrowsAsync <NotSupportedException>(() => bus.Publish("test", "key", "1"));
}
}
private static ServiceHubDispatcher PrepareAndGetDispatcher(HubConfiguration configuration, ServiceOptions options, IServiceEndpointManager endpoint, IEndpointRouter router, string applicationName, IReadOnlyList <string> hubs, ILoggerFactory loggerFactory)
{
// TODO: Using IOptions looks wierd, thinking of a way removing it
// share the same object all through
var serviceOptions = Options.Create(options);
// For safety, ALWAYS register abstract classes or interfaces
// Some third-party DI frameworks such as Ninject, implicit self-binding concrete types:
// https://github.com/ninject/ninject/wiki/dependency-injection-with-ninject#skipping-the-type-binding-bit--implicit-self-binding-of-concrete-types
configuration.Resolver.Register(typeof(IOptions <ServiceOptions>), () => serviceOptions);
var serviceProtocol = new ServiceProtocol();
configuration.Resolver.Register(typeof(IServiceProtocol), () => serviceProtocol);
var scm = new ServiceConnectionManager(applicationName, hubs);
configuration.Resolver.Register(typeof(Microsoft.Azure.SignalR.AspNet.IServiceConnectionManager), () => scm);
var ccm = new ClientConnectionManager(configuration);
configuration.Resolver.Register(typeof(IClientConnectionManager), () => ccm);
var atm = new AzureTransportManager(configuration.Resolver);
configuration.Resolver.Register(typeof(ITransportManager), () => atm);
var parser = new SignalRMessageParser(hubs, configuration.Resolver);
configuration.Resolver.Register(typeof(IMessageParser), () => parser);
var smb = new ServiceMessageBus(configuration.Resolver);
configuration.Resolver.Register(typeof(IMessageBus), () => smb);
if (hubs?.Count > 0)
{
return(new ServiceHubDispatcher(hubs, serviceProtocol, scm, ccm, endpoint, router, serviceOptions, loggerFactory));
}
else
{
loggerFactory.CreateLogger <IAppBuilder>().Log(LogLevel.Warning, "No hubs found.");
return(null);
}
}
private static void RegisterServiceObjects(HubConfiguration configuration, ServiceOptions options, string applicationName, IReadOnlyList <string> hubs)
{
// TODO: Using IOptions looks wierd, thinking of a way removing it
// share the same object all through
var serviceOptions = Options.Create(options);
// For safety, ALWAYS register abstract classes or interfaces
// Some third-party DI frameworks such as Ninject, implicit self-binding concrete types:
// https://github.com/ninject/ninject/wiki/dependency-injection-with-ninject#skipping-the-type-binding-bit--implicit-self-binding-of-concrete-types
configuration.Resolver.Register(typeof(IOptions <ServiceOptions>), () => serviceOptions);
var serviceProtocol = new ServiceProtocol();
configuration.Resolver.Register(typeof(IServiceProtocol), () => serviceProtocol);
var provider = new EmptyProtectedData();
configuration.Resolver.Register(typeof(IProtectedData), () => provider);
var endpoint = new ServiceEndpointProvider(serviceOptions.Value);
configuration.Resolver.Register(typeof(IServiceEndpointProvider), () => endpoint);
var scm = new ServiceConnectionManager(applicationName, hubs);
configuration.Resolver.Register(typeof(IServiceConnectionManager), () => scm);
var ccm = new ClientConnectionManager(configuration);
configuration.Resolver.Register(typeof(IClientConnectionManager), () => ccm);
var atm = new AzureTransportManager(configuration.Resolver);
configuration.Resolver.Register(typeof(ITransportManager), () => atm);
var parser = new SignalRMessageParser(hubs, configuration.Resolver);
configuration.Resolver.Register(typeof(IMessageParser), () => parser);
var smb = new ServiceMessageBus(configuration.Resolver);
configuration.Resolver.Register(typeof(IMessageBus), () => smb);
}
public async Task PublishBroadcastMessagesTest(string messageKey, string messageValue, string[] availableHubs, string[] expectedHubs)
{
var dr = GetDefaultResolver(availableHubs, out var scm);
PrepareConnection(scm, out var result);
using (var bus = new ServiceMessageBus(dr, NullLogger <ServiceMessageBus> .Instance))
{
await bus.Publish(SignalRMessageUtility.CreateMessage(messageKey, messageValue));
}
Assert.Equal(expectedHubs.Length, result.Count);
for (var i = 0; i < expectedHubs.Length; i++)
{
Assert.True(result.TryGetValue(expectedHubs[i], out var current));
var message = current as BroadcastDataMessage;
Assert.NotNull(message);
Assert.Equal(messageValue, message.Payloads["json"].GetJsonMessageFromSingleFramePayload <string>());
}
}
public async Task PublishConnectionDataMessagesWithLocalServiceConnectionTest(string messageKey, string messageValue, string[] availableHubs, string[] expectedHubs, string[] expectedConnectionIds)
{
var dr = GetDefaultResolver(availableHubs, out var scm);
PrepareConnection(scm, out var result);
var anotherResult = new List <ServiceMessage>();
var anotherSCM = new TestServiceConnectionContainer(null,
m =>
{
lock (anotherResult)
{
anotherResult.Add(m.Item1);
}
});
var ccm = new TestClientConnectionManager(anotherSCM);
dr.Register(typeof(IClientConnectionManager), () => ccm);
using (var bus = new ServiceMessageBus(dr, NullLogger <ServiceMessageBus> .Instance))
{
await bus.Publish(SignalRMessageUtility.CreateMessage(messageKey, messageValue));
}
Assert.Empty(result);
Assert.Equal(expectedHubs.Length, anotherResult.Count);
Assert.Equal(expectedConnectionIds.Length, anotherResult.Count);
for (var i = 0; i < expectedHubs.Length; i++)
{
var message = anotherResult[i] as ConnectionDataMessage;
Assert.NotNull(message);
Assert.Equal(expectedConnectionIds[i], message.ConnectionId);
Assert.Equal(messageValue, message.Payload.First.GetJsonMessageFromSingleFramePayload <string>());
}
}
public async Task PublishConnectionDataMessagesTest(string messageKey, string messageValue, string[] availableHubs, string[] expectedHubs, string[] expectedConnectionIds)
{
var dr = GetDefaultResolver(availableHubs, out var scm);
PrepareConnection(scm, out var result);
using (var bus = new ServiceMessageBus(dr))
{
await bus.Publish(SignalRMessageUtility.CreateMessage(messageKey, messageValue));
}
Assert.Equal(expectedHubs.Length, result.Count);
Assert.Equal(expectedConnectionIds.Length, result.Count);
for (var i = 0; i < expectedHubs.Length; i++)
{
Assert.True(result.TryGetValue(expectedHubs[i], out var current));
var message = current as ConnectionDataMessage;
Assert.NotNull(message);
Assert.Equal(expectedConnectionIds[i], message.ConnectionId);
Assert.Equal(messageValue, message.Payload.First.GetSingleFramePayload());
}
}
private static void Startup()
{
SimpleIoc container = new SimpleIoc();
container.Register <ServiceMessageBus>();
container.Register <IServiceMessageBus>(() => container.GetInstance <ServiceMessageBus>());
container.Register <IServiceMessageBusRegister>(() => container.GetInstance <ServiceMessageBus>());
container.Register <ILogService, DebugLogService>();
container.Register <IInputParseService, InputParseService>();
container.Register <IInputEvaluationService, InputEvaluationService>();
container.Register <IEnvironmentService, EnvironmentService>();
container.Register <ISettingService, SettingService>();
container.Register <ICommandManagementService, SingletonCommandManagementService>();
container.Register <IResultProcessingService, ResultProcessingService>();
container.Register <IMarkdownService, MarkdownService>();
container.Register <IConsoleRenderService, ConsoleMarkdownRenderService>();
container.Register <ConsoleViewService>();
container.Register <IViewService>(() => container.GetInstance <ConsoleViewService>());
container.Register <IPromptableViewService>(() => container.GetInstance <ConsoleViewService>());
// PowerShell Fallback
container.Register <IPowerShellResultBuilder, PowerShellResultMarkdownBuilder>();
container.Register <IFallbackService, PowerShellFallbackService>();
// Core commands
container.Register <CurrentDirectoryCommand>();
container.Register <TexoCommand>();
container.Register <HelpCommand>();
container.Register <ClearCommand>();
// Simple commands
container.Register <ReferenceCheckCommand>();
container.Register <CommandLineCommand>();
// File manager
container.Register <ISerialisationService, JsonSerialisationService>();
container.Register <IStageService, StageService>();
container.Register <IStashService, StashService>();
container.Register <FileManagerCommand>();
// Nuget manager
container.Register <IProjectManagementService, ProjectManagementService>();
container.Register <IPackageManagementService, PackageManagementService>();
container.Register <IConfigManagementService, ConfigManagementService>();
container.Register <ISourceManagementService, SourceManagementService>();
container.Register <IManagementService, ManagementService>();
container.Register <Commands.NugetManager.Stage.IStageService, Commands.NugetManager.Stage.StageService>();
container.Register <NugetManagerCommand>();
CommandFactory commandFactory = new CommandFactory();
container.Register <ITexoFactory <object, string> >(() => commandFactory);
commandFactory.Register(CommandKeys.CURRENT_DIRECTORY, () => container.GetInstance <CurrentDirectoryCommand>());
commandFactory.Register(CommandKeys.TEXO, () => container.GetInstance <TexoCommand>());
commandFactory.Register(CommandKeys.HELP, container.GetInstance <HelpCommand>);
commandFactory.Register(CommandKeys.CLEAR, container.GetInstance <ClearCommand>);
commandFactory.Register(ReferenceCheckConstants.REF_CHECK, () => container.GetInstance <ReferenceCheckCommand>());
commandFactory.Register("command-line", () => container.GetInstance <CommandLineCommand>());
commandFactory.Register("file-manager", () => container.GetInstance <FileManagerCommand>());
commandFactory.Register("nuget-manager", () => container.GetInstance <NugetManagerCommand>());
ServiceMessageBus messageBus = container.GetInstance <ServiceMessageBus>();
var engineBuilder = new TexoEngineBuilder(messageBus, messageBus)
.WithLogService(container.GetInstance <ILogService>())
.WithInputParseService(container.GetInstance <IInputParseService>())
.WithInputEvaluationService(container.GetInstance <IInputEvaluationService>())
.WithEnvironmentService(container.GetInstance <IEnvironmentService>())
.WithSettingService(container.GetInstance <ISettingService>())
.WithCommandManagementService(container.GetInstance <ICommandManagementService>())
.WithResultProcessingService(container.GetInstance <IResultProcessingService>())
.WithFallbackService(container.GetInstance <IFallbackService>());
var locator = engineBuilder.GetServiceLocator();
container.Register(locator.ActionProvider);
container.Register(locator.ActionRegister);
engine = engineBuilder.Build(commandFactory, container.GetInstance <IViewService>());
var config = TexoConfiguration.CreateDefault().ToBuilder();
config.Runtime.Commands.Add(ReferenceCheckCommand.BuildConfiguration());
config.Runtime.Commands.Add(CommandLineCommand.BuildConfiguration());
config.Runtime.Commands.Add(FileManagerBuilder.BuildCommand());
config.Runtime.Commands.Add(NugetManagerBuilder.BuildCommand());
engine.Initialise(config.ToImmutable());
}
