public void InitializeResolver_Flat()
{
Random random = new Random();
CreateScopeResolverInformation inputModel = new CreateScopeResolverInformation();
Int32 propertyAmount = random.Next(3, 30);
for (int i = 0; i < propertyAmount; i++)
{
inputModel.PropertiesAndValues.Add($"property-{i + 1}", $"{random.Next()}");
}
Mock <ISerializer> serializerMock = new Mock <ISerializer>(MockBehavior.Strict);
DHCPv6ScopeResolverManager scopeManager = new DHCPv6ScopeResolverManager(serializerMock.Object, Mock.Of <IDeviceService>(MockBehavior.Strict), Mock.Of <ILogger <DHCPv6ScopeResolverManager> >());
Mock <IScopeResolver <DHCPv6Packet, IPv6Address> > resolverMock = new Mock <IScopeResolver <DHCPv6Packet, IPv6Address> >(MockBehavior.Strict);
resolverMock.Setup(x => x.ApplyValues(inputModel.PropertiesAndValues, serializerMock.Object)).Verifiable();
String typeName = $"typname-{random.Next()}";
scopeManager.AddOrUpdateScopeResolver(typeName, () => resolverMock.Object);
inputModel.Typename = typeName;
IScopeResolver <DHCPv6Packet, IPv6Address> actual = scopeManager.InitializeResolver(inputModel);
Assert.Equal(resolverMock.Object, actual);
resolverMock.Verify();
}
public IUnitOfWorkCompleteHandle Begin(UnitOfWorkOptions options)
{
_childScope = _scopeResolver.BeginScope();
options.FillDefaultsForNonProvidedOptions(_defaultOptions);
IUnitOfWork outerUow = _currentUnitOfWorkProvider.Current;
if (options.Scope == TransactionScopeOption.Required && outerUow != null)
{
return(new InnerUnitOfWorkCompleteHandle());
}
var uow = _childScope.Resolve <IUnitOfWork>();
uow.Completed += (sender, args) => { _currentUnitOfWorkProvider.Current = null; };
uow.Failed += (sender, args) => { _currentUnitOfWorkProvider.Current = null; };
uow.Disposed += (sender, args) => { _childScope.Dispose(); };
//Inherit filters from outer UOW
if (outerUow != null)
{
options.FillOuterUowFiltersForNonProvidedOptions(outerUow.Filters.ToList());
}
uow.Begin(options);
_currentUnitOfWorkProvider.Current = uow;
return(uow);
}
/// <summary>
/// Adds a resolver. The order is the order in which the resolvers are tried. The lowest order number
/// is tried first
/// </summary>
public void RegisterResolver(IScopeResolver resolver, int order)
{
resolvers.TryAdd(new ResolverListEntry {
Resolver = resolver,
Order = order
});
}
public StoveNHibernateInterceptor(IScopeResolver scopeResolver)
{
IScopeResolver innerResolver = scopeResolver;
_stoveSession =
new Lazy <IStoveSession>(
() => innerResolver.IsRegistered(typeof(IStoveSession))
? innerResolver.Resolve <IStoveSession>()
: NullStoveSession.Instance,
true
);
_guidGenerator =
new Lazy <IGuidGenerator>(
() => innerResolver.IsRegistered(typeof(IGuidGenerator))
? innerResolver.Resolve <IGuidGenerator>()
: SequentialGuidGenerator.Instance,
true
);
_eventBus =
new Lazy <IEventBus>(
() => innerResolver.IsRegistered(typeof(IEventBus))
? innerResolver.Resolve <IEventBus>()
: NullEventBus.Instance,
true
);
_commandContextAccessor =
new Lazy <IStoveCommandContextAccessor>(
() => innerResolver.Resolve <IStoveCommandContextAccessor>(),
true);
}
private async Task RunAsync(
Label label,
IScopeResolver scopeResolver,
Func <IResolver, CancellationToken, Task> taskFactory,
CancellationToken cancellationToken)
{
using (scopeResolver)
{
var taskId = Guid.NewGuid().ToString("N");
var stopwatch = Stopwatch.StartNew();
_log.Verbose($"Starting task '{label}' ({taskId})");
try
{
await taskFactory(scopeResolver, cancellationToken).ConfigureAwait(false);
_log.Verbose($"Task '{label}' ({taskId}) completed after {stopwatch.Elapsed.TotalSeconds:0.###} seconds");
}
catch (Exception e)
{
_log.Error(e, $"Task '{label}' ({taskId}) failed after {stopwatch.Elapsed.TotalSeconds:0.###} seconds with exception '{e.GetType().Name}': {e.Message}");
}
}
}
public StoveNHibernateInterceptor(IScopeResolver scopeResolver)
{
_scopeResolver = scopeResolver;
_stoveSession =
new Lazy <IStoveSession>(
() => _scopeResolver.IsRegistered(typeof(IStoveSession))
? _scopeResolver.Resolve <IStoveSession>()
: NullStoveSession.Instance,
isThreadSafe: true
);
_guidGenerator =
new Lazy <IGuidGenerator>(
() => _scopeResolver.IsRegistered(typeof(IGuidGenerator))
? _scopeResolver.Resolve <IGuidGenerator>()
: SequentialGuidGenerator.Instance,
isThreadSafe: true
);
_eventBus =
new Lazy <IEventBus>(
() => _scopeResolver.IsRegistered(typeof(IEventBus))
? _scopeResolver.Resolve <IEventBus>()
: NullEventBus.Instance,
isThreadSafe: true
);
}
public ScopeContext(string contextPath, IClientRegistry clientRegistry, IScopeResolver scopeResolver, IServiceInvoker serviceInvoker, IPersistenceStore persistanceStore) {
_contextPath = contextPath;
_clientRegistry = clientRegistry;
_scopeResolver = scopeResolver;
_persistanceStore = persistanceStore;
_serviceInvoker = serviceInvoker;
}
public StoveDbContextMigration(IScopeResolver resolver,
IStoveMigrationConfiguration configuration,
IEnumerable <IStoveMigration> stoveMigrations)
{
_resolver = resolver;
_configuration = configuration;
_stoveMigrations = stoveMigrations;
}
public ScopeContext(string contextPath, IClientRegistry clientRegistry, IScopeResolver scopeResolver, IServiceInvoker serviceInvoker, IPersistenceStore persistanceStore)
{
_contextPath = contextPath;
_clientRegistry = clientRegistry;
_scopeResolver = scopeResolver;
_persistanceStore = persistanceStore;
_serviceInvoker = serviceInvoker;
}
public UnitOfWorkManager(
IScopeResolver scopedResolver,
ICurrentUnitOfWorkProvider currentUnitOfWorkProvider,
IUnitOfWorkDefaultOptions defaultOptions)
{
_scopeResolver = scopedResolver;
_currentUnitOfWorkProvider = currentUnitOfWorkProvider;
_defaultOptions = defaultOptions;
}
public ScopeContext(string contextPath, IClientRegistry clientRegistry, IScopeResolver scopeResolver, IServiceInvoker serviceInvoker, IPersistenceStore persistanceStore)
{
this._contextPath = string.Empty;
this._contextPath = contextPath;
this._clientRegistry = clientRegistry;
this._scopeResolver = scopeResolver;
this._persistanceStore = persistanceStore;
this._serviceInvoker = serviceInvoker;
}
public virtual Boolean AddResolver(IScopeResolver <TPacket, TAddress> resolver)
{
if (InnerResolvers.Contains(resolver) == true)
{
return(false);
}
InnerResolvers.Add(resolver);
return(true);
}
static void Main(string[] args)
{
ScopeManager scopeManager = new ScopeManager();
ProjectScopeResolver projectScopeResolver = new ProjectScopeResolver(new HostingInformation(1, 1, "Magnus"));
scopeManager.AddResolver(projectScopeResolver);
IScopeResolver scopeResolver = scopeManager.GetResolver(ParameterScopeTypes.Project);
// string scopeName = scopeResolver.Resolve();
Console.WriteLine("Hello World!");
}
public IScopeResolver <TPacket, TAddress> InitializeResolver(CreateScopeResolverInformation resolverCreateModel)
{
IScopeResolver <TPacket, TAddress> resolver = GetResolverFromCreateModel(resolverCreateModel, true);
if (resolver is IScopeResolverContainingOtherResolvers <TPacket, TAddress> == true)
{
var resolverContainingOthers = (IScopeResolverContainingOtherResolvers <TPacket, TAddress>)resolver;
IEnumerable <CreateScopeResolverInformation> innenrResolvers = resolverContainingOthers.ExtractResolverCreateModels(resolverCreateModel, _serializer);
GenerateResolverTree(innenrResolvers, resolverContainingOthers);
}
return(resolver);
}
public AuthorizationRequestFactory(
IClientIdValidator clientIdValidator,
IRedirectUriResolver redirectUriValidator,
IScopeResolver scopeValidator,
IEnumerable <IAuthorizationRequestValidator> validators,
ProtocolErrorProvider errorProvider)
{
_clientIdValidator = clientIdValidator;
_redirectUrlValidator = redirectUriValidator;
_scopeValidator = scopeValidator;
_validators = validators;
_errorProvider = errorProvider;
}
public IEnumerable <ScopeResolverDescription> GetRegisterResolverDescription()
{
List <ScopeResolverDescription> result = new List <ScopeResolverDescription>();
foreach (var item in _resolverMapper)
{
IScopeResolver <TPacket, TAddress> resolver = item.Value();
ScopeResolverDescription resolverDescription = resolver.GetDescription();
result.Add(resolverDescription);
}
return(result);
}
public void Migrate <TDbContext, TConfiguration>(string nameOrConnectionString, Assembly migrationAssembly, Action <string> logger)
where TDbContext : DbContext
where TConfiguration : DbMigrationsConfiguration <TDbContext>, new()
{
logger($"MigrationStrategy: DbContext starting for {typeof(TDbContext).GetTypeInfo().Name}...");
using (IScopeResolver scope = _resolver.BeginScope())
{
var dbInitializer = scope.Resolve <StoveDbContextMigration <TDbContext> >();
dbInitializer.Migrate(logger);
}
logger($"MigrationStrategy: DbContext finished succesfully for {typeof(TDbContext).GetTypeInfo().Name}.");
}
protected void TestDescription(IScopeResolver <DHCPv6Packet, IPv6Address> resolver, String expectedName)
{
ScopeResolverDescription description = resolver.GetDescription();
Assert.NotNull(description);
Assert.Equal(expectedName, description.TypeName);
Assert.NotNull(description.Properties);
Assert.Single(description.Properties);
ScopeResolverPropertyDescription propertyDescription = description.Properties.First();
Assert.Equal("InnerResolvers", propertyDescription.PropertyName);
Assert.Equal(ScopeResolverPropertyValueTypes.Resolvers, propertyDescription.PropertyValueType);
}
public void Migrate <TDbContext, TConfiguration>(string nameOrConnectionString, Assembly migrationAssembly, Action <string> logger)
where TDbContext : DbContext
where TConfiguration : DbMigrationsConfiguration <TDbContext>, new()
{
logger($"MigrationStrategy: DbContext starting for {typeof(TDbContext).GetTypeInfo().Name}...");
using (IScopeResolver scope = _resolver.BeginScope())
{
var dbContext = scope.Resolve <TDbContext>(new { nameOrConnectionString });
var dbInitializer = new MigrateDatabaseToLatestVersion <TDbContext, TConfiguration>(true, new TConfiguration());
dbInitializer.InitializeDatabase(dbContext);
}
logger($"MigrationStrategy: DbContext finished succesfully for {typeof(TDbContext).GetTypeInfo().Name}.");
}
/// <summary>
/// Nolockings the specified queryable.
/// </summary>
/// <typeparam name="TEntity">The type of the entity.</typeparam>
/// <typeparam name="TPrimaryKey">The type of the primary key.</typeparam>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="repository">The repository.</param>
/// <param name="queryable">The queryable.</param>
/// <returns></returns>
public static TResult Nolocking <TEntity, TPrimaryKey, TResult>(this IRepository <TEntity, TPrimaryKey> repository, Func <IQueryable <TEntity>, TResult> queryable) where TEntity : class, IEntity <TPrimaryKey>
{
Check.NotNull(queryable, nameof(queryable));
TResult result;
using (IScopeResolver scopeResolver = repository.As <IStoveRepositoryBaseWithResolver>().ScopeResolver.BeginScope())
{
using (scopeResolver.Resolve <WithNoLockInterceptor>().UseNolocking())
{
result = queryable(repository.GetAll());
}
}
return(result);
}
public TokenRequestFactory(
IClientIdValidator clientIdValidator,
IRedirectUriResolver redirectUriValidator,
IScopeResolver scopeResolver,
IEnumerable <ITokenRequestValidator> validators,
ITokenManager tokenManager,
ITimeStampManager timeStampManager,
ProtocolErrorProvider errorProvider)
{
_clientIdValidator = clientIdValidator;
_redirectUriValidator = redirectUriValidator;
_scopeResolver = scopeResolver;
_validators = validators;
_tokenManager = tokenManager;
_errorProvider = errorProvider;
_timeStampManager = timeStampManager;
}
protected void HandleScopeAdded(TScope scope, ScopeCreateInstruction <TAddressProperties, TAddress, TScopeProperties, TScopeProperty, TOption, TValueType> instruction)
{
if (instruction.ParentId.HasValue == true)
{
TScope parent = _scopes[instruction.ParentId.Value];
scope.SetParent(parent);
}
else
{
_firstLevelScopes.Add(scope);
}
IScopeResolver <TPacket, TAddress> resolver = _resolverManager.InitializeResolver(instruction.ResolverInformation);
scope.SetResolver(resolver);
_scopes.Add(scope.Id, scope);
}
private IScopeResolver <TPacket, TAddress> GetResolverFromCreateModel(CreateScopeResolverInformation resolverCreateModel, Boolean applyValues)
{
String normalizeNamed = GetNormalizedMapperName(resolverCreateModel.Typename);
if (_resolverMapper.ContainsKey(normalizeNamed) == false)
{
throw new Exception();
}
IScopeResolver <TPacket, TAddress> resolver = _resolverMapper[normalizeNamed].Invoke();
if (applyValues == true)
{
resolver.ApplyValues(resolverCreateModel.PropertiesAndValues, _serializer);
}
return(resolver);
}
public RegistrationCompletedEventTests()
{
SampleClass sampleClassInstance = null;
Building(builder =>
{
builder.RegisterServices(r => r.RegisterType <SampleClass>());
builder.RegisterServices(r => r.RegistrationCompleted += (sender, args) =>
{
var scopeResolver = args.Resolver.Resolve <IScopeResolver>();
using (IScopeResolver scope = scopeResolver.BeginScope())
{
sampleClassInstance = scope.Resolve <SampleClass>();
}
});
});
sampleClassInstance.DisposeCount.Should().Be(1);
}
public bool IsResolverInformationValid(CreateScopeResolverInformation resolverCreateModel)
{
if (resolverCreateModel == null || String.IsNullOrEmpty(resolverCreateModel.Typename) == true)
{
return(false);
}
String normalizeNamed = GetNormalizedMapperName(resolverCreateModel.Typename);
if (_resolverMapper.ContainsKey(normalizeNamed) == false)
{
return(false);
}
IScopeResolver <TPacket, TAddress> resolver = _resolverMapper[normalizeNamed].Invoke();
Boolean result = resolver.ArePropertiesAndValuesValid(resolverCreateModel.PropertiesAndValues, _serializer);
if (result == true && resolver is IScopeResolverContainingOtherResolvers <TPacket, TAddress> resolvers)
{
var resolverContainingOthers = resolvers;
IEnumerable <CreateScopeResolverInformation> innenrResolvers = resolverContainingOthers.ExtractResolverCreateModels(resolverCreateModel, _serializer);
foreach (CreateScopeResolverInformation item in innenrResolvers)
{
Boolean childResult = IsResolverInformationValid(item);
if (childResult == false)
{
result = false;
break;
}
}
}
return(result);
}
internal void SetResolver(IScopeResolver <TPacket, TAddress> resolver) => Resolver = resolver;
public CreateTable(string tableName, IScopeResolver scopeResolver)
{
_tableName = tableName;
_scopeResolver = scopeResolver;
}
public SupportedScopeTypesResolver(IScopeResolver <ConfigurationTextPack> configTextPackScopeResolver)
{
_configTextPackScopeResolver = configTextPackScopeResolver;
}
public EfActiveTransactionProvider(IScopeResolver scopeResolver)
{
_scopeResolver = scopeResolver;
}
/// <summary>
/// Initializes a new instance of the <see cref="IocScopedResolver" /> class.
/// </summary>
/// <param name="scope">The scope.</param>
public IocScopedResolver(IScopeResolver scope)
{
_scope = scope;
}
/// <summary>
/// Constructor.
/// </summary>
public StoveMemoryCacheManager(IScopeResolver scopeResolver, ICachingConfiguration configuration)
: base(scopeResolver.BeginScope(), configuration)
{
}
public DbContextMigrationStrategy(IScopeResolver resolver)
{
_resolver = resolver;
}
/// <summary>
/// Constructs a new ScopeMiddleware
/// </summary>
/// <param name="next">OwinMiddleware</param>
/// <param name="resolver">IScopeResolver</param>
public ScopeMiddleware(OwinMiddleware next, IScopeResolver resolver)
: base(next)
{
this._resolver = resolver;
}
