public SqlColumn(ITable table, String name, IDataBridge data)
{
Ordinal = -1;
Table = table;
Name = name.ToLower();
Data = data;
}
public GetMatchesTask(int teamId,
DateTime?startDate,
DateTime?endDate,
IMatchArchiveBridge mab,
IDataBridge <MatchDetails> mdb)
{
if (startDate == null)
{
throw new ArgumentNullException("startDate");
}
_startDate = startDate;
if (endDate == null)
{
throw new ArgumentNullException("endDate");
}
_endDate = endDate;
if (mab == null)
{
throw new ArgumentNullException("mab");
}
_mab = mab;
if (mdb == null)
{
throw new ArgumentNullException("mdb");
}
_mdb = mdb;
_teamId = teamId;
}
public DataAccess(RelationshipGraph graph)
{
this.graph = graph;
//TODO Andreas - hier kannst du umschalten auf Demo-Daten
// this.dataBridge = new DataBridgeDemo();
this.dataBridge = new DataBridgeODIS();
}
/// <summary>
/// Creates a chain of data bridges
/// </summary>
/// <param name="first">First part of chain. It is queried first.
/// If this fails it updated with the result from 'second'</param>
/// <param name="second">Second part of chain. Is queried if 'first' fails.</param>
public BridgeChain(IDataBridge <T> first, IDataBridge <T> second)
{
if (first == null || second == null)
{
throw new ArgumentNullException("first or second");
}
_first = first;
_second = second;
}
public CallViewModel(IDataBridge bridge)
{
if (bridge == null) throw new ArgumentNullException("bridge");
_bridge = bridge;
if (_bridge.CurrentPerson == null)
throw new ArgumentException("_bridge.CurrentPerson");
}
/// <summary>
/// Gets value from specified bridge without throwing anything
/// </summary>
/// <param name="b">bridge to query</param>
/// <param name="id">identifier to query</param>
/// <returns>value or default(T) on failure</returns>
private T SafeGet(IDataBridge <T> b, uint id)
{
try
{
return(b.Get(id));
}
catch (Exception)
{
return(default(T));
}
}
private void FindInherited(Type type, SqlTable table)
{
if (type.IsDefined(typeof(MapAttribute), false))
{
object[] attrs = type.GetCustomAttributes(typeof(MapAttribute), false);
foreach (MapAttribute attr in attrs)
{
IDataBridge data = null;
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
MemberInfo member = type.GetProperty(attr.Field, flags);
if (member != null)
{
data = new PropertyBridge((PropertyInfo)member);
}
else
{
member = type.GetField(attr.Field, flags);
if (member != null)
{
data = new FieldBridge((FieldInfo)member);
}
else
{
throw new LightException("member " + attr.Field + " not found in class " + type.Name);
}
}
if (attr.Name == null || attr.Name.Length == 0)
{
attr.Name = member.Name;
}
SqlColumn column = new SqlColumn(table, attr.Name, data);
if (attr.Alias == null || attr.Alias.Length == 0)
{
column.Alias = attr.Field;
}
else
{
column.Alias = attr.Alias;
}
column.IsID = attr.ID;
column.IsPK = attr.PK;
table.Add(column);
}
}
}
public PersonEditorViewModel(IDataBridge bridge, IConnectionDb connection)
{
if (bridge == null) throw new ArgumentNullException("bridge");
if (connection == null) throw new ArgumentNullException("connection");
_bridge = bridge;
_connection = connection;
_connection.PropertyChanged += _connection_PropertyChanged;
if (_bridge.CurrentPerson != null)
{
_currentPerson = _bridge.CurrentPerson;
_contacts = null;
FIO = _currentPerson.FIO;
RaisePropertyChanged("Contacts");
}
}
public GetMatchesTask(int teamId, ITeamDetailsBridge tdb, IMatchArchiveBridge mab, IDataBridge <MatchDetails> mdb)
{
if (tdb == null)
{
throw new ArgumentNullException("tbd");
}
_tdb = tdb;
if (mab == null)
{
throw new ArgumentNullException("mab");
}
_mab = mab;
if (mdb == null)
{
throw new ArgumentNullException("mdb");
}
_mdb = mdb;
_teamId = teamId;
}
private async Task InitBlockchain()
{
_specProvider = new ChainSpecBasedSpecProvider(_chainSpec);
Account.AccountStartNonce = _chainSpec.Parameters.AccountStartNonce;
/* sync */
IDbConfig dbConfig = _configProvider.GetConfig <IDbConfig>();
_syncConfig = _configProvider.GetConfig <ISyncConfig>();
foreach (PropertyInfo propertyInfo in typeof(IDbConfig).GetProperties())
{
if (_logger.IsDebug)
{
_logger.Debug($"DB {propertyInfo.Name}: {propertyInfo.GetValue(dbConfig)}");
}
}
_dbProvider = HiveEnabled
? (IDbProvider) new MemDbProvider()
: new RocksDbProvider(_initConfig.BaseDbPath, dbConfig, _logManager, _initConfig.StoreTraces, _initConfig.StoreReceipts || _syncConfig.DownloadReceiptsInFastSync);
_ethereumEcdsa = new EthereumEcdsa(_specProvider, _logManager);
_txPool = new TxPool(
new PersistentTxStorage(_dbProvider.PendingTxsDb, _specProvider),
Timestamp.Default,
_ethereumEcdsa,
_specProvider,
_txPoolConfig, _logManager);
var _rc7FixDb = _initConfig.EnableRc7Fix ? _dbProvider.HeadersDb : NullDb.Instance;
_receiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _rc7FixDb, _specProvider, _logManager);
// IDbProvider debugRecorder = new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig);
// _dbProvider = new RpcDbProvider(_jsonSerializer, new BasicJsonRpcClient(KnownRpcUris.NethVm1, _jsonSerializer, _logManager), _logManager, debugRecorder);
// IDbProvider debugReader = new ReadOnlyDbProvider(new RocksDbProvider(Path.Combine(_dbBasePath, "debug"), dbConfig));
// _dbProvider = debugReader;
_blockTree = new BlockTree(
_dbProvider.BlocksDb,
_dbProvider.HeadersDb,
_dbProvider.BlockInfosDb,
_specProvider,
_txPool,
_syncConfig,
_logManager);
_recoveryStep = new TxSignaturesRecoveryStep(_ethereumEcdsa, _txPool, _logManager);
CliqueConfig cliqueConfig = null;
_snapshotManager = null;
switch (_chainSpec.SealEngineType)
{
case SealEngineType.None:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Clique:
_rewardCalculator = NoBlockRewards.Instance;
cliqueConfig = new CliqueConfig();
cliqueConfig.BlockPeriod = _chainSpec.Clique.Period;
cliqueConfig.Epoch = _chainSpec.Clique.Epoch;
_snapshotManager = new SnapshotManager(cliqueConfig, _dbProvider.BlocksDb, _blockTree, _ethereumEcdsa, _logManager);
_sealValidator = new CliqueSealValidator(cliqueConfig, _snapshotManager, _logManager);
_recoveryStep = new CompositeDataRecoveryStep(_recoveryStep, new AuthorRecoveryStep(_snapshotManager));
if (_initConfig.IsMining)
{
_sealer = new CliqueSealer(new BasicWallet(_nodeKey), cliqueConfig, _snapshotManager, _nodeKey.Address, _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
break;
case SealEngineType.NethDev:
_sealer = NullSealEngine.Instance;
_sealValidator = NullSealEngine.Instance;
_rewardCalculator = NoBlockRewards.Instance;
break;
case SealEngineType.Ethash:
_rewardCalculator = new RewardCalculator(_specProvider);
var difficultyCalculator = new DifficultyCalculator(_specProvider);
if (_initConfig.IsMining)
{
_sealer = new EthashSealer(new Ethash(_logManager), _logManager);
}
else
{
_sealer = NullSealEngine.Instance;
}
_sealValidator = new EthashSealValidator(_logManager, difficultyCalculator, new Ethash(_logManager));
break;
default:
throw new NotSupportedException($"Seal engine type {_chainSpec.SealEngineType} is not supported in Nethermind");
}
/* validation */
_headerValidator = new HeaderValidator(
_blockTree,
_sealValidator,
_specProvider,
_logManager);
var ommersValidator = new OmmersValidator(
_blockTree,
_headerValidator,
_logManager);
var txValidator = new TxValidator(_specProvider.ChainId);
_blockValidator = new BlockValidator(
txValidator,
_headerValidator,
ommersValidator,
_specProvider,
_logManager);
var stateProvider = new StateProvider(
_dbProvider.StateDb,
_dbProvider.CodeDb,
_logManager);
_stateProvider = stateProvider;
var storageProvider = new StorageProvider(
_dbProvider.StateDb,
stateProvider,
_logManager);
_txPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
_transactionPoolInfoProvider = new TxPoolInfoProvider(stateProvider);
/* blockchain processing */
var blockhashProvider = new BlockhashProvider(
_blockTree, _logManager);
var virtualMachine = new VirtualMachine(
stateProvider,
storageProvider,
blockhashProvider,
_logManager);
var transactionProcessor = new TransactionProcessor(
_specProvider,
stateProvider,
storageProvider,
virtualMachine,
_logManager);
_blockProcessor = new BlockProcessor(
_specProvider,
_blockValidator,
_rewardCalculator,
transactionProcessor,
_dbProvider.StateDb,
_dbProvider.CodeDb,
_dbProvider.TraceDb,
stateProvider,
storageProvider,
_txPool,
_receiptStorage,
_logManager);
_blockchainProcessor = new BlockchainProcessor(
_blockTree,
_blockProcessor,
_recoveryStep,
_logManager,
_initConfig.StoreReceipts,
_initConfig.StoreTraces);
// create shared objects between discovery and peer manager
IStatsConfig statsConfig = _configProvider.GetConfig <IStatsConfig>();
_nodeStatsManager = new NodeStatsManager(statsConfig, _logManager);
if (_initConfig.IsMining)
{
IReadOnlyDbProvider minerDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain producerChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator,
_specProvider, minerDbProvider, _recoveryStep, _logManager, _txPool, _receiptStorage);
switch (_chainSpec.SealEngineType)
{
case SealEngineType.Clique:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Clique block producer & sealer");
}
_blockProducer = new CliqueBlockProducer(_txPool, producerChain.Processor,
_blockTree, _timestamp, _cryptoRandom, producerChain.StateProvider, _snapshotManager, (CliqueSealer)_sealer, _nodeKey.Address, cliqueConfig, _logManager);
break;
}
case SealEngineType.NethDev:
{
if (_logger.IsWarn)
{
_logger.Warn("Starting Dev block producer & sealer");
}
_blockProducer = new DevBlockProducer(_txPool, producerChain.Processor, _blockTree,
_timestamp, _logManager);
break;
}
default:
throw new NotSupportedException($"Mining in {_chainSpec.SealEngineType} mode is not supported");
}
_blockProducer.Start();
}
_blockchainProcessor.Start();
LoadGenesisBlock(_chainSpec, string.IsNullOrWhiteSpace(_initConfig.GenesisHash) ? null : new Keccak(_initConfig.GenesisHash), _blockTree, stateProvider, _specProvider);
if (_initConfig.ProcessingEnabled)
{
#pragma warning disable 4014
LoadBlocksFromDb();
#pragma warning restore 4014
}
else
{
if (_logger.IsWarn)
{
_logger.Warn($"Shutting down the blockchain processor due to {nameof(InitConfig)}.{nameof(InitConfig.ProcessingEnabled)} set to false");
}
await _blockchainProcessor.StopAsync();
}
if (HiveEnabled)
{
await InitHive();
}
if (HiveEnabled)
{
await InitHive();
}
var producers = new List <IProducer>();
if (_initConfig.PubSubEnabled)
{
var kafkaProducer = await PrepareKafkaProducer(_blockTree, _configProvider.GetConfig <IKafkaConfig>());
producers.Add(kafkaProducer);
}
var grpcClientConfig = _configProvider.GetConfig <IGrpcClientConfig>();
if (grpcClientConfig.Enabled)
{
var grpcProducer = new GrpcProducer(_grpcClient, _logManager);
producers.Add(grpcProducer);
}
ISubscription subscription;
if (producers.Any())
{
subscription = new Subscription(producers, _blockProcessor, _logManager);
}
else
{
subscription = new EmptySubscription();
}
_disposeStack.Push(subscription);
_dataBridge = new DataBridge(subscription, _receiptStorage, _blockTree, _logManager);
_dataBridge.Start();
await InitializeNetwork();
}
public SqlColumn(ITable table, string name, IDataBridge data)
{
this.table = table;
this.name = name.ToLower();
this.data = data;
}
public SqlColumn(ITable table, string name, IDataBridge data)
{
this.table = table;
this.name = name.ToLower();
this.data = data;
}
public DataModule(IDataBridge dataBridge, ILogManager logManager)
: base(logManager)
{
_dataBridge = dataBridge ?? throw new ArgumentNullException(nameof(dataBridge));
}
