public async Task <ActionResult> UpdateWorker(int id) { var pools = await PoolReader.GetPools(); var worker = await PoolWorkerReader.AdminGetWorker(User.Identity.GetUserId(), id); var poolconnection = await PoolReader.GetPoolConnection(worker.AlgoType); return(View("UpdateWorkerModal", new AdminPoolWorkerUpdateModel { Id = id, Name = worker.Name, AlgoType = worker.AlgoType, IsAutoSwitch = worker.IsAutoSwitch, Password = worker.Password, TargetDifficulty = worker.TargetDifficulty, DefaultDiff = poolconnection.DefaultDiff, FixedDiffSummary = poolconnection.FixedDiffSummary, VarDiffHighSummary = poolconnection.VarDiffHighSummary, VarDiffLowSummary = poolconnection.VarDiffLowSummary, VarDiffMediumSummary = poolconnection.VarDiffMediumSummary, DifficultyOption = PoolExtensions.TargetDifficultyToOption(worker.TargetDifficulty), TargetPool = worker.TargetPool, Pools = pools.Where(x => x.AlgoType == worker.AlgoType).OrderBy(x => x.Symbol).ToList() })); }
public async Task <HashrateChartModel> GetHashrateChart(int poolId, string userId) { var currentUser = !string.IsNullOrEmpty(userId) ? new Guid(userId) : Guid.Empty; var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.MineshaftHashrateChart(poolId, currentUser), TimeSpan.FromMinutes(5), async() => { using (var context = PoolDataContextFactory.CreateContext()) { var chartData = new HashrateChartModel(); var pool = await context.Pool.FirstOrDefaultNoLockAsync(x => x.Id == poolId).ConfigureAwait(false); var statInterval = 30; var finish = DateTime.UtcNow; var start = finish.AddHours(-24); var totalChartPoints = (1440 * 1) / statInterval; var shareData = await context.Database.SqlQuery <HashrateChartData>(string.Format(_query, pool.TablePrefix), start).ToListNoLockAsync().ConfigureAwait(false); if (shareData.IsNullOrEmpty()) { return(chartData); } var userShareData = new List <HashrateChartData>(); if (currentUser != Guid.Empty) { userShareData = await context.Database.SqlQuery <HashrateChartData>(string.Format(_userQuery, pool.TablePrefix), currentUser, start).ToListNoLockAsync().ConfigureAwait(false); } for (int i = 0; i < totalChartPoints; i++) { var rangeStart = start.AddMinutes(i *statInterval); var rangeEnd = rangeStart.AddMinutes(statInterval); var data = shareData.FirstOrDefault(x => x.Timestamp > rangeStart && x.Timestamp <= rangeEnd); var javaTime = rangeStart.ToJavaTime(); var statPeriod = i == totalChartPoints ? (data.LastTime - rangeStart).TotalMinutes : statInterval * 60; var hashrate = data != null ? PoolExtensions.CalculateHashrate(data.Shares, pool.AlgoType, statPeriod) : 0.0; chartData.PoolData.Add(new[] { javaTime, hashrate }); if (currentUser != Guid.Empty) { var userData = userShareData.FirstOrDefault(x => x.Timestamp > rangeStart && x.Timestamp <= rangeEnd); var userHashrate = userData != null ? PoolExtensions.CalculateHashrate(userData.Shares, pool.AlgoType, statPeriod) : 0.0; chartData.UserData.Add(new[] { javaTime, userHashrate }); } } return(chartData); } }).ConfigureAwait(false); return(cacheResult); }
public void Execute(List <Entity> entities) { foreach (var e in entities) { bool pathComplete = false; Entity startNode = e.request.start; Entity targetNode = e.request.target; startNode.AddNode(null, PoolExtensions.GetDistanceBetweenNodes(startNode, targetNode), 0, PoolExtensions.GetDistanceBetweenNodes(startNode, targetNode)); // Nodes to process List <Entity> openList = new List <Entity>(); // Already processed nodes List <Entity> closedList = new List <Entity>(); Entity currentNode; openList.Add(startNode); while (openList.Count > 0 && !pathComplete) { currentNode = openList[0]; foreach (Entity node in openList) { if (node.node.fcost < currentNode.node.fcost || (node.node.fcost == currentNode.node.fcost && node.node.hcost < currentNode.node.hcost)) { currentNode = node; } } openList.Remove(currentNode); closedList.Add(currentNode); if (currentNode == targetNode) { e.IsCompleted(true); e.path.path = PoolExtensions.RetracePath(startNode, targetNode); pathComplete = true; } else { } } } }
public async Task <ActionResult> CreateWorker(PoolWorkerCreateModel model) { if (!ModelState.IsValid) { var connections = await PoolReader.GetPoolConnections(); model.AlgoTypes = connections.Select(x => x.AlgoType).Distinct().ToList(); model.Connections = connections; return(View("CreateWorkerModal", model)); } model.FullName = string.Format("{0}.{1}", User.Identity.Name, model.Name); model.TargetDifficulty = PoolExtensions.OptionToTargetDifficulty(model.DifficultyOption, model.TargetDifficulty); var result = await PoolWorkerWriter.CreateWorker(User.Identity.GetUserId(), model); if (!ModelState.IsWriterResultValid(result)) { return(View("CreateWorkerModal", model)); } return(CloseModal(result)); }
public async Task <ActionResult> UpdateWorker(PoolWorkerUpdateModel model) { if (!ModelState.IsValid) { var poolconnection = await PoolReader.GetPoolConnection(model.AlgoType); model.FixedDiffSummary = poolconnection.FixedDiffSummary; model.VarDiffHighSummary = poolconnection.VarDiffHighSummary; model.VarDiffLowSummary = poolconnection.VarDiffLowSummary; model.VarDiffMediumSummary = poolconnection.VarDiffMediumSummary; return(View("UpdateWorkerModal", model)); } model.TargetDifficulty = PoolExtensions.OptionToTargetDifficulty(model.DifficultyOption, model.TargetDifficulty); var result = await PoolWorkerWriter.UpdateWorker(User.Identity.GetUserId(), model); if (!ModelState.IsWriterResultValid(result)) { return(View("UpdateWorkerModal", model)); } return(CloseModal(result)); }
protected virtual void Awake() { pool = PoolExtensions.Factory(prefab, folder); pool.Fill(10); }
protected virtual void Awake() { tracerPool = PoolExtensions.Factory(tracerPrefab, folder); tracerPool.Fill(10); }