public void Correctly_creates_topics_filter(IEnumerable <object> topics)
{
FilterBlock from = new FilterBlock(100);
FilterBlock to = new FilterBlock(FilterBlockType.Latest);
FilterStore store = new FilterStore();
LogFilter filter = store.CreateLogFilter(from, to, null, topics);
}
public void TestFilterStore()
{
var start = new DateTime(1970, 1, 1, 0, 0, 0);
var sb = new StringBuilder();
var env = new Environment(start)
{
Logger = new StringWriter(sb)
};
var sto = new FilterStore(env, capacity: 1);
env.Process(FilterStoreProducer(env, sto));
env.Process(FilterStoreConsumerA(env, sto));
env.Process(FilterStoreConsumerB(env, sto));
env.Run(TimeSpan.FromSeconds(20));
Assert.AreEqual(sb.ToString(),
@"4: Produce A
4: Consume A
6: Produce B
6: Consume B
10: Produce A
14: Consume A
14: Produce B
14: Consume B
18: Produce A
");
}
public void Correctly_creates_topics_filter(IEnumerable <object> topics)
{
BlockParameter from = new BlockParameter(100);
BlockParameter to = new BlockParameter(BlockParameterType.Latest);
FilterStore store = new FilterStore();
LogFilter filter = store.CreateLogFilter(from, to, null, topics);
}
private IEnumerable <Event> TestFilterCallsWorseCaseGetProcess(FilterStore store, Func <object, bool> filterLogger, List <string> log)
{
var req = store.Get(filterLogger);
yield return(req);
log.Add(string.Format("get {0}", req.Value));
}
private IEnumerable <Event> TestFilterCallsWorstCasePutProcess(FilterStore store, List <string> log)
{
for (var i = 0; i < 4; i++)
{
log.Add(string.Format("put {0}", i));
yield return(store.Put(i));
}
}
public void Can_save_and_load_log_filter()
{
FilterStore store = new FilterStore();
LogFilter filter = store.CreateLogFilter(new FilterBlock(1), new FilterBlock(2));
store.SaveFilter(filter);
Assert.True(store.FilterExists(0), "exists");
Assert.AreEqual(FilterType.LogFilter, store.GetFilterType(filter.Id), "type");
}
public void Cannot_overwrite_filters()
{
FilterStore store = new FilterStore();
BlockFilter externalFilter = new BlockFilter(100, 1);
store.SaveFilter(externalFilter);
Assert.Throws <InvalidOperationException>(() => store.SaveFilter(externalFilter));
}
public void Can_save_and_load_block_filter()
{
FilterStore store = new FilterStore();
BlockFilter filter = store.CreateBlockFilter(1);
store.SaveFilter(filter);
Assert.True(store.FilterExists(0), "exists");
Assert.AreEqual(FilterType.BlockFilter, store.GetFilterType(filter.Id), "type");
}
public void Correctly_creates_address_filter(object address, AddressFilter expected)
{
FilterBlock from = new FilterBlock(100);
FilterBlock to = new FilterBlock(FilterBlockType.Latest);
FilterStore store = new FilterStore();
LogFilter filter = store.CreateLogFilter(from, to, address);
filter.AddressFilter.Should().BeEquivalentTo(expected);
}
private IEnumerable <Event> FilterStoreConsumerB(Environment env, FilterStore sto)
{
while (true)
{
yield return(sto.Get(x => x == FilterStoreObjB));
env.Log("{0}: Consume B", env.Now.Second);
yield return(env.Timeout(TimeSpan.FromSeconds(3)));
}
}
public void TestFilterCallsBestCase()
{
var env = new Environment();
var store = new FilterStore(env, new object[] { 1, 2, 3 }, 3);
var log = new List<string>();
Func<object, bool> filterLogger = o => { log.Add(string.Format("check {0}", o)); return true; };
env.Process(TestFilterCallsBestCaseProcess(store, filterLogger, log));
env.Run();
Assert.IsTrue(log.SequenceEqual(new[] { "check 1", "get 1", "check 2", "get 2", "check 3", "get 3" }));
}
SimEvents StorePutter_SameEvent(FilterStore <int> store)
{
var putEv = store.Put(0);
while (true)
{
yield return(putEv);
yield return(Env.Timeout(1));
}
}
protected override async Task <TestBlockchain> Build(ISpecProvider specProvider = null)
{
await base.Build();
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, BlockProcessor, TxPool, LimboLogs.Instance);
Bridge ??= new BlockchainBridge(StateReader, State, Storage, BlockTree, TxPool, ReceiptStorage, filterStore, filterManager, NullWallet.Instance, TxProcessor, EthereumEcdsa, NullBloomStorage.Instance, LimboLogs.Instance, false);
EthModule = new EthModule(new JsonRpcConfig(), Bridge, LimboLogs.Instance);
return(this);
}
protected void FilterStore_Refresh(object sender, StoreRefreshDataEventArgs e)
{
if (gridPanel == null)
{
gridPanel = GridController.GetInstance().GetGridPanel(GridPanelName);
}
List <GridFilterPermissionInfo> rsList = gridPanel.GetAllFilter(-1);
FilterStore.DataSource = rsList;
FilterStore.DataBind();
}
public void TestFilterCallsBestCase()
{
var env = new Environment();
var store = new FilterStore(env, new object[] { 1, 2, 3 }, 3);
var log = new List <string>();
Func <object, bool> filterLogger = o => { log.Add(string.Format("check {0}", o)); return(true); };
env.Process(TestFilterCallsBestCaseProcess(store, filterLogger, log));
env.Run();
Assert.IsTrue(log.SequenceEqual(new[] { "check 1", "get 1", "check 2", "get 2", "check 3", "get 3" }));
}
public void TestFilterStoreGetAfterMismatch()
{
var env = new Environment(new DateTime(2014, 1, 1));
var store = new FilterStore(env, capacity: 2);
var proc1 = env.Process(TestFilterStoreGetAfterMismatch_Getter(env, store, 1));
var proc2 = env.Process(TestFilterStoreGetAfterMismatch_Getter(env, store, 2));
env.Process(TestFilterStoreGetAfterMismatch_Putter(env, store));
env.Run();
Assert.AreEqual(proc1.Value, 1);
Assert.AreEqual(proc2.Value, 0);
}
SimEvents StoreGetter_SameEvent(FilterStore <int> store)
{
var getEv = store.Get();
while (true)
{
yield return(store.Put(5));
yield return(getEv);
yield return(Env.Timeout(1));
}
}
public void Remove_filter_removes_and_notifies()
{
FilterStore store = new FilterStore();
BlockFilter filter = store.CreateBlockFilter(1);
store.SaveFilter(filter);
bool hasNotified = false;
store.FilterRemoved += (s, e) => hasNotified = true;
store.RemoveFilter(0);
Assert.True(hasNotified, "notied");
Assert.False(store.FilterExists(0), "exists");
}
public void Ids_are_incremented_when_storing_externally_created_filter()
{
FilterStore store = new FilterStore();
BlockFilter externalFilter = new BlockFilter(100, 1);
store.SaveFilter(externalFilter);
LogFilter filter = store.CreateLogFilter(new FilterBlock(1), new FilterBlock(2));
store.SaveFilter(filter);
Assert.True(store.FilterExists(100), "exists 100");
Assert.True(store.FilterExists(101), "exists 101");
Assert.AreEqual(FilterType.LogFilter, store.GetFilterType(filter.Id), "type");
}
SimEvents StorePutter(FilterStore <int> store, int putCount, int timeout)
{
Debug.Assert(putCount >= 0);
Debug.Assert(timeout >= 0);
for (var i = 0; i < putCount; ++i)
{
Integers.Add(i);
yield return(store.Put(i));
if (timeout > 0)
{
yield return(Env.Timeout(timeout));
}
}
}
SimEvents StoreGetter(FilterStore <int> store, int getCount, int timeout)
{
Debug.Assert(getCount >= 0);
Debug.Assert(timeout >= 0);
for (var i = 0; i < getCount; ++i)
{
var getEv = store.Get();
yield return(getEv);
Assert.AreEqual(Integers[GetIdx++], getEv.Value);
if (timeout > 0)
{
yield return(Env.Timeout(timeout));
}
}
}
public void TestFilterCallsWorstCase()
{
var env = new Environment();
var store = new FilterStore(env, 4);
var log = new List<string>();
Func<object, bool> filterLogger = o => { log.Add(string.Format("check {0}", o)); return (int)o >= 3; };
env.Process(TestFilterCallsWorseCaseGetProcess(store, filterLogger, log));
env.Process(TestFilterCallsWorstCasePutProcess(store, log));
env.Run();
Assert.IsTrue(log.SequenceEqual(new[] {
"put 0", "check 0",
"put 1", "check 0", "check 1",
"put 2", "check 0", "check 1", "check 2",
"put 3", "check 0", "check 1", "check 2", "check 3", "get 3"
}));
}
private IEnumerable <Event> FilterStoreProducer(Environment env, FilterStore sto)
{
while (true)
{
yield return(env.Timeout(TimeSpan.FromSeconds(4)));
yield return(sto.Put(FilterStoreObjA));
env.Log("{0}: Produce A", env.Now.Second);
yield return(env.Timeout(TimeSpan.FromSeconds(2)));
yield return(sto.Put(FilterStoreObjB));
env.Log("{0}: Produce B", env.Now.Second);
}
}
private IEnumerable <Event> TestFilterCallsBestCaseProcess(FilterStore store, Func <object, bool> filter, List <string> log)
{
var get = store.Get(filter);
yield return(get);
log.Add(string.Format("get {0}", get.Value));
get = store.Get(filter);
yield return(get);
log.Add(string.Format("get {0}", get.Value));
get = store.Get(filter);
yield return(get);
log.Add(string.Format("get {0}", get.Value));
}
protected override async Task <TestBlockchain> Build(ISpecProvider specProvider = null)
{
BloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
specProvider ??= MainnetSpecProvider.Instance;
await base.Build(specProvider);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, BlockProcessor, TxPool, LimboLogs.Instance);
LogFinder = new LogFinder(BlockTree, ReceiptStorage, bloomStorage, LimboLogs.Instance, new ReceiptsRecovery());
Bridge ??= new BlockchainBridge(StateReader, State, Storage, BlockTree, TxPool, ReceiptStorage, filterStore, filterManager, TestWallet, TxProcessor, EthereumEcdsa, NullBloomStorage.Instance, Timestamper, LimboLogs.Instance, false);
TxPoolBridge ??= new TxPoolBridge(TxPool, TestWallet, Timestamper, specProvider?.ChainId ?? 0);
EthModule = new EthModule(new JsonRpcConfig(), Bridge, TxPoolBridge, LimboLogs.Instance);
return(this);
}
public void TestFilterCallsWorstCase()
{
var env = new Environment();
var store = new FilterStore(env, 4);
var log = new List <string>();
Func <object, bool> filterLogger = o => { log.Add(string.Format("check {0}", o)); return((int)o >= 3); };
env.Process(TestFilterCallsWorseCaseGetProcess(store, filterLogger, log));
env.Process(TestFilterCallsWorstCasePutProcess(store, log));
env.Run();
Assert.IsTrue(log.SequenceEqual(new[] {
"put 0", "check 0",
"put 1", "check 0", "check 1",
"put 2", "check 0", "check 1", "check 2",
"put 3", "check 0", "check 1", "check 2", "check 3", "get 3"
}));
}
public static IServices Init(RequiredServices services)
{
AddDecoders();
var config = services.NdmConfig;
var providerAddress = string.IsNullOrWhiteSpace(config.ProviderAddress)
? Address.Zero
: new Address(config.ProviderAddress);
var consumerAddress = string.IsNullOrWhiteSpace(config.ConsumerAddress)
? Address.Zero
: new Address(config.ConsumerAddress);
UnlockHardcodedAccounts(providerAddress, consumerAddress, services.Wallet);
var readOnlyDbProvider = new ReadOnlyDbProvider(services.RocksProvider, false);
var filterStore = new FilterStore();
var filterManager = new FilterManager(filterStore, services.BlockProcessor, services.TransactionPool,
services.LogManager);
var state = new RpcState(services.BlockTree, services.SpecProvider, readOnlyDbProvider,
services.LogManager);
var blockchainBridge = new BlockchainBridge(
state.StateReader,
state.StateProvider,
state.StorageProvider,
state.BlockTree,
services.TransactionPool,
services.TransactionPoolInfoProvider,
services.ReceiptStorage,
filterStore,
filterManager,
services.Wallet,
state.TransactionProcessor,
services.Ecdsa);
var dataHeaderRlpDecoder = new DataHeaderDecoder();
var encoder = new AbiEncoder();
var depositService = new DepositService(blockchainBridge, encoder, services.Wallet, config,
LimboLogs.Instance);
var ndmConsumerChannelManager = services.NdmConsumerChannelManager;
var ndmDataPublisher = services.NdmDataPublisher;
var jsonRpcNdmConsumerChannel = new JsonRpcNdmConsumerChannel();
// ndmConsumerChannelManager.Add(jsonRpcNdmConsumerChannel);
return(new Services(services, new CreatedServices(consumerAddress, encoder, dataHeaderRlpDecoder,
depositService, ndmDataPublisher, jsonRpcNdmConsumerChannel, ndmConsumerChannelManager,
blockchainBridge)));
}
public void Can_get_filters_by_type()
{
FilterStore store = new FilterStore();
BlockFilter filter1 = store.CreateBlockFilter(1);
store.SaveFilter(filter1);
LogFilter filter2 = store.CreateLogFilter(new FilterBlock(1), new FilterBlock(2));
store.SaveFilter(filter2);
LogFilter[] logFilters = store.GetFilters <LogFilter>();
BlockFilter[] blockFilters = store.GetFilters <BlockFilter>();
Assert.AreEqual(1, logFilters.Length, "log filters length");
Assert.AreEqual(1, logFilters[0].Id, "log filters ids");
Assert.AreEqual(1, blockFilters.Length, "block Filters length");
Assert.AreEqual(0, blockFilters[0].Id, "block filters ids");
}
protected override async Task <TestBlockchain> Build(ISpecProvider specProvider = null, UInt256?initialValues = null)
{
BloomStorage bloomStorage = new BloomStorage(new BloomConfig(), new MemDb(), new InMemoryDictionaryFileStoreFactory());
specProvider ??= MainnetSpecProvider.Instance;
await base.Build(specProvider, initialValues);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, BlockProcessor, TxPool, LimboLogs.Instance);
ReceiptsRecovery receiptsRecovery = new ReceiptsRecovery(new EthereumEcdsa(specProvider.ChainId, LimboLogs.Instance), specProvider);
LogFinder = new LogFinder(BlockTree, ReceiptStorage, bloomStorage, LimboLogs.Instance, receiptsRecovery);
ReadOnlyTxProcessingEnv processingEnv = new ReadOnlyTxProcessingEnv(
new ReadOnlyDbProvider(DbProvider, false),
new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
new ReadOnlyBlockTree(BlockTree),
SpecProvider,
LimboLogs.Instance);
Bridge ??= new BlockchainBridge(processingEnv, TxPool, ReceiptStorage, filterStore, filterManager, EthereumEcdsa, Timestamper, LogFinder, SpecProvider, false, false);
BlockFinder ??= BlockTree;
ITxSigner txSigner = new WalletTxSigner(TestWallet, specProvider?.ChainId ?? 0);
ITxSealer txSealer0 = new TxSealer(txSigner, Timestamper);
ITxSealer txSealer1 = new NonceReservingTxSealer(txSigner, Timestamper, TxPool);
TxSender ??= new TxPoolSender(TxPool, txSealer0, txSealer1);
EthRpcModule = new EthRpcModule(
new JsonRpcConfig(),
Bridge,
BlockFinder,
StateReader,
TxPool,
TxSender,
TestWallet,
LimboLogs.Instance,
SpecProvider);
return(this);
}
public void TestFilterStore()
{
var start = new DateTime(1970, 1, 1, 0, 0, 0);
var sb = new StringBuilder();
var env = new Environment(start) {
Logger = new StringWriter(sb)
};
var sto = new FilterStore(env, capacity: 1);
env.Process(FilterStoreProducer(env, sto));
env.Process(FilterStoreConsumerA(env, sto));
env.Process(FilterStoreConsumerB(env, sto));
env.Run(TimeSpan.FromSeconds(20));
Assert.AreEqual(sb.ToString(),
@"4: Produce A
4: Consume A
6: Produce B
6: Consume B
10: Produce A
14: Consume A
14: Produce B
14: Consume B
18: Produce A
");
}
private List <Namespace> Filter(IEnumerable <Namespace> namespaces, FilterStore filterStore, FrameworkIndex frameworks)
{
var filteredNS = namespaces.ToList();
foreach (var ns in filteredNS)
{
if (ns.Types?.Count > 0)
{
ns.Types = ns.Types.Where(t =>
{
bool expose = true;
if (filterStore?.TypeFilters?.Count > 0)
{
var applicableFilters = filterStore.TypeFilters.Where(tf => tf.Filter(t).HasValue).ToList();
if (applicableFilters.Count == 1)
{
expose = applicableFilters.First().Filter(t).Value;
}
else if (applicableFilters.Count > 1)
{
var filtersPerNS = applicableFilters.GroupBy(tf => tf.Namespace).Select(tfg => tfg.FirstOrDefault(tf => tf.Name != "*") ?? tfg.First()).ToList();
foreach (var filter in filtersPerNS)
{
expose = expose && filter.Filter(t).Value;
}
}
}
return(expose && frameworks.DocIdToFrameworkDict.ContainsKey(t.DocId));
}).ToList();
}
}
filteredNS = filteredNS.Where(ns => ns.Types?.Count > 0 && frameworks.DocIdToFrameworkDict.ContainsKey(ns.CommentId)).ToList();
foreach (var ns in filteredNS)
{
foreach (var t in ns.Types)
{
if (t.Members?.Count > 0)
{
t.Members = t.Members.Where(m =>
{
bool expose = true;
if (filterStore?.MemberFilters?.Count > 0)
{
foreach (var filter in filterStore.MemberFilters.Where(mf => mf.Filter(m).HasValue))
{
expose = expose && filter.Filter(m).Value;
}
}
return(expose && frameworks.DocIdToFrameworkDict.ContainsKey(m.DocId));;
}).ToList();
}
}
}
//workaournd for https://github.com/mono/api-doc-tools/issues/89, bug #1022788
foreach (var ns in filteredNS)
{
foreach (var t in ns.Types)
{
if (t.Signatures.IsPublishSealedClass)
{
t.Members = t.Members.Where(m => !m.Signatures.IsProtected).ToList();
}
}
}
return(filteredNS);
}
private void RegisterJsonRpcModules()
{
if (!_initConfig.JsonRpcEnabled)
{
return;
}
if (_logger.IsDebug)
{
_logger.Debug($"Resolving CLI ({nameof(Cli.CliModuleLoader)})");
}
IReadOnlyDbProvider rpcDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
AlternativeChain rpcChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, rpcDbProvider, _recoveryStep, _logManager, _transactionPool, _receiptStorage);
ITracer tracer = new Tracer(rpcChain.Processor, _receiptStorage, _blockTree, _dbProvider.TraceDb);
IFilterStore filterStore = new FilterStore();
IFilterManager filterManager = new FilterManager(filterStore, _blockProcessor, _transactionPool, _logManager);
RpcState rpcState = new RpcState(_blockTree, _specProvider, rpcDbProvider, _logManager);
//creating blockchain bridge
var blockchainBridge = new BlockchainBridge(
rpcState.StateReader,
rpcState.StateProvider,
rpcState.StorageProvider,
rpcState.BlockTree,
_transactionPool,
_transactionPoolInfoProvider,
_receiptStorage,
filterStore,
filterManager,
_wallet,
rpcState.TransactionProcessor);
TransactionPool debugTransactionPool = new TransactionPool(new PersistentTransactionStorage(_dbProvider.PendingTxsDb, _specProvider),
new PendingTransactionThresholdValidator(_initConfig.ObsoletePendingTransactionInterval, _initConfig.RemovePendingTransactionInterval),
_timestamp,
_ethereumEcdsa,
_specProvider,
_logManager,
_initConfig.RemovePendingTransactionInterval,
_initConfig.PeerNotificationThreshold);
var debugReceiptStorage = new PersistentReceiptStorage(_dbProvider.ReceiptsDb, _specProvider);
AlternativeChain debugChain = new AlternativeChain(_blockTree, _blockValidator, _rewardCalculator, _specProvider, rpcDbProvider, _recoveryStep, _logManager, debugTransactionPool, debugReceiptStorage);
IReadOnlyDbProvider debugDbProvider = new ReadOnlyDbProvider(_dbProvider, false);
var debugBridge = new DebugBridge(_configProvider, debugDbProvider, tracer, debugChain.Processor);
EthModule module = new EthModule(_jsonSerializer, _configProvider, _logManager, blockchainBridge);
_rpcModuleProvider.Register <IEthModule>(module);
DebugModule debugModule = new DebugModule(_configProvider, _logManager, debugBridge, _jsonSerializer);
_rpcModuleProvider.Register <IDebugModule>(debugModule);
if (_sealer is CliqueSealer)
{
CliqueModule cliqueModule = new CliqueModule(_configProvider, _logManager, _jsonSerializer, new CliqueBridge(_blockProducer as ICliqueBlockProducer, _snapshotManager, _blockTree));
_rpcModuleProvider.Register <ICliqueModule>(cliqueModule);
}
if (_initConfig.EnableUnsecuredDevWallet)
{
PersonalBridge personalBridge = new PersonalBridge(_wallet);
PersonalModule personalModule = new PersonalModule(personalBridge, _configProvider, _logManager, _jsonSerializer);
_rpcModuleProvider.Register <IPersonalModule>(personalModule);
}
AdminModule adminModule = new AdminModule(_configProvider, _logManager, _jsonSerializer);
_rpcModuleProvider.Register <IAdminModule>(adminModule);
TxPoolModule txPoolModule = new TxPoolModule(_configProvider, _logManager, _jsonSerializer, blockchainBridge);
_rpcModuleProvider.Register <ITxPoolModule>(txPoolModule);
if (_initConfig.NetworkEnabled && _initConfig.SynchronizationEnabled)
{
NetModule netModule = new NetModule(_configProvider, _logManager, _jsonSerializer, new NetBridge(_enode, _syncManager, _peerManager));
_rpcModuleProvider.Register <INetModule>(netModule);
}
TraceModule traceModule = new TraceModule(_configProvider, _logManager, _jsonSerializer, tracer);
_rpcModuleProvider.Register <ITraceModule>(traceModule);
}
public void TestFilterStoreGetAfterMismatch()
{
var env = new Environment(new DateTime(2014, 1, 1));
var store = new FilterStore(env, capacity: 2);
var proc1 = env.Process(TestFilterStoreGetAfterMismatch_Getter(env, store, 1));
var proc2 = env.Process(TestFilterStoreGetAfterMismatch_Getter(env, store, 2));
env.Process(TestFilterStoreGetAfterMismatch_Putter(env, store));
env.Run();
Assert.AreEqual(proc1.Value, 1);
Assert.AreEqual(proc2.Value, 0);
}
private IEnumerable<Event> FilterStoreConsumerB(Environment env, FilterStore sto)
{
while (true) {
yield return sto.Get(x => x == FilterStoreObjB);
env.Log("{0}: Consume B", env.Now.Second);
yield return env.Timeout(TimeSpan.FromSeconds(3));
}
}
private FilterStore LoadFilters(string path)
{
var filterFile = Path.Combine(path, "_filter.xml");
if (_fileAccessor.Exists(filterFile))
{
var filterStore = new FilterStore();
XDocument filterDoc = XDocument.Parse(_fileAccessor.ReadAllText(filterFile));
var attrFilter = filterDoc.Root.Element("attributeFilter");
if (attrFilter != null && attrFilter.Attribute("apply").Value == "true")
{
var attrFilterElements = attrFilter.Elements("namespaceFilter");
if (attrFilterElements != null)
{
filterStore.AttributeFilters = new List <AttributeFilter>();
foreach (var fElement in attrFilterElements)
{
AttributeFilter filter = new AttributeFilter()
{
Namespace = fElement.Attribute("name").Value,
TypeFilters = new Dictionary <string, bool>(),
DefaultValue = true
};
foreach (var tFiler in fElement.Elements("typeFilter"))
{
bool expose = false;
bool.TryParse(tFiler.Attribute("expose").Value, out expose);
string name = tFiler.Attribute("name").Value;
if (name == "*")
{
filter.DefaultValue = expose;
}
else
{
filter.TypeFilters[name] = expose;
}
}
filterStore.AttributeFilters.Add(filter);
}
}
}
var apiFilter = filterDoc.Root.Element("apiFilter");
if (apiFilter != null && apiFilter.Attribute("apply").Value == "true")
{
var apiFilterElements = apiFilter.Elements("namespaceFilter");
if (apiFilterElements != null)
{
filterStore.TypeFilters = new List <TypeFilter>();
filterStore.MemberFilters = new List <MemberFilter>();
foreach (var fElement in apiFilterElements)
{
var nsName = fElement.Attribute("name").Value?.Trim();
foreach (var tElement in fElement.Elements("typeFilter"))
{
var tFilter = new TypeFilter(tElement)
{
Namespace = nsName
};
filterStore.TypeFilters.Add(tFilter);
var memberFilterElements = tElement.Elements("memberFilter");
if (memberFilterElements != null)
{
foreach (var mElement in memberFilterElements)
{
filterStore.MemberFilters.Add(new MemberFilter(mElement)
{
Parent = tFilter
});
}
}
}
}
}
}
return(filterStore);
}
return(null);
}
private IEnumerable<Event> TestFilterStoreGetAfterMismatch_Putter(Environment env, FilterStore store)
{
yield return store.Put(2);
yield return env.Timeout(TimeSpan.FromSeconds(1));
yield return store.Put(1);
}
private IEnumerable<Event> FilterStoreProducer(Environment env, FilterStore sto)
{
while (true) {
yield return env.Timeout(TimeSpan.FromSeconds(4));
yield return sto.Put(FilterStoreObjA);
env.Log("{0}: Produce A", env.Now.Second);
yield return env.Timeout(TimeSpan.FromSeconds(2));
yield return sto.Put(FilterStoreObjB);
env.Log("{0}: Produce B", env.Now.Second);
}
}
private IEnumerable<Event> TestFilterCallsBestCaseProcess(FilterStore store, Func<object, bool> filter, List<string> log)
{
var get = store.Get(filter);
yield return get;
log.Add(string.Format("get {0}", get.Value));
get = store.Get(filter);
yield return get;
log.Add(string.Format("get {0}", get.Value));
get = store.Get(filter);
yield return get;
log.Add(string.Format("get {0}", get.Value));
}
private IEnumerable<Event> TestFilterCallsWorseCaseGetProcess(FilterStore store, Func<object, bool> filterLogger, List<string> log)
{
var req = store.Get(filterLogger);
yield return req;
log.Add(string.Format("get {0}", req.Value));
}
private IEnumerable<Event> TestFilterCallsWorstCasePutProcess(FilterStore store, List<string> log)
{
for (var i = 0; i < 4; i++) {
log.Add(string.Format("put {0}", i));
yield return store.Put(i);
}
}
private IEnumerable<Event> TestFilterStoreGetAfterMismatch_Getter(Environment env, FilterStore store, int value)
{
yield return store.Get(x => (int)x == value);
env.ActiveProcess.Succeed(env.Now.Second);
}