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); }