Пример #1
0
        public UpdateSqlBuilder(IDbConfig dbConfig)
        {
            DbConfig = dbConfig;
            DbType   = dbConfig?.DbType ?? SupportedDatabaseTypes.Postgres;

            UpdateFieldSelector = new UpdateFieldSelector <TClass>(DbConfig);
        }
 public ConsumerRocksDbProvider(string basePath, IDbConfig dbConfig, ILogManager logManager)
 {
     ConsumerDepositApprovalsDb = new ConsumerDepositApprovalsRocksDb(basePath, dbConfig, logManager);
     ConsumerReceiptsDb         = new ConsumerReceiptsRocksDb(basePath, dbConfig, logManager);
     ConsumerSessionsDb         = new ConsumerSessionsRocksDb(basePath, dbConfig, logManager);
     DepositsDb = new DepositsRocksDb(basePath, dbConfig, logManager);
 }
Пример #3
0
        private void UpdateDbConfig(uint cpuCount, ISyncConfig syncConfig, IDbConfig dbConfig, IInitConfig initConfig)
        {
            if (initConfig.DiagnosticMode == DiagnosticMode.MemDb)
            {
                DbMemory = _remainingMemory;
                return;
            }

            DbMemory = _remainingMemory;
            long    remaining = DbMemory;
            DbNeeds dbNeeds   = GetHeaderNeeds(cpuCount, syncConfig);
            DbGets  dbGets    = GiveItWhatYouCan(dbNeeds, DbMemory, remaining);

            remaining -= dbGets.CacheMem + dbGets.Buffers * dbGets.SingleBufferMem;
            dbConfig.HeadersDbWriteBufferNumber = dbGets.Buffers;
            dbConfig.HeadersDbWriteBufferSize   = (ulong)dbGets.SingleBufferMem;
            dbConfig.HeadersDbBlockCacheSize    = (ulong)dbGets.CacheMem;

            dbNeeds    = GetBlocksNeeds(cpuCount, syncConfig);
            dbGets     = GiveItWhatYouCan(dbNeeds, DbMemory, remaining);
            remaining -= dbGets.CacheMem + dbGets.Buffers * dbGets.SingleBufferMem;
            dbConfig.BlocksDbWriteBufferNumber = dbGets.Buffers;
            dbConfig.BlocksDbWriteBufferSize   = (ulong)dbGets.SingleBufferMem;
            dbConfig.BlocksDbBlockCacheSize    = (ulong)dbGets.CacheMem;

            dbNeeds    = GetBlockInfosNeeds(cpuCount, syncConfig);
            dbGets     = GiveItWhatYouCan(dbNeeds, DbMemory, remaining);
            remaining -= dbGets.CacheMem + dbGets.Buffers * dbGets.SingleBufferMem;
            dbConfig.BlockInfosDbWriteBufferNumber = dbGets.Buffers;
            dbConfig.BlockInfosDbWriteBufferSize   = (ulong)dbGets.SingleBufferMem;
            dbConfig.BlockInfosDbBlockCacheSize    = (ulong)dbGets.CacheMem;

            dbNeeds    = GetReceiptsNeeds(cpuCount, syncConfig);
            dbGets     = GiveItWhatYouCan(dbNeeds, DbMemory, remaining);
            remaining -= dbGets.CacheMem + dbGets.Buffers * dbGets.SingleBufferMem;
            dbConfig.ReceiptsDbWriteBufferNumber = dbGets.Buffers;
            dbConfig.ReceiptsDbWriteBufferSize   = (ulong)dbGets.SingleBufferMem;
            dbConfig.ReceiptsDbBlockCacheSize    = (ulong)dbGets.CacheMem;

            dbNeeds    = GetCodeNeeds(cpuCount, syncConfig);
            dbGets     = GiveItWhatYouCan(dbNeeds, DbMemory, remaining);
            remaining -= dbGets.CacheMem + dbGets.Buffers * dbGets.SingleBufferMem;
            dbConfig.CodeDbWriteBufferNumber = dbGets.Buffers;
            dbConfig.CodeDbWriteBufferSize   = (ulong)dbGets.SingleBufferMem;
            dbConfig.CodeDbBlockCacheSize    = (ulong)dbGets.CacheMem;

            dbNeeds    = GetPendingTxNeeds(cpuCount, syncConfig);
            dbGets     = GiveItWhatYouCan(dbNeeds, DbMemory, remaining);
            remaining -= dbGets.CacheMem + dbGets.Buffers * dbGets.SingleBufferMem;
            dbConfig.PendingTxsDbWriteBufferNumber = dbGets.Buffers;
            dbConfig.PendingTxsDbWriteBufferSize   = (ulong)dbGets.SingleBufferMem;
            dbConfig.PendingTxsDbBlockCacheSize    = (ulong)dbGets.CacheMem;

            dbNeeds    = GetStateNeeds(cpuCount, syncConfig);
            dbGets     = GiveItWhatYouCan(dbNeeds, DbMemory, remaining);
            remaining -= dbGets.CacheMem + dbGets.Buffers * dbGets.SingleBufferMem;
            dbConfig.WriteBufferNumber = dbGets.Buffers;
            dbConfig.WriteBufferSize   = (ulong)dbGets.SingleBufferMem;
            dbConfig.BlockCacheSize    = (ulong)dbGets.CacheMem;
        }
Пример #4
0
        private void InitDbApi(IInitConfig initConfig, IDbConfig dbConfig, bool storeReceipts)
        {
            switch (initConfig.DiagnosticMode)
            {
            case DiagnosticMode.RpcDb:
                _api.DbProvider = new DbProvider(DbModeHint.Persisted);
                var rocksDbFactory = new RocksDbFactory(dbConfig, _api.LogManager, Path.Combine(initConfig.BaseDbPath, "debug"));
                var rpcDbFactory   = new RpcDbFactory(new MemDbFactory(), rocksDbFactory, _api.EthereumJsonSerializer, new BasicJsonRpcClient(new Uri(initConfig.RpcDbUrl), _api.EthereumJsonSerializer, _api.LogManager), _api.LogManager);
                _api.RocksDbFactory = rpcDbFactory;
                _api.MemDbFactory   = rpcDbFactory;
                break;

            case DiagnosticMode.ReadOnlyDb:
                var rocksDbProvider = new DbProvider(DbModeHint.Persisted);
                _api.DbProvider = new ReadOnlyDbProvider(rocksDbProvider, storeReceipts);     // ToDo storeReceipts as createInMemoryWriteStore - bug?
                _api.DisposeStack.Push(rocksDbProvider);
                _api.RocksDbFactory = new RocksDbFactory(dbConfig, _api.LogManager, Path.Combine(initConfig.BaseDbPath, "debug"));
                _api.MemDbFactory   = new MemDbFactory();
                break;

            case DiagnosticMode.MemDb:
                _api.DbProvider     = new DbProvider(DbModeHint.Mem);
                _api.RocksDbFactory = new RocksDbFactory(dbConfig, _api.LogManager, Path.Combine(initConfig.BaseDbPath, "debug"));
                _api.MemDbFactory   = new MemDbFactory();
                break;

            default:
                _api.DbProvider     = new DbProvider(DbModeHint.Persisted);
                _api.RocksDbFactory = new RocksDbFactory(dbConfig, _api.LogManager, initConfig.BaseDbPath);
                _api.MemDbFactory   = new MemDbFactory();
                break;
            }
        }
        public MongoCollectionBase(IDbConfig dbConfig, string collectionName)
        {
            var client = new MongoClient(dbConfig.ConnectionString);
            var db     = client.GetDatabase(DATABASE_NAME);

            collection = db.GetCollection <T>(collectionName);
        }
Пример #6
0
        /// <inheritdoc/>
        public IDatabaseInterface Boot(IDbConfig config)
        {
            if (booted)
            {
                throw new DataException("Database was booted more than once.");
            }

            // Local connections are formatted as;
            // 'Local/[type]/[connect_id]'
            string hostString = String.Format("{0}/Boot/", KnownConnectionProtocols.Local);

            // Start the DbSystem and bind it to a IDatabaseInterface.
            if (controller.IsInitialized(databaseName))
            {
                dbsys = controller.ConnectToDatabase(config, databaseName);
            }
            else
            {
                dbsys = controller.StartDatabase(config, databaseName);
            }

            IDatabaseInterface dbInterface = new LocalDatabaseInterface(this, hostString);

            booted = true;
            ++openConnections;

            return(dbInterface);
        }
Пример #7
0
 protected ColumnsDb(string basePath, string dbPath, IDbConfig dbConfig, ILogManager logManager, params T[] keys) : base(basePath, dbPath, dbConfig, logManager, GetColumnFamilies(keys))
 {
     foreach (var key in keys)
     {
         _columnDbs[key] = new ColumnDb(Db, this, key.ToString());
     }
 }
Пример #8
0
        private async Task <RocksDbProvider> GetRocksDbProvider(IDbConfig dbConfig, string basePath, bool useReceiptsDb)
        {
            RocksDbProvider debugRecorder = new RocksDbProvider(_context.LogManager);
            await debugRecorder.Init(basePath, dbConfig, useReceiptsDb);

            return(debugRecorder);
        }
Пример #9
0
        public DbOnTheRocks(string basePath, string dbPath, IDbConfig dbConfig, ILogManager logManager = null) // TODO: check column families
        {
            string fullPath = dbPath.GetApplicationResourcePath(basePath);

            _logger = logManager?.GetClassLogger() ?? NullLogger.Instance;
            if (!Directory.Exists(fullPath))
            {
                Directory.CreateDirectory(fullPath);
            }

            if (_logger.IsInfo)
            {
                _logger.Info($"Using database directory {fullPath}");
            }

            try
            {
                DbOptions options = BuildOptions(dbConfig);
                _db = DbsByPath.GetOrAdd(fullPath, path => RocksDb.Open(options, path));
            }
            catch (DllNotFoundException e) when(e.Message.Contains("libdl"))
            {
                throw new ApplicationException($"Unable to load 'libdl' necessary to init the RocksDB database. Please run{Environment.NewLine}" +
                                               "sudo apt update && sudo apt install libsnappy-dev libc6-dev libc6");
            }
        }
Пример #10
0
 public PersonRepository(
     ILogger <PersonRepository> logger,
     IDbConfig dbConfig)
 {
     Logger   = logger;
     DbConfig = dbConfig;
 }
Пример #11
0
        public async Task Init(string basePath, IDbConfig dbConfig, bool useReceiptsDb)
        {
            HashSet <Task> allInitializers = new HashSet <Task>();

            allInitializers.Add(Task.Run(() => BlocksDb      = new BlocksRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => HeadersDb     = new HeadersRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => BlockInfosDb  = new BlockInfosRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => StateDb       = new StateDb(new StateRocksDb(basePath, dbConfig, _logManager))));
            allInitializers.Add(Task.Run(() => CodeDb        = new StateDb(new CodeRocksDb(basePath, dbConfig, _logManager))));
            allInitializers.Add(Task.Run(() => PendingTxsDb  = new PendingTxsRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => BloomDb       = new BloomRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => ChtDb         = new CanonicalHashRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => ConfigsDb     = _addNdmDbs ? new ConfigsRocksDb(basePath, dbConfig, _logManager) : (IDb) new MemDb()));
            allInitializers.Add(Task.Run(() => EthRequestsDb = _addNdmDbs ? new EthRequestsRocksDb(basePath, dbConfig, _logManager) : (IDb) new MemDb()));

            allInitializers.Add(Task.Run(() =>
            {
                if (useReceiptsDb)
                {
                    ReceiptsDb = new ReceiptsRocksDb(basePath, dbConfig, _logManager);
                }
                else
                {
                    ReceiptsDb = new ReadOnlyColumnsDb <ReceiptsColumns>(new MemColumnsDb <ReceiptsColumns>(), false);
                }
            }));

            await Task.WhenAll(allInitializers);
        }
        /// <summary>
        /// Get granting users from configuration
        /// </summary>
        /// <param name="dbConfig"></param>
        /// <returns></returns>
        public static IEnumerable <string> GetUserGrantsFromConfig(this IDbConfig dbConfig)
        {
            var userGrants = dbConfig.GetAllDatabaseConfigValues()
                             .Where(x => x.Key.ContainsIgnoreCase("grants:users") && x.Value.IsNotEmpty())
                             .Select(x => x.Value)
                             .ToList();

            if (userGrants.Any() == false && UserGrantsFromConfigKey.IsNotEmpty())
            {
                var outboxSchema = dbConfig.GetAllDatabaseConfigValues().FirstOrDefault(x =>
                                                                                        x.Key.EqualsIgnoreCase($"database:{UserGrantsFromConfigKey}Schema") && x.Value.IsNotEmpty()).Value;
                var schema = dbConfig.GetAllDatabaseConfigValues().FirstOrDefault(x =>
                                                                                  x.Key.EqualsIgnoreCase("database:schema") && x.Value.IsNotEmpty()).Value;

                if (string.Equals(outboxSchema, schema, StringComparison.OrdinalIgnoreCase))
                {
                    userGrants = dbConfig.GetAllDatabaseConfigValues()
                                 .Where(x => x.Key.ContainsIgnoreCase($"grants:{UserGrantsFromConfigKey}Users") && x.Value.IsNotEmpty())
                                 .Select(x => x.Value)
                                 .ToList();
                }
            }

            var defaultAppUser = dbConfig.GetAllDatabaseConfigValues().GetValue("defaultApp:user");

            if (defaultAppUser.IsNotEmpty())
            {
                userGrants.Add(defaultAppUser);
            }

            var result = userGrants.Distinct().SelectMany(userGrant => userGrant.Split(',')).ToArray();

            return(result.Select(x => x.Trim()).Distinct());
        }
Пример #13
0
    protected override DbOptions BuildOptions(IDbConfig dbConfig)
    {
        DbOptions options = base.BuildOptions(dbConfig);

        options.SetCreateMissingColumnFamilies();
        return(options);
    }
Пример #14
0
        public async Task Execute(CancellationToken _)
        {
            ILogger logger = _api.LogManager.GetClassLogger();

            /* sync */
            IDbConfig      dbConfig      = _api.Config <IDbConfig>();
            ISyncConfig    syncConfig    = _api.Config <ISyncConfig>();
            IInitConfig    initConfig    = _api.Config <IInitConfig>();
            IPruningConfig pruningConfig = _api.Config <IPruningConfig>();

            foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
            {
                if (logger.IsDebug)
                {
                    logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
                }
            }

            try
            {
                bool useReceiptsDb = initConfig.StoreReceipts || syncConfig.DownloadReceiptsInFastSync;
                InitDbApi(initConfig, dbConfig, initConfig.StoreReceipts || syncConfig.DownloadReceiptsInFastSync);
                StandardDbInitializer dbInitializer = new(_api.DbProvider, _api.RocksDbFactory, _api.MemDbFactory, _api.FileSystem, pruningConfig.Mode.IsFull());
                await dbInitializer.InitStandardDbsAsync(useReceiptsDb);
            }
            catch (TypeInitializationException e)
            {
                if (logger.IsError)
                {
                    logger.Error("RocksDb was not found, please make sure it is installed on your machine. \n On macOs : 'brew install rocksdb'", e);
                }
            }
        }
Пример #15
0
        public RocksDbProvider(string dbBasePath, ILogManager logManager, IDbConfig dbConfig)
        {
            _logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));

            _stateDb = new SnapshotableDb(new DbOnTheRocks(Path.Combine(dbBasePath, DbOnTheRocks.StateDbPath), dbConfig));
            _codeDb  = new SnapshotableDb(new DbOnTheRocks(Path.Combine(dbBasePath, DbOnTheRocks.CodeDbPath), dbConfig));
        }
Пример #16
0
        public async Task Execute()
        {
            ILogger logger = _context.LogManager.GetClassLogger();

            /* sync */
            IDbConfig   dbConfig   = _context.Config <IDbConfig>();
            ISyncConfig syncConfig = _context.Config <ISyncConfig>();
            IInitConfig initConfig = _context.Config <IInitConfig>();

            foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
            {
                if (logger.IsDebug)
                {
                    logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
                }
            }

            _context.DbProvider = await GetDbProvider(initConfig, dbConfig, initConfig.StoreReceipts || syncConfig.DownloadReceiptsInFastSync);

            if (syncConfig.BeamSync)
            {
                BeamSyncDbProvider beamSyncProvider = new BeamSyncDbProvider(_context.DbProvider, "processor DB", _context.LogManager);
                _context.DbProvider       = beamSyncProvider;
                _context.NodeDataConsumer = beamSyncProvider.NodeDataConsumer;
            }
        }
 public ExtendedOracleMigrationGenerator(
     OracleQuoterBase quoter,
     IDbConfig dbConfig)
 {
     Quoter   = quoter;
     DbConfig = dbConfig;
 }
Пример #18
0
        public CommanderService(IDbConfig settings)
        {
            var client   = new MongoClient(settings.ConnectionString);
            var database = client.GetDatabase(settings.DbName);

            _CommandCollection = database.GetCollection <Command>(settings.Command);
        }
Пример #19
0
        public static string GetAdminConnectionString(this IDbConfig dbConfig)
        {
            var dbType = dbConfig.DbType;

            AssertDbConnectionImplemented(dbType);
            return(DbConnectionProviders[dbType].GetAdminConnectionString(dbConfig));
        }
Пример #20
0
        /// <inheritdoc/>
        public IDatabaseInterface Create(string username, string password, IDbConfig config)
        {
            if (String.IsNullOrEmpty(username) ||
                String.IsNullOrEmpty(password))
            {
                throw new DataException("Username and Password must both be set.");
            }

            if (booted)
            {
                throw new DataException("Database is already created.");
            }

            // Local connections are formatted as;
            // 'Local/[type]/[connect_id]'
            string hostString = String.Format("{0}/Create/", KnownConnectionProtocols.Local);

            // Create the DbSystem and bind it to a IDatabaseInterface.
            dbsys = controller.CreateDatabase(config, databaseName, username, password);
            IDatabaseInterface dbInterface = new LocalDatabaseInterface(this, hostString);

            booted = true;
            ++openConnections;

            return(dbInterface);
        }
Пример #21
0
        public RocksDbProvider(string basePath, IDbConfig dbConfig, ILogManager logManager)
        {
            BlocksDb = new DbOnTheRocks(
                Path.Combine(basePath, DbOnTheRocks.BlocksDbPath),
                dbConfig, logManager);

            BlockInfosDb = new DbOnTheRocks(
                Path.Combine(basePath, DbOnTheRocks.BlockInfosDbPath),
                dbConfig, logManager);

            ReceiptsDb = new DbOnTheRocks(
                Path.Combine(basePath, DbOnTheRocks.ReceiptsDbPath),
                dbConfig, logManager);

            StateDb = new StateDb(
                new DbOnTheRocks(Path.Combine(basePath, DbOnTheRocks.StateDbPath), dbConfig, logManager));

            CodeDb = new StateDb(
                new DbOnTheRocks(Path.Combine(basePath, DbOnTheRocks.CodeDbPath), dbConfig, logManager));

            PendingTxsDb = new DbOnTheRocks(
                Path.Combine(basePath, DbOnTheRocks.PendingTxsDbPath),
                dbConfig, logManager);

            TraceDb = new DbOnTheRocks(
                Path.Combine(basePath, DbOnTheRocks.TraceDbPath),
                dbConfig, logManager);
        }
 public ExtendedPostgresGenerator(
     PostgresQuoter quoter,
     IDbConfig dbConfig)
 {
     Quoter   = quoter;
     DbConfig = dbConfig;
 }
Пример #23
0
        public async Task Execute(CancellationToken _)
        {
            ILogger logger = _context.LogManager.GetClassLogger();

            /* sync */
            IDbConfig   dbConfig   = _context.Config <IDbConfig>();
            ISyncConfig syncConfig = _context.Config <ISyncConfig>();
            IInitConfig initConfig = _context.Config <IInitConfig>();

            foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
            {
                if (logger.IsDebug)
                {
                    logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
                }
            }

            _context.DbProvider = await GetDbProvider(initConfig, dbConfig, initConfig.StoreReceipts || syncConfig.DownloadReceiptsInFastSync);

            if (syncConfig.BeamSync)
            {
                _context.SyncModeSelector = new PendingSyncModeSelector();
                BeamSyncDbProvider beamSyncProvider = new BeamSyncDbProvider(_context.SyncModeSelector, _context.DbProvider, _context.Config <ISyncConfig>(), _context.LogManager);
                _context.DbProvider = beamSyncProvider;
            }
        }
Пример #24
0
        public RocksDbProvider(string basePath, IDbConfig dbConfig, ILogManager logManager, bool useTraceDb, bool useReceiptsDb)
        {
            BlocksDb      = new BlocksRocksDb(basePath, dbConfig, logManager);
            HeadersDb     = new HeadersRocksDb(basePath, dbConfig, logManager);
            BlockInfosDb  = new BlockInfosRocksDb(basePath, dbConfig, logManager);
            StateDb       = new StateDb(new StateRocksDb(basePath, dbConfig, logManager));
            CodeDb        = new StateDb(new CodeRocksDb(basePath, dbConfig, logManager));
            PendingTxsDb  = new PendingTxsRocksDb(basePath, dbConfig, logManager);
            ConfigsDb     = new ConfigsRocksDb(basePath, dbConfig, logManager);
            EthRequestsDb = new EthRequestsRocksDb(basePath, dbConfig, logManager);

            if (useReceiptsDb)
            {
                ReceiptsDb = new ReceiptsRocksDb(basePath, dbConfig, logManager);
            }
            else
            {
                ReceiptsDb = new ReadOnlyDb(new MemDb(), false);
            }

            if (useTraceDb)
            {
                TraceDb = new TraceRocksDb(basePath, dbConfig, logManager);
            }
            else
            {
                TraceDb = new ReadOnlyDb(new MemDb(), false);
            }
        }
Пример #25
0
        public async Task Init(string basePath, IDbConfig dbConfig, bool useReceiptsDb)
        {
            _dbConfig = dbConfig;
            _basePath = basePath;

            HashSet <Task> allInitializers = new HashSet <Task>();

            allInitializers.Add(Task.Run(() => BlocksDb     = new BlocksRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => HeadersDb    = new HeadersRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => BlockInfosDb = new BlockInfosRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => StateDb      = new StateDb(new StateRocksDb(basePath, dbConfig, _logManager))));
            allInitializers.Add(Task.Run(() => CodeDb       = new StateDb(new CodeRocksDb(basePath, dbConfig, _logManager))));
            allInitializers.Add(Task.Run(() => PendingTxsDb = new PendingTxsRocksDb(basePath, dbConfig, _logManager)));
            allInitializers.Add(Task.Run(() => BloomDb      = new BloomRocksDb(basePath, dbConfig, _logManager)));

            allInitializers.Add(Task.Run(() =>
            {
                if (useReceiptsDb)
                {
                    ReceiptsDb = new ReceiptsRocksDb(basePath, dbConfig, _logManager);
                }
                else
                {
                    ReceiptsDb = new ReadOnlyDb(new MemDb(), false);
                }
            }));

            await Task.WhenAll(allInitializers);
        }
Пример #26
0
        /// <summary>
        /// Return a new instance if IDbConnection created from dbConfig settings
        /// </summary>
        /// <param name="dbConfig"></param>
        /// <param name="withAdminPrivileges">If true, a IDbConnection with AdminConnectionString is created</param>
        /// <returns></returns>
        public static IDbConnection CreateDbConnection(this IDbConfig dbConfig, bool withAdminPrivileges = false)
        {
            var dbType = dbConfig.DbType;

            AssertDbConnectionImplemented(dbType);
            AssertDbProviderFactoryImplemented(dbType);
            return(dbConfig.GetDbProviderFactory(withAdminPrivileges).CreateConnection());
        }
Пример #27
0
 public string GetAdminConnectionString(IDbConfig dbConfig) =>
 string.Format(dbConfig.ConnectionStringTemplate ?? DefaultConnectionStringTemplate,
               dbConfig.AdminUser.ToUpper(),
               dbConfig.AdminPassword,
               dbConfig.Hostname,
               dbConfig.Port,
               dbConfig.DatabaseConnectionName.ToLower(),
               dbConfig.Pooling);
Пример #28
0
 public SimpleRocksDb(
     string basePath,
     RocksDbSettings rocksDbSettings,
     IDbConfig dbConfig,
     ILogManager logManager = null)
     : base(basePath, rocksDbSettings, dbConfig, logManager)
 {
 }
Пример #29
0
 protected static void InitCache(IDbConfig dbConfig)
 {
     if (Interlocked.CompareExchange(ref _cacheInitialized, 1, 0) == 0)
     {
         _cache = RocksDbSharp.Native.Instance.rocksdb_cache_create_lru(new UIntPtr(dbConfig.BlockCacheSize));
         Interlocked.Add(ref _maxRocksSize, (long)dbConfig.BlockCacheSize);
     }
 }
Пример #30
0
 public DbMetricsUpdater(string dbName, DbOptions dbOptions, RocksDb db, IDbConfig dbConfig, ILogger logger)
 {
     _dbName    = dbName;
     _dbOptions = dbOptions;
     _db        = db;
     _dbConfig  = dbConfig;
     _logger    = logger;
 }
Пример #31
0
 public static void SetTo(IDbConfig config)
 {
     //config.SetKey(DatabaseName);
     config.SetKey(IgnoreIdentifiersCase);
     config.SetKey(MaxWorkerThreads);
     config.SetKey(ReadOnly);
     config.SetKey(DefaultSchema);
     config.SetKey(AutoCommit);
 }
Пример #32
0
        /// <summary>
        /// Constructs the <see cref="DbConfig"/> from the given parent.
        /// </summary>
        /// <param name="parent">The parent <see cref="DbConfig"/> object that
        /// will provide fallback configurations</param>
        /// <param name="source"></param>
        public DbConfig(IDbConfig parent, IConfigSource source)
            : this(false)
        {
            Parent = parent;
            Source = source;

            if (source != null)
                this.Load(source);
        }
Пример #33
0
        public SystemContext(IDbConfig configuration)
        {
            if (configuration == null)
                throw new ArgumentNullException("configuration");

            Configuration = configuration;
            EventRegistry = new SystemEventRegistry(this);

            Init();
        }
Пример #34
0
        public override void Configure(IDbConfig config)
        {
            base.Configure(config);

            // Find a prime hash size depending on the size of the cache.
            int hashSize = ClosestPrime(MaxCacheSize / 55);
            nodeHash = new ListNode[hashSize];

            listStart = null;
            listEnd = null;
        }
Пример #35
0
        internal DbSystem(DbController controller, string name, IDbConfig config, IDatabase database)
        {
            this.name = name;
            this.controller = controller;
            this.config = config;
            this.Database = database;
            internalCounter = 0;

            // Register the shut down delegate,
            database.Context.OnShutdown += new EventHandler(Shutdown);

            // Enable commands to the database system...
            database.Context.IsExecutingCommands = true;
        }
Пример #36
0
 public DbContext(string cnsconfig, bool transaction, IsolationLevel il)
 {
     _cfg = GetConfiguration(cnsconfig);
     _cn = _cfg.GetConnection();
     _cmd = _cn.CreateCommand();
     _da = _cfg.GetDataAdapter(_cmd);
     if (transaction)
     {
         _trans = _cn.BeginTransaction(il);
         _cmd.Transaction = _trans;
     }
     else
     {
         _trans = null;
     }
 }
Пример #37
0
        public DatabaseContext(ISystemContext systemContext, IDbConfig configuration)
        {
            if (systemContext == null)
                throw new ArgumentNullException("systemContext");
            if (configuration == null)
                throw new ArgumentNullException("configuration");

            SystemContext = systemContext;
            SystemContext.ServiceProvider.AttachContext(this);

            Configuration = configuration;
            Locker = new Locker(this);

            Sessions = new ActiveSessionList(this);

            Init();
        }
Пример #38
0
        public IServerConnector Boot(IDbConfig config)
        {
            if (IsBooted)
                throw new DatabaseException("Database was booted more than once.");

            // Start the DbSystem and bind it to a IDatabaseInterface.
            if (System.Controller.IsInitialized(databaseName))
                dbsys = System.Controller.ConnectToDatabase(config, databaseName);
            else
                dbsys = System.Controller.StartDatabase(config, databaseName);

            var connector = new LocalEmbeddedServerConnector(this);

            IsBooted = true;
            ++openConnections;

            return connector;
        }
Пример #39
0
 /// <summary>
 /// This object can not be constructed publicaly.
 /// </summary>
 private DbController(IDbConfig configContext)
 {
     this.configContext = configContext;
     databases = new Hashtable();
     SetupLog(configContext);
 }
Пример #40
0
 public UserRepository(IDbConfig config)
 {
     _config = config;
 }
Пример #41
0
        // ---------- Static methods ----------
        /// <summary>
        /// Creates a Database object for the given DbConfig configuration.
        /// </summary>
        /// <param name="config"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        private static IDatabase CreateDatabase(IDbConfig config, string name)
        {
            var context = new DatabaseContext();

            // Initialize the DatabaseSystem first,
            // ------------------------------------

            // This will throw an Error exception if the database system has already
            // been initialized.
            context.Init(config);

            // Start the database class
            // ------------------------

            var database = new Database(context, name);

            // Start up message
            database.Context.Logger.Trace(typeof(DbController), "Starting Database Server");

            return database;
        }
Пример #42
0
 public DbConfig(IDbConfig parent)
     : this(parent, null)
 {
 }
Пример #43
0
        // ---------- Private methods ----------
        /// <summary>
        /// Disposes of all the resources associated with this system.
        /// </summary>
        /// <remarks>
        /// It may only be called from the shutdown delegate registered 
        /// in the constructor.
        /// </remarks>
        private void InternalDispose()
        {
            if (connections != null && connections.Count > 0) {
                ArrayList list = new ArrayList(connections.Keys);
                for (int i = list.Count - 1; i >= 0; i--) {
                    int id = (int) list[i];
                    IDbConnection connection = connections[id] as IDbConnection;

                    try {
                        if (connection != null)
                            connection.Dispose();
                    } catch(Exception) {
                        // we ignore this ...
                    }
                }
            }

            connections = null;
            controller = null;
            config = null;
        }
Пример #44
0
        private bool ChangeDatabaseInterface(IDbConfig config, string databaseName)
        {
            if (!controller.DatabaseExists(config, databaseName))
                return false;

            DatabaseInterface dbi;
            if (!dbInterfaces.TryGetValue(databaseName, out dbi)) {
                dbi = new DatabaseInterface(controller, databaseName, hostString);
                dbInterfaces[databaseName] = dbi;
            }

            Database = controller.GetDatabase(databaseName);
            dbInterface = dbi;
            return true;
        }
Пример #45
0
 public TrackRepository(IDbConfig config)
 {
     _config = config;
 }
Пример #46
0
        /// <inheritdoc/>
        public IDatabaseInterface Create(string username, string password, IDbConfig config)
        {
            if (String.IsNullOrEmpty(username) ||
                String.IsNullOrEmpty(password))
                throw new DataException("Username and Password must both be set.");

            if (booted)
                throw new DataException("Database is already created.");

            // Local connections are formatted as;
            // 'Local/[type]/[connect_id]'
            string hostString = String.Format("{0}/Create/", KnownConnectionProtocols.Local);

            // Create the DbSystem and bind it to a IDatabaseInterface.
            dbsys = controller.CreateDatabase(config, databaseName, username, password);
            IDatabaseInterface dbInterface = new LocalDatabaseInterface(this, hostString);

            booted = true;
            ++openConnections;

            return dbInterface;
        }
Пример #47
0
        /// <inheritdoc/>
        public IDatabaseInterface Boot(IDbConfig config)
        {
            if (booted)
                throw new DataException("Database was booted more than once.");

            // Local connections are formatted as;
            // 'Local/[type]/[connect_id]'
            string hostString = String.Format("{0}/Boot/", KnownConnectionProtocols.Local);

            // Start the DbSystem and bind it to a IDatabaseInterface.
            if (controller.IsInitialized(databaseName))
                dbsys = controller.ConnectToDatabase(config, databaseName);
            else
                dbsys = controller.StartDatabase(config, databaseName);

            IDatabaseInterface dbInterface = new LocalDatabaseInterface(this, hostString);

            booted = true;
            ++openConnections;

            return dbInterface;
        }
Пример #48
0
 public QueryReader(IDbConfig config)
     : base(config.ConnectionString)
 {
 }
Пример #49
0
        private static IDbConfig GetConfig(IDbConfig parentConfig, string path, string configFile)
        {
            if (configFile == null)
                configFile = DefaultConfigFileName;

            configFile = Path.Combine(path, configFile);

            bool fileExists = File.Exists(configFile);
            if (!fileExists) {
                // if we didn't find the file where it was supposed to be, try to
                // look for a .conf file into the directory...
                string[] files = Directory.GetFiles(path, "*.conf");

                // if, and only if, we have exactly one .conf file set it as our
                // config file, otherwise we quit...
                configFile = files.Length == 1 ? Path.GetFileName(files[0]) : configFile;
                fileExists = files.Length == 1;
            }

            if (!fileExists)
                return parentConfig;

            // if the config file exists, we load the settings from there...
            //TODO: support more formats

            var config = new DbConfig(parentConfig);
            config.Load(configFile);
            return config;
        }
Пример #50
0
 public DataManagerFactory(IDbConfig Config)
 {
     config = Config;
 }
Пример #51
0
 private void SetupLog(IDbConfig config)
 {
     //TODO:
     Logger = new EmptyLogger();
 }
Пример #52
0
        public IServerConnector Create(IDbConfig config, string userName, string password)
        {
            if (String.IsNullOrEmpty(userName))
                throw new ArgumentNullException("userName");
            if (String.IsNullOrEmpty(password))
                throw new ArgumentNullException("password");

            if (IsBooted)
                throw new DatabaseException("The database was already booted.");

            // Create the DbSystem and bind it to a IDatabaseInterface.
            dbsys = System.Controller.CreateDatabase(config, databaseName, userName, password);
            var connector = new LocalEmbeddedServerConnector(this);

            IsBooted = true;
            ++openConnections;

            return connector;
        }
Пример #53
0
 public void Init(IDbConfig config)
 {
 }
Пример #54
0
        public bool CheckExists(IDbConfig config)
        {
            if (IsBooted)
                return true;

            return System.Controller.DatabaseExists(config, databaseName);
        }
Пример #55
0
        /// <summary>
        /// Gets the type of storage for the system defined in the
        /// configuration given.
        /// </summary>
        /// <param name="config">The <see cref="DbConfig">database 
        /// configuration object</see> that defines the storage system 
        /// for which to retrieve its kind of storage.</param>
        /// <returns>
        /// Returns a <see cref="StorageType"/> defined by the storage
        /// system configured.
        /// </returns>
        /// <seealso cref="GetStorageType(string)"/>
        private static StorageType GetStorageType(IDbConfig config)
        {
            // if we don't have any configuration given let's assume it's in-memory
            if (config == null)
                return StorageType.Memory;

            string typeName = config.StorageSystem();
            if (typeName == null)
                throw new InvalidOperationException("A storage system must be specified.");

            return GetStorageType(typeName);
        }
Пример #56
0
        public IServerConnector Connect(IDbConfig config)
        {
            if (!IsBooted)
                throw new DatabaseException("The database is not started.");

            var connector = new LocalEmbeddedServerConnector(this);

            ++openConnections;

            return connector;
        }
Пример #57
0
        /// <inheritdoc/>
        public bool CheckExists(IDbConfig config)
        {
            if (booted)
                throw new DataException("The database is already booted.");

            return controller.DatabaseExists(config, databaseName);
        }
Пример #58
0
 public CommandHandler(IDbConfig config, IBus bus)
     : base(bus, config.ConnectionString)
 {
 }
 public SegmentRepository(IDbConfig config)
 {
     _config = config;
 }
Пример #60
0
        /// <summary>
        /// Starts up the database identified with the given name.
        /// </summary>
        /// <param name="config">The configurations used to start the database.</param>
        /// <param name="name">The name of the database to start.</param>
        /// <returns>
        /// Returns a <see cref="DbSystem"/> instance used to access the database created.
        /// </returns>
        /// <exception cref="ArgumentNullException">
        /// If the <paramref name="name"/> of the database is <b>null</b>.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// If a database with the given <paramref name="name"/> already exists.
        /// </exception>
        /// <exception cref="InvalidOperationException">
        /// If an error occurred while initializing the database.
        /// </exception>
        public DbSystem StartDatabase(IDbConfig config, string name)
        {
            if (!DatabaseExists(config, name))
                throw new ArgumentException("Database '" + name + "' not existing.", "name");

            if (config == null)
                config = DbConfig.Default;

            config.Parent = Config;

            IDatabase database = GetDatabase(name);

            if (database.IsInitialized)
                throw new ArgumentException("The database is already initialized.");

            // First initialise the database
            try {
                database.Init();
            } catch (DatabaseException e) {
                database.Context.Logger.Error(this, "Database init failed");
                database.Context.Logger.Error(this, e);
                throw new InvalidOperationException(e.Message);
            }

            // Return the DbSystem object for the newly created database.
            return new DbSystem(this, name, config, database);
        }