public async Task ShouldNotPublishToPoisonQueueWhenMessageIsHandled() { var handled = false; var context = MockPartitionContext.CreateWithNoopCheckpoint("1"); var events = new[] { new EventData() }; var resovler = new MockMessageHandlerResolver( (body, headers) => { handled = true; return(Task.FromResult <object>(null)); }); var poisonHandler = (MockPoisonMessageHandler)DependencyResolverFactory .GetResolver() .GetService(typeof(IPoisonMessageHandler)); var processor = new EventProcessor(resovler, new MockCircuitBreaker(), 1, "test", Mock.Of <IDispatcherInstrumentationPublisher>()); await processor.ProcessEventsAsync(context, events); Assert.True(handled); Assert.False( poisonHandler.Messages.Any(), String.Format("Expected poison handler to have no messages; count = {0}", poisonHandler.Messages.Count())); }
public async Task ShouldPublishToPoisonQueueWhenHandlerThrows() { var context = MockPartitionContext.CreateWithNoopCheckpoint("1"); var attemptedToResolveHandler = false; var events = new[] { new EventData() }; var resolver = new MockMessageHandlerResolver( async(body, headers) => { attemptedToResolveHandler = true; await Task.Yield(); throw new Exception("This message was bad."); }); var poisonHandler = (MockPoisonMessageHandler)DependencyResolverFactory .GetResolver() .GetService(typeof(IPoisonMessageHandler)); var processor = new EventProcessor(resolver, new MockCircuitBreaker(), 1, "test", Mock.Of <IDispatcherInstrumentationPublisher>()); await processor.ProcessEventsAsync(context, events); Assert.True(attemptedToResolveHandler); Assert.True( poisonHandler.Messages.Any(), String.Format("Expected poison handler to have messages; count = {0}", poisonHandler.Messages.Count())); }
public async Task WhenRegisteringExistingApplicationThenErrorShouldBeRaised() { using (IDependencyResolver resolver = DependencyResolverFactory.CreateDependencyResolver()) { LoggerController controller = new LoggerController(resolver.Resolve <IApplicationService>(), resolver.Resolve <ILogService>()); string displayName = GenerateDisplayName(); ApplicationCreateModel applicationCreateModel = new ApplicationCreateModel() { DisplayName = displayName, Password = "******" }; OkNegotiatedContentResult <int> result = await controller.RegisterAsync(applicationCreateModel) as OkNegotiatedContentResult <int>; Assert.IsNotNull(result); BadRequestErrorMessageResult newResult = await controller.RegisterAsync(applicationCreateModel) as BadRequestErrorMessageResult; Assert.IsNotNull(newResult); Assert.AreEqual(newResult.Message, $"Application with DisplayName {displayName} already exists."); } }
public void SourceControlMapping_Resolver_Success() { // Arrange: DependencyResolverFactory.RegisterResolverType(new SourceControlMappingResolverType()); // Mock logger: Mock <ILogger> logger = new Mock <ILogger>(); logger.Setup(f => f.LogMsg(It.IsAny <string>())); logger.Setup(f => f.ShowMessages()); // Mock dependency graph: DependencyGraphCreator target = new DependencyGraphCreator("Data", logger.Object, true); Mock <ISettings <ServiceValidSettings> > service = new Mock <ISettings <ServiceValidSettings> >(); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultTeamProjectCollection)).Returns(Values.TeamProjectCollection); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultWorkspaceName)).Returns(_workspaceName); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultWorkspaceOwner)).Returns(Values.WorkspaceOwner); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultOutputBaseFolder)).Returns(_localWorkspaceFolder); service.Setup(f => f.GetSetting(ServiceValidSettings.BinaryTeamProjectCollectionUrl)).Returns(Values.TeamProjectCollection); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultRelativeOutputPath)).Returns(@"..\Bin"); service.Setup(f => f.GetSetting(ServiceValidSettings.BinaryRepositoryTeamProject)).Returns(""); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultDependencyDefinitionFilename)).Returns("component.targets"); // Act: var result = target.GetDependencyGraph(service.Object, Path.Combine(_localWorkspaceFolder, @"SourceControlTarget\component.targets")); var dependencyService = new DependencyService(service.Object); dependencyService.DownloadGraph(result, logger.Object, true, true); // Assert: var dllFiles = Directory.GetFiles(_localWorkspaceFolder + @"..\..\DependencySource", "*.dll").Select(path => Path.GetFileName(path)).ToArray(); Assert.AreEqual("helloWorld.dll", dllFiles.First()); }
public void VNextBuildResult_Resolver_Success() { // Arrange: DependencyResolverFactory.RegisterResolverType(new VNextBuildResultResolverType()); // Mock logger: Mock <ILogger> logger = new Mock <ILogger>(); logger.Setup(f => f.LogMsg(It.IsAny <string>())); logger.Setup(f => f.ShowMessages()); // Mock dependency graph: DependencyGraphCreator target = new DependencyGraphCreator("Data", logger.Object, true); Mock <ISettings <ServiceValidSettings> > service = new Mock <ISettings <ServiceValidSettings> >(); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultTeamProjectCollection)).Returns(Values.TeamProjectCollection); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultWorkspaceName)).Returns(Values.WorkSpaceName); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultWorkspaceOwner)).Returns(Values.WorkspaceOwner); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultOutputBaseFolder)).Returns(Values.PathToTeamProject); service.Setup(f => f.GetSetting(ServiceValidSettings.BinaryTeamProjectCollectionUrl)).Returns(Values.TeamProjectCollection); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultRelativeOutputPath)).Returns(@"..\Bin"); service.Setup(f => f.GetSetting(ServiceValidSettings.BinaryRepositoryTeamProject)).Returns(""); service.Setup(f => f.GetSetting(ServiceValidSettings.DefaultDependencyDefinitionFilename)).Returns("component.targets"); // Act: var result = target.GetDependencyGraph(service.Object, Values.PathToTeamProject + @"\VNextBuildResult\component.targets"); var dependencyService = new DependencyService(service.Object); dependencyService.DownloadGraph(result, logger.Object, true, true); // Assert: var dllFiles = Directory.GetFiles(Values.DependencyOutputPath, "*").Select(path => Path.GetFileName(path)).ToArray(); Assert.AreEqual("AssemblyInfo.cs", dllFiles.First()); }
public CardValidationTest() { resolver = DependencyResolverFactory.Create(ResolverType.Default, new List <IDependencyRegistrator> { new DependencyRegistrator(), new MobLib.Payment.PayU.DependencyRegistrator() }); }
public WhenProcessingMessages() { var handler = new MockPoisonMessageHandler(); var mockResolver = MockDependencyResolver .CreateFor <IPoisonMessageHandler>(handler); DependencyResolverFactory.Register(mockResolver); handler.Clear(); }
public DependencyResolverFactoryFixture() { var type = typeof(DependencyResolverTestDouble); var typeName = string.Format("{0}, {1}", type.FullName, type.Assembly.FullName); var factory = new DependencyResolverFactory(typeName); _resolver = factory.CreateInstance(); }
public override bool OnStart() { try { // Register the dependency resolver for initializing handlers and service // classes. var resolver = CarWorkerHostDependencyResolver.CreateAsync().Result; DependencyResolverFactory.Register( resolver ); // Set up the process defaults for connections to optimize storage performance ServicePointManager.DefaultConnectionLimit = int.MaxValue; var configuration = DispatcherConfiguration.GetCurrentConfiguration(); var typesToSearchForHandlers = typeof(UpdateLocationHandler) .Assembly .DefinedTypes; _coordinator = ProcessingCoordinator.CreateAsync( RoleEnvironment.CurrentRoleInstance.Id, configuration.EventHubName, configuration.ConsumerGroupName, configuration.EventHubConnectionString, configuration.CheckpointStorageAccount, configuration.MaxBatchSize, configuration.PrefetchCount, configuration.ReceiveTimeout, configuration.MaxConcurrencyPerProcessor, typesToSearchForHandlers, (name, partitionId) => new CircuitBreaker( name, partitionId, configuration.CircuitBreakerWarningLevel, configuration.CircuitBreakerTripLevel, configuration.CircuitBreakerStallInterval, configuration.CircuitBreakerLogCooldownInterval), new DispatcherInstrumentationManager(instrumentationEnabled: true).CreatePublisher("WaWorkerHost")).Result; bool result = base.OnStart(); return(result); } catch (Exception ex) { // Hard error on startup, usually configuration or security related // Ensure that we log this error, including a direct post to the local // event log LogHelpers.HandleRoleException(Logger, "OnStart()", ex); throw; } }
/// <summary> /// Resolves a list of missing packages. /// </summary> /// <param name="token">Used to cancel the operation.</param> public static async Task ResolveMissingPackagesAsync(CancellationToken token = default) { if (!HasInternetConnection) { return; } ModDependencyResolveResult resolveResult = null !; do { // Get missing dependencies for this update loop. var missingDeps = CheckMissingDependencies(); // Get Dependencies var resolver = DependencyResolverFactory.GetInstance(IoC.Get <AggregateNugetRepository>()); var results = new List <Task <ModDependencyResolveResult> >(); foreach (var dependencyItem in missingDeps.Items) { foreach (var dependency in dependencyItem.Dependencies) { results.Add(resolver.ResolveAsync(dependency, dependencyItem.Mod.PluginData, token)); } } await Task.WhenAll(results); // Merge Results resolveResult = ModDependencyResolveResult.Combine(results.Select(x => x.Result)); DownloadPackages(resolveResult, token); }while (resolveResult.FoundDependencies.Count > 0); if (resolveResult.NotFoundDependencies.Count > 0) { ActionWrappers.ExecuteWithApplicationDispatcher(() => { Actions.DisplayMessagebox(Resources.ErrorMissingDependency.Get(), $"{Resources.FetchNugetNotFoundMessage.Get()}\n\n" + $"{string.Join('\n', resolveResult.NotFoundDependencies)}\n\n" + $"{Resources.FetchNugetNotFoundAdvice.Get()}", new Actions.DisplayMessageBoxParams() { Type = Actions.MessageBoxType.Ok, StartupLocation = Actions.WindowStartupLocation.CenterScreen }); }); } }
public async Task WhenRegisteringApplicationThenApplicationIsRegistered() { using (IDependencyResolver resolver = DependencyResolverFactory.CreateDependencyResolver()) { LoggerController controller = new LoggerController(resolver.Resolve <IApplicationService>(), resolver.Resolve <ILogService>()); ApplicationCreateModel applicationCreateModel = new ApplicationCreateModel() { DisplayName = GenerateDisplayName(), Password = "******" }; OkNegotiatedContentResult <int> result = await controller.RegisterAsync(applicationCreateModel) as OkNegotiatedContentResult <int>; Assert.IsNotNull(result); } }
private void Application_Start(object sender, EventArgs e) { // Code that runs on application startup IDependencyResolverFactory dependencyResolverFactory = new DependencyResolverFactory(); IoC.InitializeIoC(dependencyResolverFactory); //var slProvider = new WebServiceLocatorProvider(); //ServiceLocator.SetLocatorProvider(slProvider.GetWebServiceLocator); var routingConfig = new RoutingConfiguration(); routingConfig.RegisterRoutes(RouteTable.Routes); DynamicControlsContainer.InitializeDynamicControls(); //var a = typeof(Buncis.Web.Common.WebServices.WebSessionBehaviorExtensionElement).AssemblyQualifiedName; }
private static async Task RunAsync(CancellationToken token) { var configuration = DispatcherConfiguration.GetCurrentConfiguration(); // Configure dependency resolver (including poison handler) var resolver = await ConsoleHostDependencyResolver.CreateAsync(); DependencyResolverFactory.Register( resolver ); Console.WriteLine("Initializing coordinator"); var messageProcessor = await ProcessingCoordinator.CreateAsync( "Console", configuration.EventHubName, configuration.ConsumerGroupName, configuration.EventHubConnectionString, configuration.CheckpointStorageAccount, configuration.MaxBatchSize, configuration.PrefetchCount, configuration.ReceiveTimeout, configuration.MaxConcurrencyPerProcessor, typeof(UpdateLocationHandler).Assembly.DefinedTypes, (name, partitionId) => new CircuitBreaker( name, partitionId, configuration.CircuitBreakerWarningLevel, configuration.CircuitBreakerTripLevel, configuration.CircuitBreakerStallInterval, configuration.CircuitBreakerLogCooldownInterval), new DispatcherInstrumentationManager(true, true).CreatePublisher("console")); Console.WriteLine("Running processor"); try { await Task.Delay(Timeout.InfiniteTimeSpan, token); } catch (TaskCanceledException) { /* expected cancellation */ } messageProcessor.Dispose(); }
public async Task WhenLoggingWithBadApplicationIdThenErrorShouldBeRaised() { using (IDependencyResolver resolver = DependencyResolverFactory.CreateDependencyResolver()) { LoggerController controller = new LoggerController(resolver.Resolve <IApplicationService>(), resolver.Resolve <ILogService>()); LogCreateModel logCreateModel = new LogCreateModel() { ApplicationId = 0, // bad application_id Logger = "logger", Level = "level", Message = "message" }; var result = await controller.LogAsync(logCreateModel) as OkNegotiatedContentResult <LogCreationResultModel>; Assert.AreEqual(result.Content.success, false); } }
void Application_Start(object sender, EventArgs e) { var assemblise = new string[] { "SuperCom.Host", "Sql.Infrastructure.IoC" }; DependencyResolverFactory.Initialize(assemblise); _resolver = DependencyResolverFactory.GetResolver(); GlobalConfiguration.Configuration.Services.Replace( typeof(IHttpControllerActivator), new WindsorCompositionRoot(_resolver.GetResolver)); AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebApiConfig.Register); RouteConfig.RegisterRoutes(RouteTable.Routes); }
public Service( string url, ServiceDescriptor descriptor, IConfigViewer configViewer, ILogProvider logProvider, Action <HttpConfiguration> startup, Type dependencyLoaderType ) { m_url = url; m_descriptor = descriptor; m_configViewer = configViewer; m_logProvider = logProvider; m_startup = startup; m_dependencyResolver = DependencyResolverFactory .CreateFrom(new CoreDependencyLoader( m_configViewer, m_logProvider, dependencyLoaderType ) ); }
protected async Task InitializeAsync( string hostName, string eventHubName, string consumerGroupName, string eventHubConnectionString, string checkpointStorageAccount, int maxBatchSize, int prefetchCount, TimeSpan receiveTimeout, int maxConcurrencyPerProcessor, IEnumerable <Type> typesToSearch, Func <string, string, ICircuitBreaker> circuitBreakerFactory, IDispatcherInstrumentationPublisher instrumentationPublisher) { Logger.Info("Initializing event hub listener for {0} ({1})", eventHubName, consumerGroupName); // Get the consumer group via the Service Bus namespace (identifies the // consumer) var ns = NamespaceManager.CreateFromConnectionString(eventHubConnectionString); try { await ns.GetConsumerGroupAsync(eventHubName, consumerGroupName); Logger.Info("Found consumer group {1} for {0}", eventHubName, consumerGroupName); } catch (Exception e) { Logger.Error(e, "Could not establish connection to {0} in event hub {1}", consumerGroupName, eventHubName); throw; } var eventHubId = ConfigurationHelper.GetEventHubName(ns.Address, eventHubName); // Use a custom event processor factory to pass parameters to the // event host processor var factory = new EventProcessorFactory( handlerResolver: new MessageHandlerResolver(typesToSearch, DependencyResolverFactory.GetResolver()), maxConcurrency: maxConcurrencyPerProcessor, circuitBreakerFactory: circuitBreakerFactory, eventHubName: eventHubId, instrumentationPublisher: instrumentationPublisher); var options = new EventProcessorOptions { MaxBatchSize = maxBatchSize, PrefetchCount = prefetchCount, ReceiveTimeOut = receiveTimeout }; options.ExceptionReceived += options_ExceptionReceived; // Create the event processor host and register via the factory _host = new EventProcessorHost( hostName, consumerGroupName: consumerGroupName, eventHubPath: eventHubName, eventHubConnectionString: eventHubConnectionString, storageConnectionString: checkpointStorageAccount ); await _host.RegisterEventProcessorFactoryAsync(factory, options); Logger.Info("Event processor registered for {0} ({1})", eventHubName, consumerGroupName); }