//:id, :oType, :payload, :token, :locked, :dateFrom, :dateTo
        public bool AddCredential(Guid userId, IAuthenticationProvider provider, string token, string payload)
        {
            if (!Guid.Empty.Equals(userId) && provider != null && !string.IsNullOrEmpty(token) && !string.IsNullOrEmpty(payload))
            {
                try
                {
                    NpgsqlCommand cmd = Db.GetCmd(Db.ConnectionString);
                    cmd.CommandText = Db.Insert;
                    cmd.Parameters.AddWithValue("id", userId);
                    cmd.Parameters.AddWithValue("oType", TypeNameReference.Create(provider).ToString());
                    cmd.Parameters.AddWithValue("payload", payload);
                    cmd.Parameters.AddWithValue("token", token);
                    cmd.Parameters.AddWithValue("locked", false);
                    cmd.Parameters.AddWithValue("dateFrom", DateTime.UtcNow);
                    cmd.Parameters.AddWithValue("dateTo", new DateTime(3000, 1, 1)); //should move this to config

                    Db.ExecuteNonQuery(cmd);

                    return(true);
                }
                catch
                { }
            }
            return(false);
        }
Exemple #2
0
 protected override void BootstrapImpl()
 {
     lock (this.syncRoot)
     {
         this.State = RunState.Bootstrapping;
         try
         {
             ConfigurationProviderBase prov = ConfigurationManager.Instance.GetProvider();
             if (prov != null)
             {
                 ConfigurationParameter param = prov.Get(typeof(LogManager), "provider");
                 if (param != null)
                 {
                     string fName = (string)param.Value;
                     if (!string.IsNullOrEmpty(fName))
                     {
                         TypeNameReference tnr = TypeNameReference.Parse(fName, ',');
                         if (tnr != null)
                         {
                             this.Bootstrap(tnr);
                             return;
                         }
                     }
                 }
             }
         }
         catch
         { }
         this.State = RunState.FailedBootstrapping;
     }
 }
        protected internal override ConfigurationParameter GetImpl(string typeName, string name)
        {
            if (this.configs.ContainsKey(typeName))
            {
                if (this.configs[typeName].ContainsKey(name))
                {
                    return(ConfigurationParameter.Create(typeName, name, this.configs[typeName][name]));
                }
                else
                {
                    TypeNameReference ty = TypeNameReference.Parse(typeName);
                    if (ty != null) //try for a new file
                    {
                        string corePath = Path.GetDirectoryName(AppContext.BaseDirectory);
                        if (File.Exists(Path.Combine(corePath, ty.AssemblyFileName + ".jconfig")))
                        {
                            try
                            {
                                this.Init(Path.Combine(corePath, ty.AssemblyFileName + ".jconfig"));
                            }
                            catch
                            { }

                            if (this.configs[typeName].ContainsKey(name))
                            {
                                return(ConfigurationParameter.Create(typeName, name, this.configs[typeName][name]));
                            }
                        }
                    }
                }
            }
            return(null);
        }
 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;
         }
     }
 }
 protected override void BootstrapImpl()
 {
     lock (this.syncRoot)
     {
         try
         {
             this.State = RunState.Bootstrapping;
             string       corePath    = Path.GetDirectoryName(AppContext.BaseDirectory);
             JsonProvider tmpProvider = new JsonProvider();
             if (tmpProvider.Init(Path.Combine(corePath, "Osrs.Runtime.Configuration.jconfig")))
             {
                 Type   t    = typeof(ConfigurationManager);
                 string name = string.Format("{0}.{1}, {2}", t.Namespace, t.Name, t.GetTypeInfo().Assembly.GetName().Name);
                 ConfigurationParameter param = tmpProvider.GetImpl(name, "provider");
                 if (param != null)
                 {
                     string fName = (string)param.Value;
                     if (!string.IsNullOrEmpty(fName))
                     {
                         TypeNameReference tnr = TypeNameReference.Parse(fName, ',');
                         if (tnr != null)
                         {
                             Bootstrap(tnr, tmpProvider);
                             return;
                         }
                     }
                 }
             }
         }
         catch
         { }
         this.State = RunState.FailedBootstrapping;
     }
 }
Exemple #6
0
 public NewInstanceDependencyTarget(TypeNameReference targetType = default, IEnumerable <TypeNameReference> constructorSignature = default, bool isReadOnly = default)
     : base(isReadOnly: isReadOnly)
 {
     _targetType           = targetType;
     _constructorSignature =
         constructorSignature is null
                         ? (isReadOnly ? (new TypeNameReference[] { }).AsReadOnlyCollection() : (new TypeNameReference[] { }))
                         : (isReadOnly ? (ICollection <TypeNameReference>) new ListReadOnlyWrap <TypeNameReference>(collection: constructorSignature) : new List <TypeNameReference>(collection: constructorSignature));
 }
Exemple #7
0
 public TypeDependencyId(
     ITypeDependencyId other,
     bool isReadOnly = false)
     : base(isReadOnly: isReadOnly)
 {
     //
     other.EnsureNotNull(nameof(other));
     //
     _type = other.Type;
 }
Exemple #8
0
 public LogItem(TypeNameReference typeName, DateTime when, string eventId, ushort severity, string title, string exception, string message)
 {
     this.TypeName  = typeName;
     this.When      = when;
     this.EventId   = eventId;
     this.Severity  = severity;
     this.Title     = title;
     this.Exception = exception;
     this.Message   = message;
 }
 internal void Log(TypeNameReference typeName, DateTime when, string eventId, ushort severity, string title, Exception exception, string message)
 {
     if (exception != null)
     {
         this.Log(typeName, when, eventId, severity, title, exception.ToString(), message);
     }
     else
     {
         this.Log(typeName, when, eventId, severity, title, (string)null, message);
     }
 }
Exemple #10
0
 public virtual bool Equals(TypeDependencyId other)
 {
     if (ReferenceEquals(other, null))
     {
         return(false);
     }
     else
     {
         return(TypeNameReference.Equals(_type, other._type));
     }
 }
Exemple #11
0
        public void Bootstrap()
        {
            lock (instance)
            {
                if (RuntimeUtils.Bootstrappable(this.State))
                {
                    string meth = "Bootstrap";
                    this.State  = RunState.Bootstrapping;
                    this.logger = LogManager.Instance.GetProvider(typeof(IdentityManager));
                    Log(meth, LogLevel.Info, "Called");

                    ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
                    if (config != null)
                    {
                        ConfigurationParameter param = config.Get(typeof(IdentityManager), "provider");
                        if (param != null)
                        {
                            string tName = param.Value as string;
                            if (!string.IsNullOrEmpty(tName))
                            {
                                TypeNameReference typeName = TypeNameReference.Parse(tName);
                                if (typeName != null)
                                {
                                    IdentityConfiguration iConfig = new IdentityConfiguration();
                                    iConfig.FactoryTypeName = typeName;
                                    Bootstrap(iConfig);
                                    return;
                                }
                                else
                                {
                                    Log(meth, LogLevel.Error, "Failed to parse 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");
                    }


                    this.State = RunState.FailedBootstrapping;
                }
            }
        }
Exemple #12
0
        protected override void InitializeImpl()
        {
            lock (instance)
            {
                if (RuntimeUtils.Initializable(this.State))
                {
                    string meth = "Initialize";
                    this.State  = RunState.Initializing;
                    this.logger = LogManager.Instance.GetProvider(typeof(InstrumentManager));
                    Log(meth, LogLevel.Info, "Called");

                    ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
                    if (config != null)
                    {
                        ConfigurationParameter param = config.Get(typeof(InstrumentManager), "provider");
                        if (param != null)
                        {
                            string tName = param.Value as string;
                            if (!string.IsNullOrEmpty(tName))
                            {
                                TypeNameReference typeName = TypeNameReference.Parse(tName);
                                if (typeName != null)
                                {
                                    this.Initialize(typeName);
                                    return;
                                }
                                else
                                {
                                    Log(meth, LogLevel.Error, "Failed to parse role provider param value");
                                }
                            }
                            else
                            {
                                Log(meth, LogLevel.Error, "Failed to get role provider param value");
                            }
                        }
                        else
                        {
                            Log(meth, LogLevel.Error, "Failed to get role provider param");
                        }
                    }
                    else
                    {
                        Log(meth, LogLevel.Error, "Failed to get ConfigurationProvider");
                    }


                    this.State = RunState.FailedInitializing;
                }
            }
        }
Exemple #13
0
 protected override void Log(TypeNameReference typeName, DateTime when, string eventId, ushort severity, string title, string exception, string message)
 {
     lock (FlatFileLogFactory.syncRoot)
     {
         if (FlatFileLogFactory.writer != null)
         {
             LogItem tmp = new LogItem(typeName, when, eventId, severity, title, exception, message);
             FlatFileLogFactory.writer.WriteLine(tmp.ToString());
             FlatFileLogFactory.count++;
             if (FlatFileLogFactory.count > 99)
             {
                 FlatFileLogFactory.writer.Flush();
                 FlatFileLogFactory.count = 0;
             }
         }
     }
 }
Exemple #14
0
        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;
                }
            }
        }
Exemple #15
0
        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;
                }
            }
        }
Exemple #16
0
        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;
                }
            }
        }
Exemple #17
0
 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 bool Lock(IAuthenticationProvider provider, Guid userId)
        {
            if (provider != null && !Guid.Empty.Equals(userId))
            {
                try
                {
                    NpgsqlCommand cmd = Db.GetCmd(Db.ConnectionString);
                    cmd.CommandText = Db.Lock + "AND \"OwnerType\"=:oType";
                    cmd.Parameters.AddWithValue("id", userId);
                    cmd.Parameters.AddWithValue("oType", TypeNameReference.Create(provider).ToString());

                    Db.ExecuteNonQuery(cmd);

                    return(true);
                }
                catch
                { }
            }
            return(false);
        }
Exemple #19
0
 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 DeleteCredential(Guid userId, IAuthenticationProvider provider, string token)
        {
            if (!Guid.Empty.Equals(userId) && provider != null && !string.IsNullOrEmpty(token))
            {
                try
                {
                    NpgsqlCommand cmd = Db.GetCmd(Db.ConnectionString);
                    cmd.CommandText = Db.Delete;
                    cmd.Parameters.AddWithValue("id", userId);
                    cmd.Parameters.AddWithValue("oType", TypeNameReference.Create(provider).ToString());
                    cmd.Parameters.AddWithValue("token", token);

                    Db.ExecuteNonQuery(cmd);

                    return(true);
                }
                catch
                { }
            }
            return(false);
        }
        public bool Lock(IAuthenticationProvider provider, PersistedCredential credential)
        {
            if (provider != null && credential != null)
            {
                try
                {
                    NpgsqlCommand cmd = Db.GetCmd(Db.ConnectionString);
                    cmd.CommandText = Db.Lock + "AND \"OwnerType\"=:oType AND \"Token\"=:token";
                    cmd.Parameters.AddWithValue("id", credential.UserId);
                    cmd.Parameters.AddWithValue("oType", TypeNameReference.Create(provider).ToString());
                    cmd.Parameters.AddWithValue("token", credential.TextToken);

                    Db.ExecuteNonQuery(cmd);

                    return(true);
                }
                catch
                { }
            }
            return(false);
        }
        public IEnumerable <PersistedCredential> Get(IAuthenticationProvider provider, Guid userId, string token)
        {
            if (provider != null)
            {
                NpgsqlCommand cmd = Db.GetCmd(Db.ConnectionString);
                cmd.CommandText = Db.Select + "\"Id\"=:id AND \"OwnerType\"=:oType AND \"Token\"=:token";
                cmd.Parameters.AddWithValue("id", userId);
                cmd.Parameters.AddWithValue("oType", TypeNameReference.Create(provider).ToString());
                cmd.Parameters.AddWithValue("token", token);
                NpgsqlDataReader           rdr         = Db.ExecuteReader(cmd);
                List <PersistedCredential> permissions = new List <PersistedCredential>();
                try
                {
                    PersistedCredential o;
                    while (rdr.Read())
                    {
                        o = PgCredentialStoreFactory.Instance.Create(rdr);
                        if (o != null)
                        {
                            permissions.Add(o);
                        }
                    }
                    if (cmd.Connection.State == System.Data.ConnectionState.Open)
                    {
                        cmd.Connection.Close();
                    }
                }
                catch
                { }
                finally
                {
                    cmd.Dispose();
                }

                return(permissions);
            }
            return(null);
        }
        public bool UpdateCredential(IAuthenticationProvider provider, PersistedCredential credential, DateTime validFrom, DateTime validTo, bool isLocked)
        {
            if (provider != null && credential != null)
            {
                try
                {
                    NpgsqlCommand cmd = Db.GetCmd(Db.ConnectionString);
                    cmd.CommandText = Db.Update;
                    cmd.Parameters.AddWithValue("id", credential.UserId);
                    cmd.Parameters.AddWithValue("oType", TypeNameReference.Create(provider).ToString());
                    cmd.Parameters.AddWithValue("token", credential.TextToken);
                    cmd.Parameters.AddWithValue("dateFrom", validFrom);
                    cmd.Parameters.AddWithValue("dateTo", validTo);
                    cmd.Parameters.AddWithValue("locked", isLocked);

                    Db.ExecuteNonQuery(cmd);

                    return(true);
                }
                catch
                { }
            }
            return(false);
        }
Exemple #24
0
        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;
                }
            }
        }
Exemple #25
0
        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);
        }
Exemple #26
0
 protected internal override void Log(TypeNameReference typeName, DateTime when, string eventId, ushort severity, string title, string exception, string message)
 {
     MemoryLoggerFactory.Items.Add(new LogItem(typeName, when, eventId, severity, title, exception, message));
 }
 protected LogProviderBase(Type logType)
 {
     this.Type     = logType;
     this.typeName = TypeNameReference.Create(this.Type);
 }
 protected internal abstract void Log(TypeNameReference typeName, DateTime when, string eventId, ushort severity, string title, string exception, string message);
Exemple #29
0
 protected override bool Initialize()
 {
     lock (this)
     {
         if (!initialized)
         {
             ConfigurationProviderBase config = ConfigurationManager.Instance.GetProvider();
             if (config != null)
             {
                 Type myType = typeof(UserPasswordProviderFactory);
                 ConfigurationParameter parm = config.Get(myType, "historyProvider");
                 if (parm != null)
                 {
                     TypeNameReference fact = TypeNameReference.Parse((string)parm.Value);
                     if (fact != null)
                     {
                         UserPasswordConfig myConfig = new UserPasswordConfig();
                         myConfig.HistoryProvider = fact;
                         parm = config.Get(myType, "maxHistory");
                         if (parm != null)
                         {
                             try
                             {
                                 myConfig.MaxHistory = (ushort)(int)parm.Value;
                                 parm = config.Get(myType, "hashLength");
                                 if (parm != null)
                                 {
                                     try
                                     {
                                         myConfig.HashLength = (int)parm.Value;
                                         if (myConfig.HashLength > 0)
                                         {
                                             parm = config.Get(myType, "hashMinChar");
                                             if (parm != null)
                                             {
                                                 try
                                                 {
                                                     myConfig.MinChar = (char)(int)parm.Value;
                                                     if (myConfig.MinChar > 0)
                                                     {
                                                         parm = config.Get(myType, "hashMaxChar");
                                                         if (parm != null)
                                                         {
                                                             try
                                                             {
                                                                 myConfig.MaxChar = (char)(int)parm.Value;
                                                                 if (myConfig.MaxChar > 0)
                                                                 {
                                                                     //TODO -- add complexity rule config params
                                                                     return(this.Initialize(myConfig));
                                                                 }
                                                             }
                                                             catch
                                                             { }
                                                         }
                                                     }
                                                 }
                                                 catch
                                                 { }
                                             }
                                         }
                                     }
                                     catch
                                     { }
                                 }
                             }
                             catch
                             { }
                         }
                     }
                 }
             }
         }
     }
     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;
                }
            }
        }