public void Shutdown() { lock (this.syncRoot) { GetLogger(); this.logger.Log(0, "Shutdown: Called"); this.State = RunState.Stopping; while (this.monitoring) { Thread.Sleep(5); //just try to let it finish a round of restarts } foreach (IHostedService cur in this.hostedServices) { cur.Shutdown(); if (cur.State != RunState.Shutdown) { this.logger.Log(0, "Shutdown: Failed to shutdown " + NameReflectionUtils.GetName(cur).ToString()); } } LogManager.Instance.Shutdown(); if (LogManager.Instance.State != RunState.Shutdown) { this.logger.Log(0, "Shutdown: Failed to shutdown " + NameReflectionUtils.GetName(LogManager.Instance).ToString()); } ConfigurationManager.Instance.Shutdown(); if (ConfigurationManager.Instance.State != RunState.Shutdown) { this.logger.Log(0, "Shutdown: Failed to shutdown " + NameReflectionUtils.GetName(ConfigurationManager.Instance).ToString()); } this.logger.Log(0, "Shutdown: Succeeded"); this.State = RunState.Shutdown; } }
public void Bootstrap(TypeNameReference configSource, ConfigurationProviderBase initialConfig) { lock (this.syncRoot) { if (RuntimeUtils.Bootstrappable(this.State) || this.State == RunState.Bootstrapping) { this.State = RunState.Bootstrapping; if (configSource != null) { this.initialProv = initialConfig; ConfigurationFactoryBase configFinal = NameReflectionUtils.CreateInstance <ConfigurationFactoryBase>(configSource); if (configFinal != null) { if (configFinal.Initialize()) { this.provider = configFinal; this.State = RunState.Bootstrapped; return; } else { this.provider = null; } } } this.State = RunState.FailedBootstrapping; } } }
public void Resume() //we left the monitor running, so we may not need to restart it { lock (this.syncRoot) { if (LogManager.Instance.State != RunState.Running) { LogManager.Instance.Start(); } this.logger.Log(0, "Resume: Called"); if (this.State == RunState.Paused) { this.State = RunState.Starting; foreach (IHostedService cur in this.hostedServices) { cur.Resume(); if (cur.State != RunState.Running) { this.logger.Log(0, "Resume: Failed to resume " + NameReflectionUtils.GetName(cur).ToString()); } } this.logger.Log(0, "Resume: Succeeded, restarting monitoring"); this.State = RunState.Running; if (!this.monitoring) { Task t = new Task(this.MonitorServices); t.Start(); } } else { this.logger.Log(0, "Resume: Called from improper state: " + this.State.ToString()); } } }
public void Pause() //leave the monitor running and never stop the logger -- just in case { lock (this.syncRoot) { this.logger.Log(0, "Pause: Called"); if (this.State == RunState.Running) { this.State = RunState.Stopping; foreach (IHostedService cur in this.hostedServices) { cur.Pause(); if (cur.State != RunState.Paused) { this.logger.Log(0, "Pause: Failed to pause " + NameReflectionUtils.GetName(cur).ToString()); } } this.logger.Log(0, "Pause: Succeeded"); this.State = RunState.Paused; } else { this.logger.Log(0, "Pause: Called from improper state: " + this.State.ToString()); } } }
protected NonSubclassableSingletonBase() : base() { lock (syncRoot) { if (created != null) { throw new SingletonException("Singleton instance already exists: " + created); } created = NameReflectionUtils.GetName(this); } }
public ObjectToStringBuilder(object thing) { if (thing == null) { this.sb.Append(ObjectToStringBuilder.NullLiteral); this.sb.Append(ObjectToStringBuilder.StartObject); } else { this.sb.Append(NameReflectionUtils.GetBaseName(thing)); this.sb.Append(ObjectToStringBuilder.StartObject); } }
protected override void InitializeImpl() { lock (instance) { if (RuntimeUtils.Initializable(this.State)) { string meth = "Initialize"; this.State = RunState.Initializing; this.logger = LogManager.Instance.GetProvider(typeof(UserAffilationSecurityManager)); Log(meth, LogLevel.Info, "Called"); ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider(); if (config != null) { ConfigurationParameter param = config.Get(NameReflectionUtils.GetType(TypeNameReference.Parse("Osrs.WellKnown.FieldActivities.Providers.PgFieldActivityProviderFactory, Osrs.WellKnown.FieldActivities.Providers.Postgres")), "connectionString"); if (param != null) { string tName = param.Value as string; if (!string.IsNullOrEmpty(tName)) { if (NpgSqlCommandUtils.TestConnection(tName)) { Db.ConnectionString = tName; this.initialized = true; this.State = RunState.Initialized; return; } } else { Log(meth, LogLevel.Error, "Failed to get connectionString param value"); } } else { Log(meth, LogLevel.Error, "Failed to get connectionString param"); } } else { Log(meth, LogLevel.Error, "Failed to get ConfigurationProvider"); } this.State = RunState.FailedInitializing; } } }
public void Start() { lock (this.syncRoot) { GetLogger(); this.logger.Log(0, "Start: Called"); if (this.State == RunState.Initialized || this.State == RunState.Stopped) { this.State = RunState.Starting; if (ConfigurationManager.Instance.State != RunState.Running) { ConfigurationManager.Instance.Start(); if (ConfigurationManager.Instance.State != RunState.Running) { this.logger.Log(0, "Start: Failed to start " + NameReflectionUtils.GetName(ConfigurationManager.Instance).ToString()); } } if (LogManager.Instance.State != RunState.Running) { LogManager.Instance.Start(); if (LogManager.Instance.State != RunState.Running) { this.logger.Log(0, "Start: Failed to start " + NameReflectionUtils.GetName(LogManager.Instance).ToString()); } } foreach (IHostedService cur in this.hostedServices) { cur.Start(); if (cur.State != RunState.Running) { this.logger.Log(0, "Start: Failed to start " + NameReflectionUtils.GetName(cur).ToString()); } } this.logger.Log(0, "Start: Succeeded, starting monitoring"); this.State = RunState.Running; Task t = new Task(this.MonitorServices); t.Start(); } else { this.logger.Log(0, "Start: Called from improper state: " + this.State.ToString()); } } }
public void Bootstrap(TypeNameReference logfactory) { lock (this.syncRoot) { if (RuntimeUtils.Bootstrappable(this.State) || this.State == RunState.Bootstrapping) { this.State = RunState.Bootstrapping; if (logfactory != null) { this.provider = new MemoryLoggerFactory(); this.provider.Initialize(); if (!logfactory.Equals(TypeNameReference.Create(typeof(MemoryLoggerFactory)))) //confirm we're not just using memory logger { LogProviderFactory configFinal = NameReflectionUtils.CreateInstance <LogProviderFactory>(logfactory); if (configFinal != null) { if (configFinal.Initialize()) { this.provider = configFinal; //for the time being foreach (LogItem cur in MemoryLoggerFactory.Items) { LogProviderBase log = this.provider.GetLogger(NameReflectionUtils.GetType(cur.TypeName)); if (log != null) { log.Log(cur.Severity, cur.Message); } } MemoryLoggerFactory.Items.Clear(); this.State = RunState.Bootstrapped; return; } } } else //permanent logger is memory logger, so do nothing else { this.State = RunState.Bootstrapped; return; } } this.provider = null; this.State = RunState.FailedBootstrapping; } } }
public void Bootstrap(TypeNameReference authFactoryType, TypeNameReference credFactoryType) { lock (instance) { if (this.State == RunState.Created || this.State == RunState.Bootstrapping) { this.State = RunState.Bootstrapping; string meth = "Bootstrap"; if (this.logger == null) //in case we're directly bootstrapping { this.logger = LogManager.Instance.GetProvider(typeof(AuthenticationManager)); Log(meth, LogLevel.Info, "Called"); } if (authFactoryType != null && credFactoryType != null) { this.credFactory = NameReflectionUtils.CreateInstance <CredentialStoreFactory>(credFactoryType); if (this.credFactory != null) { this.authFactory = NameReflectionUtils.CreateInstance <AuthenticationProviderFactory>(authFactoryType); if (this.authFactory != null) { Log(meth, LogLevel.Info, "Succeeded"); this.State = RunState.Bootstrapped; return; } else { Log(meth, LogLevel.Error, "Failed to create authentication factory instance"); } } else { Log(meth, LogLevel.Error, "Failed to create credential factory instance"); } } else { Log(meth, LogLevel.Error, "No typename provided"); } this.State = RunState.FailedBootstrapping; } } }
public void Initialize(TypeNameReference providerFactory) { lock (instance) { if (RuntimeUtils.Initializable(this.State) || this.State == RunState.Initializing) { this.State = RunState.Initializing; string meth = "Initialize"; if (this.logger == null) //in case we're directly bootstrapping { this.logger = LogManager.Instance.GetProvider(typeof(InstrumentManager)); Log(meth, LogLevel.Info, "Called"); } if (providerFactory != null) { this.factory = NameReflectionUtils.CreateInstance <InstrumentProviderFactoryBase>(providerFactory); if (this.factory != null) { if (this.factory.Initialize()) { this.factory.LocalContext = new UserSecurityContext(new LocalSystemUser(user.Uid, user.Name, user.UserState)); Log(meth, LogLevel.Info, "Succeeded"); this.State = RunState.Initialized; return; } else { Log(meth, LogLevel.Error, "Failed to initialize provider factory instance"); } } else { Log(meth, LogLevel.Error, "Failed to create permission factory instance"); } } else { Log(meth, LogLevel.Error, "No typename provided"); } this.State = RunState.FailedInitializing; } } }
public void Bootstrap(IdentityConfiguration config) { lock (instance) { if (RuntimeUtils.Bootstrappable(this.State) || this.State == RunState.Bootstrapping) { this.State = RunState.Bootstrapping; string meth = "Bootstrap"; if (this.logger == null) //in case we're directly bootstrapping { this.logger = LogManager.Instance.GetProvider(typeof(IdentityManager)); Log(meth, LogLevel.Info, "Called"); } if (config != null) { TypeNameReference typ = config.FactoryTypeName; if (typ != null) { this.factory = NameReflectionUtils.CreateInstance <IdentityProviderFactory>(typ); if (this.factory != null) { Log(meth, LogLevel.Info, "Succeeded"); this.State = RunState.Bootstrapped; return; } else { Log(meth, LogLevel.Error, "Failed to create factory instance"); } } else { Log(meth, LogLevel.Error, "Failed to extract typename"); } } else { Log(meth, LogLevel.Error, "No config provided"); } this.State = RunState.FailedBootstrapping; } } }
public void Stop() { lock (this.syncRoot) { GetLogger(); this.logger.Log(0, "Stop: Called"); if (this.State == RunState.Running || this.State == RunState.Paused) { this.State = RunState.Stopping; while (this.monitoring) { Thread.Sleep(5); //just try to let it finish a round of restarts } foreach (IHostedService cur in this.hostedServices) { cur.Stop(); if (cur.State != RunState.Stopped) { this.logger.Log(0, "Stop: Failed to stop " + NameReflectionUtils.GetName(cur).ToString()); } } ConfigurationManager.Instance.Stop(); if (ConfigurationManager.Instance.State != RunState.Stopped) { this.logger.Log(0, "Stop: Failed to stop " + NameReflectionUtils.GetName(ConfigurationManager.Instance).ToString()); } this.logger.Log(0, "Stop: Succeeded"); //try to make sure we can log this event before we kill the logger LogManager.Instance.Stop(); if (LogManager.Instance.State != RunState.Stopped) { this.logger.Log(0, "Stop: Failed to stop " + NameReflectionUtils.GetName(LogManager.Instance).ToString()); //ha! may or may not actually log } this.State = RunState.Stopped; } else { this.logger.Log(0, "Stop: Called from improper state: " + this.State.ToString()); } } }
public void Bootstrap(TypeNameReference factoryType, uint sessionDuration) { lock (instance) { if (RuntimeUtils.Bootstrappable(this.State) || this.State == RunState.Bootstrapping) { if (factoryType != null) { SessionProviderFactory fact = NameReflectionUtils.CreateInstance <SessionProviderFactory>(factoryType); if (fact != null) { this.factory = fact; this.SessionDuration = sessionDuration; this.State = RunState.Bootstrapped; return; } } this.State = RunState.FailedBootstrapping; } } }
public bool Initialize(UserPasswordConfig config) { lock (this) { if (config != null && !this.initialized) { if (config.HistoryProvider != null) { this.HistoryProvider = this.HistoryProvider = NameReflectionUtils.CreateInstance <UserPasswordHistoryProviderFactory>(config.HistoryProvider); if (this.HistoryProvider != null) { if (this.HistoryProvider.Initialize()) { this.MaxHistory = config.MaxHistory; if (config.MinChar < config.MaxChar) { try { this.Shaker = new SaltShaker((char)config.MinChar, (char)config.MaxChar, config.HashLength, SaltCreationModel.Repeatable, SaltEmbeddingModel.Randomized, -1); foreach (PasswordComplexityRule curRule in config.Rules) { if (curRule != null) { this.ComplexityChecker.Rules.Add(curRule); } } this.initialized = true; return(true); } catch { } } } } } } } return(false); }
protected override bool Initialize() { lock (instance) { if (!this.initialized) { string meth = "Initialize"; this.logger = LogManager.Instance.GetProvider(typeof(CachingPermissionProviderFactory)); Log(meth, LogLevel.Info, "Called"); ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider(); if (config != null) { ConfigurationParameter param = config.Get(typeof(CachingPermissionProviderFactory), "provider"); if (param != null) { string tName = param.Value as string; if (!string.IsNullOrEmpty(tName)) { TypeNameReference typeName = TypeNameReference.Parse(tName); if (typeName != null) { innerFact = NameReflectionUtils.CreateInstance <PermissionProviderFactory>(typeName); if (innerFact != null) { if (InitializeOther(innerFact)) { //ok preload the cache LocalSystemUser u = new LocalSystemUser(SecurityUtils.AdminIdentity, "Admin", UserState.Active); IPermissionProvider prov = this.GetProviderOther(this.innerFact, new UserSecurityContext(u)); if (prov != null) { IEnumerable <Permission> perms = prov.GetPermissions(); if (perms != null) { foreach (Permission p in perms) { PermissionMemorySet.RegisterPermission(p); } this.initialized = true; return(true); } else { Log(meth, LogLevel.Error, "Failed to get existing permissions"); } } else { Log(meth, LogLevel.Error, "Failed to get inner provider for preload"); } } else { Log(meth, LogLevel.Error, "Failed to initialize inner provider"); } } else { Log(meth, LogLevel.Error, "Failed to create inner provider factory"); } } else { Log(meth, LogLevel.Error, "Failed to parse permission provider param value"); } } else { Log(meth, LogLevel.Error, "Failed to get provider param value"); } } else { Log(meth, LogLevel.Error, "Failed to get provider param"); } } else { Log(meth, LogLevel.Error, "Failed to get ConfigurationProvider"); } } } return(false); }
public void Bootstrap(AuthorizationConfiguration config) { lock (instance) { if (RuntimeUtils.Bootstrappable(this.State) || this.State == RunState.Bootstrapping) { this.State = RunState.Bootstrapping; string meth = "Bootstrap"; if (this.logger == null) //in case we're directly bootstrapping { this.logger = LogManager.Instance.GetProvider(typeof(AuthorizationManager)); Log(meth, LogLevel.Info, "Called"); } if (config != null) { TypeNameReference typ = config.PermissionFactoryTypeName; if (typ != null) { this.permissionFactory = NameReflectionUtils.CreateInstance <PermissionProviderFactory>(typ); if (this.permissionFactory != null) { typ = config.RoleFactoryTypeName; if (typ != null) { this.roleFactory = NameReflectionUtils.CreateInstance <RoleProviderFactory>(typ); if (this.roleFactory != null) { this.roleFactory.LocalContext = new UserSecurityContext(new LocalSystemUser(user.Uid, user.Name, user.UserState)); this.permissionFactory.LocalContext = new UserSecurityContext(new LocalSystemUser(user.Uid, user.Name, user.UserState)); Log(meth, LogLevel.Info, "Succeeded"); this.State = RunState.Bootstrapped; return; } else { Log(meth, LogLevel.Error, "Failed to create role factory instance"); } } else { Log(meth, LogLevel.Error, "Failed to extract role typename"); } } else { Log(meth, LogLevel.Error, "Failed to create permission factory instance"); } } else { Log(meth, LogLevel.Error, "Failed to extract permission typename"); } } else { Log(meth, LogLevel.Error, "No config provided"); } this.State = RunState.FailedBootstrapping; } } }
protected override bool Initialize() { lock (instance) { if (!this.initialized) { string meth = "Initialize"; this.logger = LogManager.Instance.GetProvider(typeof(CachingRoleProviderFactory)); Log(meth, LogLevel.Info, "Called"); ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider(); if (config != null) { ConfigurationParameter param = config.Get(typeof(CachingRoleProviderFactory), "provider"); if (param != null) { string tName = param.Value as string; if (!string.IsNullOrEmpty(tName)) { TypeNameReference typeName = TypeNameReference.Parse(tName); if (typeName != null) { innerFact = NameReflectionUtils.CreateInstance <RoleProviderFactory>(typeName); if (innerFact != null) { if (InitializeOther(innerFact)) { //ok preload the cache LocalSystemUser u = new LocalSystemUser(SecurityUtils.AdminIdentity, "Admin", UserState.Active); IRoleProvider prov = this.GetProviderOther(this.innerFact, new UserSecurityContext(u)); if (prov != null) { if (RoleMemorySet.Reset(prov)) { if (RoleMembershipMemorySet.Reset(prov)) { this.initialized = true; scavengeTimer = new Timer(this.Scavenge, null, 0, 300000); //5 minutes return(true); } else { Log(meth, LogLevel.Error, "Failed to initialize caching"); } } else { Log(meth, LogLevel.Error, "Failed to initialize caching"); } } else { Log(meth, LogLevel.Error, "Failed to get inner provider for preload"); } } else { Log(meth, LogLevel.Error, "Failed to initialize inner provider"); } } else { Log(meth, LogLevel.Error, "Failed to create inner provider factory"); } } else { Log(meth, LogLevel.Error, "Failed to parse permission provider param value"); } } else { Log(meth, LogLevel.Error, "Failed to get permission provider param value"); } } else { Log(meth, LogLevel.Error, "Failed to get provider param"); } } else { Log(meth, LogLevel.Error, "Failed to get ConfigurationProvider"); } } } return(false); }
public void Initialize(IEnumerable <TypeNameReference> typeList) { lock (this.syncRoot) { if (this.State == RunState.Created) { if (ConfigurationManager.Instance.State == RunState.Created) { ConfigurationManager.Instance.Bootstrap(); ConfigurationManager.Instance.Initialize(); } if (ConfigurationManager.Instance.State == RunState.Initialized) { ConfigurationManager.Instance.Start(); } if (LogManager.Instance.State == RunState.Created) { LogManager.Instance.Bootstrap(); LogManager.Instance.Initialize(); } if (LogManager.Instance.State == RunState.Initialized) { LogManager.Instance.Start(); //make sure we have something to log to } this.logger = null; GetLogger(); this.logger.Log(0, "Initialize: Called"); //at this point, the logging and configuration services are running if (typeList == null) { this.logger.Log(0, "Initialize: Null typeList, exiting"); return; } if (ConfigurationManager.Instance.State != RunState.Running) { this.logger.Log(100, "Initialize: ConfigurationManager failed to initialize"); } if (LogManager.Instance.State != RunState.Running) { this.logger.Log(100, "Initialize: LogManager failed to initialize"); } foreach (TypeNameReference cur in typeList) { try { IHostedService b = ReflectionUtils.Get <IHostedService>(cur); if (b != null) { this.hostedServices.Add(b); b.Initialize(); if (b.State != RunState.Initialized) { this.logger.Log(5, "Initialize: Init failed for " + NameReflectionUtils.GetName(b).ToString()); } } else { this.logger.Log(5, "Initialize: Load failed for " + cur); } } catch { } } this.logger.Log(0, "Initialize: Succeeded"); this.State = RunState.Initialized; } else { this.logger.Log(0, "Initialize: Called from improper state: " + this.State.ToString()); } } }
private void MonitorServices() { this.monitoring = true; while (this.State == RunState.Running) { foreach (IHostedService cur in this.hostedServices) { if (cur.State == RunState.FailedRunning) //only try to restart failed services { try { this.logger.Log(1000, "MonitorServices: Discovered failed service, attempting restart: " + NameReflectionUtils.GetName(cur).ToString()); cur.Start(); if (cur.State == RunState.FailedStarting) { this.logger.Log(1000, "MonitorServices: restart failed: " + NameReflectionUtils.GetName(cur).ToString()); } } catch { } //suck it up and keep going } } Thread.Sleep(5000); //5 seconds } this.monitoring = false; }