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);
}
