protected override void DoConfigure(IConfigSectionNode node) { node.NonEmpty(nameof(GdidProviderModule) + ".conf"); base.DoConfigure(node); var isLocal = node.Of(CONFIG_LOCAL_ATTR).ValueAsBool(false); var naccessor = node[CONFIG_ACCESSOR_SECT]; if (!isLocal && naccessor.Exists) { var accessor = FactoryUtils.MakeAndConfigureDirectedComponent <IGdidAuthorityAccessor>(this, naccessor); m_Generator = new GdidGenerator(this, nameof(GdidProviderModule), ScopePrefix, SequencePrefix, accessor); } else { if (isLocal) { m_Generator = new LocalGdidGenerator(this); } else { m_Generator = new GdidGenerator(this, nameof(GdidProviderModule)); } } var ngen = node[CONFIG_GENERATOR_SECT]; if (ngen.Exists && m_Generator is IConfigurable configurable) { configurable.Configure(ngen); } }
internal Area(Heap director, IConfigSectionNode cfg) : base(director) { cfg.NonEmpty(nameof(cfg)); //1. Build Schema m_Schema = new TypeSchema(this, cfg[TypeSchema.CONFIG_SCHEMA_SECTION]); //2. Build Selector var cfgSelector = cfg[CONFIG_NODE_SELECTOR_SECTION]; m_NodeSelector = FactoryUtils.MakeDirectedComponent <INodeSelector>(this, cfgSelector, typeof(DefaultNodeSelector), new object[] { cfgSelector }); //3. Build Service Client var cfgClient = cfg[CONFIG_SERVICE_CLIENT_SECTION]; m_ServiceClient = FactoryUtils.MakeDirectedComponent <IHttpService>(this, cfgClient, typeof(HttpService), new object[] { cfgClient }); //4. Build Spaces m_Spaces = new Dictionary <Type, ISpace>(); foreach (var tObject in m_Schema.ObjectTypes) { var tSpace = typeof(Space <>).MakeGenericType(tObject); var space = Activator.CreateInstance(tSpace).CastTo <ISpace>("space .ctor"); m_Spaces.Add(tSpace, space); } }
protected WorkHandler(WorkDispatcher dispatcher, IConfigSectionNode confNode) : base(dispatcher) { confNode.NonEmpty(nameof(confNode)); ConfigAttribute.Apply(this, confNode); m_Dispatcher = dispatcher; m_Server = dispatcher.ComponentDirector; m_Name = confNode.AttrByName(Configuration.CONFIG_NAME_ATTR).Value; m_Order = confNode.AttrByName(Configuration.CONFIG_ORDER_ATTR).ValueAsInt(0); if (m_Name.IsNullOrWhiteSpace()) { m_Name = "{0}({1})".Args(GetType().FullName, Guid.NewGuid()); } foreach (var cn in confNode.Children.Where(cn => cn.IsSameName(WorkFilter.CONFIG_FILTER_SECTION))) { if (!m_Filters.Register(FactoryUtils.Make <WorkFilter>(cn, typeof(WorkFilter), args: new object[] { this, cn }))) { throw new WaveException(StringConsts.CONFIG_HANDLER_DUPLICATE_FILTER_NAME_ERROR.Args(cn.AttrByName(Configuration.CONFIG_NAME_ATTR).Value)); } } foreach (var cn in confNode.Children.Where(cn => cn.IsSameName(WorkMatch.CONFIG_MATCH_SECTION))) { if (!m_Matches.Register(FactoryUtils.Make <WorkMatch>(cn, typeof(WorkMatch), args: new object[] { cn }))) { throw new WaveException(StringConsts.CONFIG_HANDLER_DUPLICATE_MATCH_NAME_ERROR.Args(cn.AttrByName(Configuration.CONFIG_NAME_ATTR).Value)); } } }
protected byte[][] BuildKeysFromConfig(IConfigSectionNode config, string sectionName, int len) { var result = config.NonEmpty(nameof(config)) .Children .Where(c => c.IsSameName(sectionName) && c.ValOf(CONFIG_KEY_ATTR).IsNotNullOrWhiteSpace()) .Select(c => BuildKeyFromConfig(c, len)) .ToArray(); if (result.Length == 0) { throw new SecurityException("{0} config section `{1}` must contain at least one key entry".Args(GetType().Name, sectionName)); } foreach (var a in result) { if (a.Length != len) { throw new SecurityException("{0} config section `{1}` all keys must be of {2} bytes in length".Args(GetType().Name, sectionName, len)); } if (result.Any(a2 => a2 != a && a.MemBufferEquals(a2))) { throw new SecurityException("{0} config section `{1}` contains duplicate keys".Args(GetType().Name, sectionName)); } } return(result); }
protected override void DoConfigure(IConfigSectionNode node) { base.DoConfigure(node); var ndata = node.NonEmpty(nameof(node))[CONFIG_DATA_SECTION] .NonEmpty($"section `{CONFIG_DATA_SECTION}`"); m_Data = FactoryUtils.MakeAndConfigureDirectedComponent <IForestDataSource>(this, ndata, typeof(ForestDataSource)); }
protected LoginProvider(IIdpHandlerLogic handler, IConfigSectionNode cfg) : base(handler) { cfg.NonEmpty(nameof(cfg)); m_Name = cfg.Of(Configuration.CONFIG_NAME_ATTR).ValueAsAtom(Atom.ZERO).Value; m_Name.NonBlank("attribute ${0}".Args(Configuration.CONFIG_NAME_ATTR)); m_DefaultLoginType = cfg.Of(CONFIG_DEFAULT_LOGIN_TYPE_ATTR).ValueAsAtom(Atom.ZERO); SupportedLoginTypes.Any(t => t == m_DefaultLoginType) .IsTrue("Known login type"); }
protected override void DoConfigure(IConfigSectionNode node) { var nlog = node.NonEmpty(nameof(node))[CommonApplicationLogic.CONFIG_LOG_SECTION] .NonEmpty($"`{CommonApplicationLogic.CONFIG_LOG_SECTION}` config section"); DisposeAndNull(ref m_Log); m_Log = FactoryUtils.MakeAndConfigureDirectedComponent <ILogImplementation>(this, nlog, typeof(LogDaemon)); base.DoConfigure(node); }
protected internal Shard(ShardSet set, IConfigSectionNode conf) { m_Set = set.NonNull(nameof(set)); ConfigAttribute.Apply(this, conf.NonEmpty(nameof(conf))); m_Name = conf.ValOf(Configuration.CONFIG_NAME_ATTR).NonBlank("$name"); m_NameHash = ShardKey.ForString(m_Name); m_Weight = conf.Of(CONFIG_WEIGHT_ATTR).ValueAsDouble(1.0d); m_ConnectString = conf.Of(CONFIG_CONNECT_ATTR, CONFIG_CONNECT_STRING_ATTR).Value.NonBlank($"${CONFIG_CONNECT_ATTR}"); m_DatabaseName = conf.Of(CONFIG_DB_ATTR).Value.NonBlank($"${CONFIG_DB_ATTR}"); }
protected override void DoConfigure(IConfigSectionNode node) { node.NonEmpty(nameof(GdidAuthorityModule) + ".conf"); base.DoConfigure(node); var nauth = node[CONFIG_AUTHORITY_SECT]; nauth.NonEmpty("cfg section `{0}`".Args(CONFIG_AUTHORITY_SECT)); DisposeAndNull(ref m_Svc); m_Svc = FactoryUtils.MakeAndConfigureDirectedComponent <GdidAuthorityService>(this, nauth, typeof(GdidAuthorityService)); }
internal ServerLocation(IAMClient owner, IConfigSectionNode cfg) { Owner = owner; ConfigAttribute.Apply(this, cfg.NonEmpty(nameof(cfg))); if (Uri == null) { throw new IAMException(StringConsts.ARGUMENT_ERROR + "ServerLocation.ctor(uri==null)"); } if (Name.IsNullOrWhiteSpace()) { Name = Uri.AbsolutePath; } }
internal TypeSchema(IArea area, IConfigSectionNode cfg) { m_Area = area.NonNull(nameof(area)); if (!cfg.NonEmpty(nameof(cfg)).IsSameName(CONFIG_SCHEMA_SECTION)) { cfg = cfg[CONFIG_SCHEMA_SECTION]; } cfg.NonEmpty(nameof(CONFIG_SCHEMA_SECTION)); m_Assemblies = new Dictionary <string, BuildInformation>(StringComparer.OrdinalIgnoreCase); m_ObjectTypes = new Dictionary <string, Type>(StringComparer.OrdinalIgnoreCase); m_QueryTypes = new Dictionary <string, List <Type> >(StringComparer.OrdinalIgnoreCase); try { foreach (var node in cfg.ChildrenNamed(CONFIG_ASSEMBLY_SECTION)) { var fn = node.ValOf(CONFIG_FILE_ATTR).NonBlank("{0}/${1}".Args(node.RootPath, CONFIG_FILE_ATTR)); var asm = Assembly.LoadFrom(fn); var nsPat = node.ValOf(CONFIG_NS_PATTERN_ATTR).Default("*"); load(asm, nsPat); } //Computer version digest on SORTED assembly Build infos //the operation is deferred after all assemblies finished loading m_Version = 0; foreach (var entry in m_Assemblies.OrderBy(e => e.Key)) //(deterministic order) based on Assembly FQN { m_Version ^= ShardKey.ForString(entry.Value.Content); //compute version digest hash based on the BuildInfo } } catch (Exception error) { throw new ConfigException("Bad config of {0}: {1}".Args(nameof(TypeSchema), error.ToMessageWithType()), error); } }
protected byte[] BuildKeyFromConfig(IConfigSectionNode keyNode, int len) { var result = keyNode.NonEmpty(nameof(keyNode)) .AttrByName(CONFIG_KEY_ATTR) .ValueAsByteArray(null) ?? throw new SecurityException("{0} config section `{1}` does not contain a valid key byte array".Args(GetType().Name, keyNode.RootPath)); if (result.Length != len) { throw new SecurityException("{0} config section `{1}` keys must be of {2} bytes in length".Args(GetType().Name, keyNode.RootPath, len)); } return(result); }
private void ctor(WorkDispatcher dispatcher, IConfigSectionNode confNode) { confNode.NonEmpty(nameof(confNode)); ConfigAttribute.Apply(this, confNode); m_Dispatcher = dispatcher; m_Server = dispatcher.ComponentDirector; m_Name = confNode.AttrByName(Configuration.CONFIG_NAME_ATTR).Value; m_Order = confNode.AttrByName(Configuration.CONFIG_ORDER_ATTR).ValueAsInt(0); if (m_Name.IsNullOrWhiteSpace()) { throw new WaveException(StringConsts.ARGUMENT_ERROR + GetType().FullName + ".ctor(confNode$name==null|empty)"); } }
public ShardSet(IShardedCrudDataStoreImplementation director, IConfigSectionNode conf) : base(director) { ConfigAttribute.Apply(this, conf.NonEmpty(nameof(conf))); m_Name.NonBlank("$name"); m_Shards = new List <IShard>(); //read shards foreach (var nsh in conf.ChildrenNamed(CONFIG_SHARD_SECTION)) { var shard = director.MakeShard(this, nsh); if (m_Shards.Any(s => s.Name.EqualsIgnoreCase(shard.Name))) { throw new DataAccessException(StringConsts.DATA_SHARDING_DUPLICATE_SECTION_CONFIG_ERROR.Args(CONFIG_SHARD_SECTION, shard.Name)); } m_Shards.Add(shard); } m_Shards.IsTrue(s => s.Count > 0, StringConsts.DATA_SHARDING_AT_LEAST_ONE_CLAUSE); }
protected Cmdlet(AppRemoteTerminal terminal, IConfigSectionNode args) { m_Terminal = terminal.NonNull(nameof(terminal)); m_Args = args.NonEmpty(nameof(args)); }
protected CryptoMessageAlgorithm(ICryptoManagerImplementation director, IConfigSectionNode config) : base(director) { ConfigAttribute.Apply(this, config.NonEmpty("{0}.ctor(config=null|!Exists)".Args(GetType().Name))); }
/// <summary> /// Typically you would not call this .ctor directly unless you are temporarily mocking assumptions. /// Call <see cref="AssumptionsForCaller(string)"/> or <see cref="AssumptionsForCallerStory(string, string)"/> instead /// </summary> public Assumptions(AssumptionsType tp, IConfigSectionNode data) { Type = tp; Data = data.NonEmpty(nameof(data)); }
/// <summary> /// Warning: storing plain credentials in config file is not secure. Use this method for the most simplistic cases /// like unit testing /// </summary> public IDPasswordCredentials(IConfigSectionNode cfg) { cfg.NonEmpty(nameof(cfg)); ConfigAttribute.Apply(this, cfg); }
protected EndpointBase(TService service, IConfigSectionNode conf) : base(service) { ConfigAttribute.Apply(this, conf.NonEmpty(nameof(conf))); }