internal static void AddLanguageWorkerChannelErrors(IFunctionDispatcher functionDispatcher, IDictionary <string, ICollection <string> > functionErrors)
{
foreach (KeyValuePair <WorkerConfig, LanguageWorkerState> kvp in functionDispatcher.LanguageWorkerChannelStates)
{
WorkerConfig workerConfig = kvp.Key;
LanguageWorkerState workerState = kvp.Value;
foreach (var functionRegistrationContext in workerState.GetRegistrations())
{
var exMessage = $"Failed to start language worker process for: {workerConfig.Language}";
var languageWorkerChannelException = workerState.Errors != null && workerState.Errors.Count > 0 ? new LanguageWorkerChannelException(exMessage, workerState.Errors[workerState.Errors.Count - 1]) : new LanguageWorkerChannelException(exMessage);
Utility.AddFunctionError(functionErrors, functionRegistrationContext.Metadata.Name, Utility.FlattenException(languageWorkerChannelException, includeSource: false));
}
}
}
public HeadersRequestWorker(WorkerConfig workerConfig, LocalClient localClient, CoreDaemon coreDaemon)
: base("HeadersRequestWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime)
{
this.localClient = localClient;
this.coreDaemon = coreDaemon;
this.coreStorage = coreDaemon.CoreStorage;
this.headersRequestsByPeer = new ConcurrentDictionary <Peer, DateTimeOffset>();
this.localClient.OnBlockHeaders += HandleBlockHeaders;
this.coreDaemon.OnTargetChainChanged += HandleTargetChainChanged;
this.flushWorker = new WorkerMethod("HeadersRequestWorker.FlushWorker", FlushWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue);
this.flushQueue = new ConcurrentQueue <FlushHeaders>();
}
public static void Main(string[] args)
{
string env = Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT");
builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.AddJsonFile($"appsettings.{env}.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
configuration = builder.Build();
workerConfig = configuration.Get <WorkerConfig>();
CreateHostBuilder(args).Build().Run();
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkerActionConfiguration"/> class.
/// </summary>
/// <param name="workerConfig">
/// The worker config.
/// </param>
/// <exception cref="ArgumentNullException">
/// Argument Null Exception
/// </exception>
public WorkerActionConfiguration(WorkerConfig workerConfig)
{
if (workerConfig == null)
{
throw new ArgumentNullException(nameof(workerConfig));
}
this.ActionType = workerConfig.ActionType;
this.ShortTimeout = TimeSpan.FromSeconds(workerConfig.ShortTimeoutSec);
this.LongTimeout = TimeSpan.FromSeconds(workerConfig.LongTimeoutSec);
this.FailTimeout = TimeSpan.FromSeconds(workerConfig.FailTimeoutSec);
this.DelayStart = TimeSpan.FromSeconds(workerConfig.DelayStartSec);
this.Parameters = workerConfig.Parameters.OfType <ParameterConfig>()
.ToDictionary(config => config.Key, config => config.Value);
}
public void ReadWorkerProviderFromConfig_ReturnsProviderNoArguments()
{
var configs = new List <TestLanguageWorkerConfig>()
{
MakeTestConfig(testLanguage, new string[0])
};
// Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig
var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage));
Assert.Single(workerConfigs);
Assert.Equal(Path.Combine(rootPath, testLanguage, $"{WorkerConfigTestUtilities.TestWorkerPathInWorkerConfig}.{testLanguage}"), workerConfigs.Single().Description.DefaultWorkerPath);
WorkerConfig worker = workerConfigs.FirstOrDefault();
Assert.True(worker.Description.Arguments.Count == 0);
}
public HeadersRequestWorker(Logger logger, WorkerConfig workerConfig, LocalClient localClient, CoreDaemon blockchainDaemon, BlockHeaderCache blockHeaderCache)
: base("HeadersRequestWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger)
{
this.logger = logger;
this.localClient = localClient;
this.blockchainDaemon = blockchainDaemon;
this.blockHeaderCache = blockHeaderCache;
this.headersRequestsByPeer = new ConcurrentDictionary <IPEndPoint, DateTime>();
this.localClient.OnBlockHeaders += HandleBlockHeaders;
this.blockchainDaemon.OnTargetChainChanged += HandleTargetChainChanged;
this.flushWorker = new WorkerMethod("HeadersRequestWorker.FlushWorker", FlushWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue, logger: this.logger);
this.flushQueue = new ConcurrentQueue <Tuple <RemoteNode, IImmutableList <BlockHeader> > >();
}
public IngestWorker(IVictoriaMetricClient victoriaMetricClient,
WorkerConfig workerConfig,
ILogger <IngestWorker> logger,
IHostApplicationLifetime lifetime)
{
_victoriaMetricClient = victoriaMetricClient;
_workerConfig = workerConfig;
_logger = logger;
_timer = BuildTimer(workerConfig);
lifetime.ApplicationStopping.Register(async() =>
{
_timer.Stop();
_timer.Dispose();
_tokenSource.Cancel();
await DoWork(default);
static void Main(string[] argss)
{
ServicePointManager.ServerCertificateValidationCallback =
delegate(object s, X509Certificate certificate,
X509Chain chain, SslPolicyErrors sslPolicyErrors)
{ return(true); };
var environment = EnvironmentResolver.GetEnvironmentName();
IAppCache cache = new CachingService {
DefaultCacheDuration = 60 * 5
};
IConfigReader configReader = ConfigReaderFactory.Create(cache, environment, "WORKER");
IWorkerConfiguration workerConfig = new WorkerConfig(configReader);
Host.Run(() => new ServiceApp(workerConfig));
}
protected override async Task OnInit()
{
blockGroupSystem = World.GetOrCreateSystem <BlockGroupSystem>();
workerFactorySystem = World.GetExistingSystem <WorkerFactorySystem>();
customWorker = Object.Instantiate(workerFactorySystem.DefaultWorker);
StorageUtil.DeserializeScriptable(customWorker);
customWorker.displayName = "Manual";
await workerFactorySystem.Register(customWorker);
await SetActiveWorker(customWorker);
while (blockGroupSystem.IsReady == false)
{
await Task.Yield();
}
isReady = true;
}
public LanguageWorkerChannelTests()
{
_logger = new TestLogger("FunctionDispatcherTests");
_testFunctionRpcService = new TestFunctionRpcService(_eventManager, _workerId, _logger, _expectedLogMsg);
_testWorkerConfig = TestHelpers.GetTestWorkerConfigs().FirstOrDefault();
_mockLanguageWorkerProcess.Setup(m => m.StartProcessAsync()).Returns(Task.CompletedTask);
_workerChannel = new LanguageWorkerChannel(
_workerId,
_scriptRootPath,
_eventManager,
_testWorkerConfig,
_mockLanguageWorkerProcess.Object,
_logger,
_mockMetricsLogger.Object,
0);
}
public TargetChainWorker(WorkerConfig workerConfig, Logger logger, IKernel kernel, IBlockchainRules rules, ChainedHeaderCache chainedHeaderCache, InvalidBlockCache invalidBlockCache)
: base("TargetChainWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger)
{
this.logger = logger;
this.rules = rules;
this.chainedHeaderCache = chainedHeaderCache;
this.invalidBlockCache = invalidBlockCache;
this.rescanEvent = new AutoResetEvent(false);
this.targetBlockWorker = kernel.Get <TargetBlockWorker>(
new ConstructorArgument("workerConfig", new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue)));
this.targetBlockWorker.OnTargetBlockChanged += HandleTargetBlockChanged;
this.chainedHeaderCache.OnAddition += HandleChainedHeader;
this.invalidBlockCache.OnAddition += HandleInvalidBlock;
}
public void ReadWorkerProviderFromConfig_ReturnsProviderWithArguments()
{
var expectedArguments = new string[] { "-v", "verbose" };
var configs = new List <TestLanguageWorkerConfig>()
{
MakeTestConfig(testLanguage, expectedArguments)
};
var testLogger = new TestLogger(testLanguage);
// Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig
IEnumerable <WorkerConfig> workerConfigs = TestReadWorkerProviderFromConfig(configs, testLogger);
Assert.Single(workerConfigs);
WorkerConfig worker = workerConfigs.FirstOrDefault();
Assert.True(expectedArguments.SequenceEqual(worker.Description.Arguments.ToArray()));
}
public void ReadWorkerProviderFromConfig_AddProfile_ReturnsDefaultDescription()
{
var expectedArguments = new string[] { "-v", "verbose" };
var configs = new List <TestLanguageWorkerConfig>()
{
MakeTestConfig(testLanguage, expectedArguments, false, "TestProfile")
};
var testLogger = new TestLogger(testLanguage);
// Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig
IEnumerable <WorkerConfig> workerConfigs = TestReadWorkerProviderFromConfig(configs, testLogger);
Assert.Single(workerConfigs);
WorkerConfig worker = workerConfigs.FirstOrDefault();
Assert.Equal(WorkerConfigTestUtilities.TestDefaultExecutablePath, worker.Description.DefaultExecutablePath);
}
public TargetBlockWorker(WorkerConfig workerConfig, Logger logger, ChainedHeaderCache chainedHeaderCache, InvalidBlockCache invalidBlockCache)
: base("TargetBlockWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger)
{
this.chainedHeaderCache = chainedHeaderCache;
this.invalidBlockCache = invalidBlockCache;
this.targetBlock = null;
this.targetBlockLock = new ReaderWriterLockSlim();
this.chainedHeaderQueue = new ConcurrentQueue <ChainedHeader>();
this.rescanEvent = new AutoResetEvent(false);
// wire up cache events
this.chainedHeaderCache.OnAddition += CheckChainedHeader;
this.invalidBlockCache.OnAddition += HandleInvalidBlock;
}
public void ReadWorkerProviderFromConfig_OverrideDefaultExePath()
{
var configs = new List <TestLanguageWorkerConfig>()
{
MakeTestConfig(testLanguage, new string[0], false, OutOfProcConstants.WorkerDescriptionAppServiceEnvProfileName)
};
var testLogger = new TestLogger(testLanguage);
var testExePath = "./mySrc/myIndex";
Dictionary <string, string> keyValuePairs = new Dictionary <string, string>
{
[$"{LanguageWorkerConstants.LanguageWorkersSectionName}:{testLanguage}:{OutOfProcConstants.WorkerDescriptionDefaultExecutablePath}"] = testExePath
};
var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage), null, keyValuePairs, true);
Assert.Single(workerConfigs);
WorkerConfig worker = workerConfigs.FirstOrDefault();
Assert.Equal(testExePath, worker.Description.DefaultExecutablePath);
}
public ChainStateWorker(WorkerConfig workerConfig, TargetChainWorker targetChainWorker, ChainStateBuilder chainStateBuilder, ICoreRules rules, CoreStorage coreStorage)
: base("ChainStateWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime)
{
this.rules = rules;
this.coreStorage = coreStorage;
this.blockProcessingDurationMeasure = new DurationMeasure(sampleCutoff: TimeSpan.FromMinutes(5));
this.blockMissCountMeasure = new CountMeasure(TimeSpan.FromSeconds(30));
this.targetChainWorker = targetChainWorker;
this.chainStateBuilder = chainStateBuilder;
this.currentChain = new Lazy <Chain>(() => this.chainStateBuilder.Chain);
this.coreStorage.BlockInvalidated += HandleChanged;
this.coreStorage.BlockTxesAdded += HandleChanged;
this.coreStorage.BlockTxesRemoved += HandleChanged;
this.coreStorage.ChainedHeaderAdded += HandleChanged;
this.coreStorage.ChainedHeaderRemoved += HandleChanged;
this.targetChainWorker.OnTargetChainChanged += HandleChanged;
}
public void ReadWorkerProviderFromAppSetting()
{
var testConfig = MakeTestConfig(testLanguage, new string[0]);
var configs = new List <TestLanguageWorkerConfig>()
{
testConfig
};
WorkerConfigTestUtilities.CreateWorkerFolder(customRootPath, testConfig);
Dictionary <string, string> keyValuePairs = new Dictionary <string, string>
{
[$"{LanguageWorkerConstants.LanguageWorkersSectionName}:{testLanguage}:{OutOfProcConstants.WorkerDirectorySectionName}"] = Path.Combine(customRootPath, testLanguage)
};
var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage), null, keyValuePairs);
Assert.Single(workerConfigs);
WorkerConfig workerConfig = workerConfigs.Single();
Assert.Equal(Path.Combine(customRootPath, testLanguage, $"{WorkerConfigTestUtilities.TestWorkerPathInWorkerConfig}.{testLanguage}"), workerConfig.Description.DefaultWorkerPath);
}
public void ReadWorkerProviderFromConfig_ArgumentsFromSettings()
{
var configs = new List <TestLanguageWorkerConfig>()
{
MakeTestConfig(testLanguage, new string[0])
};
// Creates temp directory w/ worker.config.json and runs ReadWorkerProviderFromConfig
Dictionary <string, string> keyValuePairs = new Dictionary <string, string>
{
[$"{LanguageWorkerConstants.LanguageWorkersSectionName}:{testLanguage}:{OutOfProcConstants.WorkerDescriptionArguments}"] = "--inspect=5689 --no-deprecation"
};
var workerConfigs = TestReadWorkerProviderFromConfig(configs, new TestLogger(testLanguage), null, keyValuePairs);
Assert.Single(workerConfigs);
Assert.Equal(Path.Combine(rootPath, testLanguage, $"{WorkerConfigTestUtilities.TestWorkerPathInWorkerConfig}.{testLanguage}"), workerConfigs.Single().Description.DefaultWorkerPath);
WorkerConfig worker = workerConfigs.FirstOrDefault();
Assert.True(worker.Description.Arguments.Count == 2);
Assert.True(worker.Description.Arguments.Contains("--inspect=5689"));
Assert.True(worker.Description.Arguments.Contains("--no-deprecation"));
}
static void HandleCalibration(int port, string model, string data)
{
Console.WriteLine("Starting CalibrationHandler ...");
var workerService = new WorkerService();
var config = new WorkerConfig
{
cPort = port.ToString() + "/tcp",
hIP = "0.0.0.0",
hPort = port.ToString(),
cmd = new List <string>
{
"dotnet", "/tmp/published/CalibrationHandler.dll", "tcp://0.0.0.0:" + port
//"python", "/tmp/worker.py", "tcp://*:"+config.cPort
}
};
// Start worker
workerService.StartWorker(config);
// Push task to worker and wait for ack
using (var worker = new RequestSocket("tcp://127.0.0.1:" + port))
{
// TODO: Serialize <model, data> ...
Console.WriteLine("Pushing to {0}", "tcp://localhost:" + port);
worker.SendFrame("Hey worker, do some work and get back to us ok?");
var response = worker.ReceiveFrameString();
Console.WriteLine("Calibration handler received: {0}", response);
}
// After ack from worker exit thread and let server collect
// finished tasks ...
}
public BlockRequestWorker(WorkerConfig workerConfig, LocalClient localClient, CoreDaemon coreDaemon)
: base("BlockRequestWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime)
{
this.localClient = localClient;
this.coreDaemon = coreDaemon;
this.coreStorage = coreDaemon.CoreStorage;
this.allBlockRequests = new ConcurrentDictionary <UInt256, BlockRequest>();
this.blockRequestsByPeer = new ConcurrentDictionary <Peer, ConcurrentDictionary <UInt256, DateTimeOffset> >();
this.missedBlockRequests = new ConcurrentDictionary <UInt256, BlockRequest>();
this.localClient.OnBlock += HandleBlock;
this.coreDaemon.OnChainStateChanged += HandleChainStateChanged;
this.coreDaemon.OnTargetChainChanged += HandleTargetChainChanged;
this.coreDaemon.BlockMissed += HandleBlockMissed;
this.blockRequestDurationMeasure = new DurationMeasure(sampleCutoff: TimeSpan.FromMinutes(5));
this.blockDownloadRateMeasure = new RateMeasure();
this.duplicateBlockDownloadCountMeasure = new CountMeasure(TimeSpan.FromSeconds(30));
this.targetChainQueue = new List <ChainedHeader>();
this.targetChainQueueIndex = 0;
this.targetChainLookAhead = 1;
this.flushWorker = new ActionBlock <FlushBlock>((Action <FlushBlock>)FlushWorkerMethod,
new ExecutionDataflowBlockOptions {
MaxDegreeOfParallelism = Environment.ProcessorCount
});
this.flushQueue = new BufferBlock <FlushBlock>();
this.flushBlocks = new ConcurrentSet <UInt256>();
this.flushQueue.LinkTo(this.flushWorker, new DataflowLinkOptions {
PropagateCompletion = true
});
this.diagnosticWorker = new WorkerMethod("BlockRequestWorker.DiagnosticWorker", DiagnosticWorkerMethod, initialNotify: true, minIdleTime: TimeSpan.FromSeconds(10), maxIdleTime: TimeSpan.FromSeconds(10));
}
/// <summary>
/// Cria uma nova instância do objeto
/// </summary>
public IntegracaoCorreios(IOptions <WorkerConfig> options)
{
_config = options?.Value;
}
public MergeLeaderSeeker(Transform transform, WorkerConfig wc, LanesDatabase lanes) : base(transform, wc, lanes)
{
}
public void TestPruneAllData()
{
// create genesis block
var genesisblock = CreateFakeBlock(1);
var genesisHeader = new ChainedHeader(genesisblock.Header, height: 0, totalWork: genesisblock.Header.CalculateWork().ToBigInteger(), dateSeen: DateTimeOffset.Now);
// create a block
var txCount = 100;
var block = CreateFakeBlock(txCount, genesisblock.Hash);
var chainedHeader = ChainedHeader.CreateFromPrev(genesisHeader, block.Header, dateSeen: DateTimeOffset.Now);
// create a long chain based off the block, to account for pruning buffer
var fakeHeaders = new FakeHeaders(new[] { genesisHeader, chainedHeader });
var chain = new ChainBuilder(Enumerable.Concat(new[] { genesisHeader, chainedHeader }, Enumerable.Range(0, 2000).Select(x => fakeHeaders.NextChained()))).ToImmutable();
// mock core daemon to return the chain
var coreDaemon = new Mock <ICoreDaemon>();
coreDaemon.Setup(x => x.CurrentChain).Returns(chain);
// create memory storage with the block
var storageManager = new MemoryStorageManager();
storageManager.BlockTxesStorage.TryAddBlockTransactions(block.Hash, block.BlockTxes);
// initialize the pruning worker
var workerConfig = new WorkerConfig(initialNotify: false, minIdleTime: TimeSpan.Zero, maxIdleTime: TimeSpan.MaxValue);
using (var pruningWorker = new PruningWorker(workerConfig, coreDaemon.Object, storageManager, null))
// get a chain state cursor
using (var handle = storageManager.OpenChainStateCursor())
{
var chainStateCursor = handle.Item;
// set the pruning worker to prune all data
pruningWorker.Mode = PruningMode.TxIndex | PruningMode.BlockSpentIndex | PruningMode.BlockTxesPreserveMerkle;
// wire event to wait for work
var workFinishedEvent = new AutoResetEvent(false);
pruningWorker.OnWorkFinished += () => workFinishedEvent.Set();
// wire event to track exceptions
Exception workException = null;
pruningWorker.OnWorkError += e => workException = e;
// start the worker
pruningWorker.Start();
// pick a random pruning order
var random = new Random();
var pruneOrderSource = Enumerable.Range(0, txCount).ToList();
var pruneOrder = new List <int>(txCount);
while (pruneOrderSource.Count > 0)
{
var randomIndex = random.Next(pruneOrderSource.Count);
pruneOrder.Add(pruneOrderSource[randomIndex]);
pruneOrderSource.RemoveAt(randomIndex);
}
// add an unspent tx for each transaction to storage
var unspentTxes = new UnspentTx[block.Transactions.Length];
chainStateCursor.BeginTransaction();
for (var txIndex = 0; txIndex < block.Transactions.Length; txIndex++)
{
var tx = block.Transactions[txIndex];
var unspentTx = new UnspentTx(tx.Hash, blockIndex: 1, txIndex: txIndex, txVersion: tx.Version, isCoinbase: txIndex == 0, outputStates: new OutputStates(1, OutputState.Spent));
unspentTxes[txIndex] = unspentTx;
chainStateCursor.TryAddUnspentTx(unspentTx);
}
chainStateCursor.CommitTransaction();
// create a memory pruning cursor to verify expected pruning results
var pruneCursor = new MemoryMerkleTreePruningCursor <BlockTxNode>(block.BlockTxes.Select(x => (BlockTxNode)x));
// prune each transaction in random order
var pruneHeight = 0;
foreach (var pruneTxIndex in pruneOrder)
{
// create a spent tx to prune the transaction
var pruneTx = block.Transactions[pruneTxIndex];
var spentTxes = BlockSpentTxes.CreateRange(new[] { unspentTxes[pruneTxIndex].ToSpentTx() });
// store the spent txes for the current pruning block
pruneHeight++;
chainStateCursor.BeginTransaction();
Assert.IsTrue(chainStateCursor.TryAddBlockSpentTxes(pruneHeight, spentTxes));
pruningWorker.PrunableHeight = pruneHeight;
// verify unspent tx is present before pruning
Assert.IsTrue(chainStateCursor.ContainsUnspentTx(pruneTx.Hash));
chainStateCursor.CommitTransaction();
// notify the pruning worker and wait
pruningWorker.NotifyWork();
workFinishedEvent.WaitOne();
// verify unspent tx is removed after pruning
chainStateCursor.BeginTransaction();
Assert.IsFalse(chainStateCursor.ContainsUnspentTx(pruneTx.Hash));
// verify unspent tx outputs are removed after pruning
for (var outputIndex = 0; outputIndex < pruneTx.Outputs.Length; outputIndex++)
{
Assert.IsFalse(chainStateCursor.ContainsUnspentTxOutput(new TxOutputKey(pruneTx.Hash, (uint)outputIndex)));
}
// verify the spent txes were removed
Assert.IsFalse(chainStateCursor.ContainsBlockSpentTxes(pruneHeight));
chainStateCursor.RollbackTransaction();
// prune to determine expected results
MerkleTree.PruneNode(pruneCursor, pruneTxIndex);
var expectedPrunedTxes = pruneCursor.ReadNodes().ToList();
// retrieve the actual transaction after pruning
IEnumerator <BlockTxNode> actualPrunedTxNodes;
Assert.IsTrue(storageManager.BlockTxesStorage.TryReadBlockTxNodes(block.Hash, out actualPrunedTxNodes));
// verify the actual pruned transactions match the expected results
CollectionAssert.AreEqual(expectedPrunedTxes, actualPrunedTxNodes.UsingAsEnumerable().ToList());
}
// verify all unspent txes were removed
chainStateCursor.BeginTransaction();
Assert.AreEqual(0, chainStateCursor.ReadUnspentTransactions().Count());
chainStateCursor.CommitTransaction();
// verify final block with all transactions pruned
IEnumerator <BlockTxNode> finalPrunedTxNodes;
Assert.IsTrue(storageManager.BlockTxesStorage.TryReadBlockTxNodes(block.Hash, out finalPrunedTxNodes));
var finalPrunedTxesList = finalPrunedTxNodes.UsingAsEnumerable().ToList();
Assert.AreEqual(1, finalPrunedTxesList.Count);
Assert.AreEqual(block.Header.MerkleRoot, finalPrunedTxesList.Single().Hash);
// verify no work exceptions occurred
Assert.IsNull(workException);
}
}
protected SeekPosition(WorkerConfig wc, Rigidbody rb, Transform transform)
{
this.wc = wc;
this.rb = rb;
this.transform = transform;
}
//SkinnedMeshRenderer hel;
//SkinnedMeshRenderer ov;
//List<Mesh> helMesh = new List<Mesh>();
//List<Mesh> ovMesh = new List<Mesh>();
public MergerCollide(WorkerConfig wc, MeshChange mc, WorkerFSM w)
{
this.wc = wc;
wfsm = w;
m_meshChange = mc;
}
public TutJumpSlide(WorkerConfig wc, BoxCollider mCollider, Animator mAnimator, Transform transform,
GameObject shadow, WorkerFSM workerController) : base(wc, mCollider, mAnimator, transform, shadow, workerController)
{
}
protected virtual void OnWorkerAssigned(WorkerConfig config)
{
}
public ChainStateWorker(TargetChainWorker targetChainWorker, ChainStateBuilder chainStateBuilder, Func <Chain> getTargetChain, WorkerConfig workerConfig, Logger logger, IKernel kernel, IBlockchainRules rules, BlockCache blockCache, SpentTransactionsCache spentTransactionsCache, InvalidBlockCache invalidBlockCache)
: base("ChainStateWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime, logger)
{
this.logger = logger;
this.getTargetChain = getTargetChain;
this.kernel = kernel;
this.rules = rules;
this.blockCache = blockCache;
this.spentTransactionsCache = spentTransactionsCache;
this.invalidBlockCache = invalidBlockCache;
this.blockProcessingDurationMeasure = new DurationMeasure();
this.targetChainWorker = targetChainWorker;
this.chainStateBuilder = chainStateBuilder;
this.currentChain = this.chainStateBuilder.Chain.ToImmutable();
this.pruningWorker = kernel.Get <PruningWorker>(
new ConstructorArgument("workerConfig", new WorkerConfig(initialNotify: false, minIdleTime: TimeSpan.FromSeconds(30), maxIdleTime: TimeSpan.FromMinutes(5))),
new ConstructorArgument("getChainStateBuilder", (Func <ChainStateBuilder>)(() => this.chainStateBuilder)));
}
public PositionWorker(WorkerConfig wc, Rigidbody rb, Transform transform, int id) : base(wc, rb, transform, id)
{
}
protected override void OnWorkerAssigned(WorkerConfig config)
{
input.SetBounds(MIN, MAX);
input.SetInitialValue(config.power);
}
