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