public static bool TryGet <T>(this IConfigResolver configResolver, string key, out T value)
{
var returnResult = configResolver.TryGet(key, typeof(T).GetTypeInfo(), out var returnValue);
value = (T)returnValue;
return(returnResult);
}
//////////////////////////////////////////////////////////////
/// <summary>
/// This factory method returns the appropriate resolver to
/// the consumer. The definition of "appropriate" is left
/// to the implementation of the config resolver.
/// </summary>
/// <param name="key">the key to be tested</param>
/// <param name="supplier">the potential new supplier</param>
/// <param name="current">the current supplier</param>
//////////////////////////////////////////////////////////////
public virtual IConfigResolver GetResolver(string key,
IConfigSupplier supplier,
IConfigResolver current)
{
IConfigResolver cr = null;
if (_debug.IsActive)
{
_debug.WriteLine("template: getting resolver for key: " + key);
_debug.WriteLine("template: supplier: " + supplier);
_debug.WriteLine("template: current: " + current);
}
// only do something if the supplier can read the key
if (supplier.CanRead(key))
{
cr = new DefaultConfigResolver(key, supplier);
}
else
{
return(current);
}
// if we get here, the supplier can read the key, so
// it is just a matter of hooking up the relationships
if (current != null)
{
current.Parent = cr;
cr = current;
}
return(cr);
}
private static void InitCacheManager(IWindsorContainer container, IConfigResolver localConfigResolver)
{
if (localConfigResolver.CacheManagerConfig().Items.Count == 0)
{
return;
}
localConfigResolver.CacheManagerConfig().Items.ForEach(m =>
{
Action <ConfigurationBuilderCachePart> settings;
var redisConfigName = $"{m.RedisConfigName}_connection";
if (!IocManager.Instance.IsRegistered(redisConfigName))
{
return;
}
var redisConnectionWrapper = IocManager.Instance.Resolve <IRedisConnectionWrapper>(redisConfigName);
switch (m.CacheModel)
{
case EumCacheModel.Redis:
{
settings = (o) => o.WithRedisConfiguration("redis", redisConnectionWrapper.Database().Multiplexer).WithMaxRetries(100).WithRetryTimeout(50).WithRedisBackplane("redis").WithRedisCacheHandle("redis", true); break;
}
case EumCacheModel.RuntimeRedis:
{
settings = (o) => o.WithMemoryCacheHandle("handleName").And.WithRedisConfiguration("redis", redisConnectionWrapper.Database().Multiplexer).WithMaxRetries(100).WithRetryTimeout(50).WithRedisBackplane("redis").WithRedisCacheHandle("redis", true); break;
}
default: return;
}
// 注册
container.Register(Component.For <ICacheManager>().Named(m.Name).ImplementedBy <Cache.CacheManager>().DependsOn(Dependency.OnValue(settings.GetType(), settings)).LifestyleSingleton());
});
}
//////////////////////////////////////////////////////////////
/// <summary>
/// This factory method returns the appropriate resolver to
/// the consumer. The definition of "appropriate" is left
/// to the implementation of the config resolver.
/// </summary>
/// <param name="key">the key to be tested</param>
/// <param name="supplier">the potential new supplier</param>
/// <param name="current">the current supplier</param>
//////////////////////////////////////////////////////////////
public override IConfigResolver GetResolver(string key,
IConfigSupplier supplier,
IConfigResolver current)
{
// unfortunately, this is pretty much cut-n-paste code
// reuse from the base class... :(
IConfigResolver cr = null;
// only do something if the supplier can read the key
if (supplier.CanRead(key))
{
cr = new WriteCaptureConfigResolver(key,
supplier, _write);
}
else
{
return(current);
}
// if we get here, the supplier can read the key, so
// it is just a matter of hooking up the relationships
if (current != null)
{
current.Parent = cr;
cr = current;
}
return(cr);
}
public Replicator(
IReplicationWorker replicationWorker,
IConfigResolver configResolver,
ILogger logger,
IUsageHelpProvider usageHelpProvider)
{
_replicationWorker = replicationWorker;
_configResolver = configResolver;
_logger = logger;
_usageHelpProvider = usageHelpProvider;
}
private static void InitConfig(IConfigResolver configResolver)
{
var config = configResolver.NLogConfig();
if (config == null || config.AppName == null)
{
configResolver.Set(new NLogConfig {
AppName = "Default"
});
configResolver.Save();
}
}
public void GetConfigResolverTest()
{
// Arrange.
IUnityContainer container = UnityFactory.GetContainer();
// Act.
IConfigResolver configResolver = container.Resolve <IConfigResolver>();
configResolver.ResolveConnectionString("TestConnStr");
// Assert.
Assert.NotNull(configResolver);
}
/// <summary>
/// 扫描所有继承FarseerConfig类的配置文件
/// </summary>
public override void PreInitialize()
{
IocManager.Container.Install(new ConfigurationInstaller());
// 取出本地配置解析器
_configResolver = IocManager.Resolve <IConfigResolver>("LocalConfigResolver");
// 扫描所有继承FarseerConfig类的配置文件
ScanAppendFarseerConfig();
// 加载配置文件
_configResolver.Load();
}
/// <inheritdoc />
private void InitConfig(IConfigResolver configResolver)
{
// 全局配置
var globalConfig = configResolver.Get <GlobalConfig>();
if (globalConfig == null)
{
configResolver.Set(new GlobalConfig {
AppName = ""
});
configResolver.Save();
}
}
private void InitConfig(IConfigResolver configResolver)
{
var config = configResolver.DbConfig();
if (config == null)
{
configResolver.Set(config = new DbConfig {
Items = new List <DbItemConfig> {
new DbItemConfig {
Name = "testDb", Server = "127.0.0.1"
}
}
});
configResolver.Save();
}
}
private static void InitConfig(IConfigResolver configResolver)
{
var config = configResolver.MongoConfig();
if (config == null || config.Items.Count == 0)
{
configResolver.Set(new MongoConfig {
Items = new List <MongoItemConfig> {
new MongoItemConfig {
Name = "Default", Server = "mongodb://127.0.0.1:27017"
}
}
});
configResolver.Save();
}
}
private void InitConfig(IConfigResolver configResolver)
{
var config = configResolver.KafkaConfig();
if (config == null || config.Items.Count == 0)
{
configResolver.Set(new KafkaConfig {
Items = new List <KafkaItemConfig> {
new KafkaItemConfig {
Name = "test", Server = "IP:Host"
}
}
});
configResolver.Save();
}
}
private void InitRedisConfig(IWindsorContainer container, IConfigResolver localConfigResolver)
{
if (localConfigResolver.RedisConfig().Items.Count == 0)
{
return;
}
localConfigResolver.RedisConfig().Items.ForEach(m =>
{
// 注册Redis连接
container.Register(Component.For <IRedisConnectionWrapper>().Named($"{m.Name}_connection").ImplementedBy <RedisConnectionWrapper>().DependsOn(Dependency.OnValue(m.GetType(), m)).LifestyleSingleton());
// 注册Redis管理
container.Register(Component.For <IRedisCacheManager>().Named(m.Name).ImplementedBy <RedisCacheManager>().DependsOn(Dependency.OnValue(m.GetType(), m), Dependency.OnValue(typeof(IRedisConnectionWrapper), _iocResolver.Resolve <IRedisConnectionWrapper>($"{m.Name}_connection"))).LifestyleSingleton());
});
}
private void InitConfig(IConfigResolver configResolver)
{
var config = configResolver.RedisConfig();
if (config == null || config.Items.Count == 0)
{
configResolver.Set(new RedisConfig {
Items = new List <RedisItemConfig> {
new RedisItemConfig {
Name = "testRedis", Server = "10.9.15.32:6388,10.9.15.38:6379,10.9.15.33:6383,10.9.15.36:6389,10.9.15.34:6382,10.9.15.35:6382,syncTimeout=60000"
}
}
});
configResolver.Save();
}
}
public void ResolveConnectionStringTest()
{
// Arrange.
IUnityContainer container = UnityFactory.GetContainer();
IConfigResolver configResolver = container.Resolve <IConfigResolver>();
Assert.NotNull(configResolver);
string connectionStringName = "TestConnStr";
string expectedResult = @"SERVER=.\SQLEXPRESS;Trusted_connection=yes;DATABASE=Test;";
// Act.
string actualResult = configResolver.ResolveConnectionString(connectionStringName);
// Assert.
Assert.Equal(expectedResult, actualResult);
}
private void InitConfig(IConfigResolver configResolver)
{
var config = configResolver.CacheManagerConfig();
if (config == null || config.Items.Count == 0)
{
configResolver.Set(new CacheManagerConfig {
Items = new List <CacheManagerItemConfig> {
new CacheManagerItemConfig {
Name = "test", RedisConfigName = "", CacheModel = EumCacheModel.Runtime
}
}
});
configResolver.Save();
}
}
private static void InitConfig(IConfigResolver configResolver)
{
var config = configResolver.ElasticSearchConfig();
if (config == null || config.Items.Count == 0)
{
configResolver.Set(new ElasticSearchConfig {
Items = new List <ElasticSearchItemConfig> {
new ElasticSearchItemConfig {
Name = "Default", Server = "http://10.9.15.141:9200"
}
}
});
configResolver.Save();
}
}
/// <inheritdoc />
private void InitConfig(IConfigResolver configResolver)
{
var config = configResolver.RocketMQConfig();
if (config == null || config.Items.Count == 0)
{
configResolver.Set(new RocketMQConfig {
Items = new List <RocketMQItemConfig> {
new RocketMQItemConfig {
Name = "test", Server = "", AccessKey = "AccessKey", SecretKey = "SecretKey", ProducerID = "ProducerID", ConsumerID = "ConsumerID", Topic = "Topic", Channel = ONSChannel.CLOUD, ConsumeThreadNums = 16
}
}
});
configResolver.Save();
}
}
//////////////////////////////////////////////////////////////
/// <summary>
/// This indexer provides access to a configuration
/// setting. If the setting does not exist, a null is
/// returned.
/// </summary>
//////////////////////////////////////////////////////////////
public string this[string key]
{
get
{
IConfigResolver cr = (IConfigResolver)_hash[key];
if (cr != null)
{
return(cr[key]);
}
return(null);
}
set
{
IConfigResolver cr = (IConfigResolver)_hash[key];
if (cr != null)
{
cr[key] = value;
}
}
}
public SymmetricTokenGenerator(IConfigResolver configResolver)
{
_configResolver = configResolver;
}
/// <summary> /// 获取配置文件 /// </summary> public static RedisConfig RedisConfig(this IConfigResolver resolver) => resolver.Get <RedisConfig>();
//
public CodeGenerationContext(IConfigResolver configResolver, ISchemaFetcher schemaFetcher)
{
_configResolver = configResolver;
_schemaFetcher = schemaFetcher;
}
public static IServiceCollection AddSecurity(this IServiceCollection services, IConfigResolver configResolver)
{
var resolver = configResolver.Resolve <AuthenticationConfig>();
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}
)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
RequireExpirationTime = true,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero,
ValidateIssuer = true,
ValidIssuer = "MyCommerce.Authentication",
ValidateAudience = false,
RequireSignedTokens = true,
IssuerSigningKey = new SymmetricSecurityKey(Convert.FromBase64String(resolver.Secret))
};
options.Events = new JwtBearerEvents
{
OnTokenValidated = ctx =>
{
return(Task.CompletedTask);
},
OnChallenge = ctx =>
{
return(Task.CompletedTask);
},
OnAuthenticationFailed = ctx =>
{
if (ctx.Exception.GetType() == typeof(SecurityTokenExpiredException))
{
ctx.Response.Headers.Add("Token-Expired", true.ToString().ToLower());
}
ctx.Fail("Not Authorized");
return(Task.CompletedTask);
}
};
});
return(services);
}
/// <summary> /// 获取配置文件 /// </summary> public static MongoConfig MongoConfig(this IConfigResolver resolver) => resolver.Get <MongoConfig>();
/// <summary> /// 获取配置文件 /// </summary> public static DbConfig DbConfig(this IConfigResolver resolver) => resolver.Get <DbConfig>();
public ConfigValueResolver(IConfigResolver configResolver)
{
_configResolver = configResolver;
}
/// <summary> /// 获取配置文件 /// </summary> public static NLogConfig NLogConfig(this IConfigResolver resolver) => resolver.Get <NLogConfig>();
/// <summary>
/// 获取配置文件
/// </summary>
public static RocketMQConfig RocketMQConfig(this IConfigResolver resolver) => resolver.Get <RocketMQConfig>() ?? new RocketMQConfig
{
Items = new List <RocketMQItemConfig>()
};
/// <summary>
/// 获取配置文件
/// </summary>
public static KafkaConfig KafkaConfig(this IConfigResolver resolver) => resolver.Get <KafkaConfig>() ?? new KafkaConfig
{
Items = new List <KafkaItemConfig>()
};
public AutoRegisterOptionsBuilder ConfigResolver(IConfigResolver configResolver)
{
Options.ConfigResolver = configResolver;
return(this);
}
