private BlockVm GenerateBlock(object @object)
{
try
{
BlockVm block = (BlockVm)@object;
Task <byte[]> hashGenerationProcess = new Task <byte[]>((obj) => BlockHashing.ComputeBlockHashPoW((BlockVm)obj), block);
hashGenerationProcess.Start();
while (!hashGenerationProcess.IsCompleted)
{
blockGenerationCancellToken.ThrowIfCancellationRequested();
Task.Delay(250).Wait();
}
block.Header.Hash = hashGenerationProcess.Result;
block.Header.Sign = Encryptor.GetSign(BlockHashing.GetBlockBytes(block), NodeData.Instance.NodeKeys.SignPrivateKey, NodeData.Instance.NodeKeys.Password);
block.Header.SignKeyId = NodeData.Instance.NodeKeys.KeyId;
using (BlockchainDbContext context = new BlockchainDbContext())
{
var resultBlock = context.Add(BlockBuilder.GetBlock(block));
context.SaveChanges();
return(BlockBuilder.GetBlockVm(resultBlock.Entity));
}
}
catch (Exception ex)
{
throw new BlockGenerationException("An error occurred while generating the block.", ex);
}
}
public async Task SaveBlockDataAsync(BlockVm block)
{
foreach (var segment in block.BlockSegments.OrderBy(opt => opt.SegmentHeader.BlockSegmentType))
{
await SaveBlockSegmentDataAsync(segment).ConfigureAwait(false);
}
}
public void HandleNewBlock(BlockVm block)
{
if (blockGenerationTask != null && !blockGenerationTask.IsCompleted)
{
blockGenerationCancellToken.Register(BlockGenerationCancelledHandleDelegate, block);
cancellationTokenSource.Cancel();
}
}
/// <summary>
/// Creates a report for the given block, fills all process reports
/// </summary>
/// <param name="block"></param>
public BlockReportVm(BlockVm vm)
{
_parent = vm;
UOW = new Dal.SoheilEdmContext();
TaskDataService = new DataServices.TaskDataService(UOW);
ProcessReportDataService = new DataServices.ProcessReportDataService(UOW);
entity = new DataServices.BlockDataService(UOW).GetSingle(vm.Id);
ReloadReports();
}
private void BlockGenerationCancelledHandleDelegate(object blockObject)
{
BlockVm block = (BlockVm)blockObject;
List <BlockSegmentVm> uniqueBlockSegments = currentSegments.Where(segment => !block.BlockSegments.Any(opt => opt.SegmentHash.SequenceEqual(segment.SegmentHash))).ToList();
if (uniqueBlockSegments.Any())
{
AddSegments(uniqueBlockSegments);
}
}
public async void SendNewBlockNodeNoticeAsync(BlockVm block)
{
try
{
BlocksNodeNotice notice = new BlocksNodeNotice(Enums.NodeNoticeCode.NewBlocks, block);
await SendNoticeToNodesAsync(notice).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
private async Task BeginBlockGenerationAsync()
{
if (blockGenerationTask == null || blockGenerationTask.IsCompleted)
{
IEnumerable <BlockSegmentVm> blockSegments;
List <BlockSegmentVm> resultBlockSegments = new List <BlockSegmentVm>();
blockSegments = await cacheService.GetBlockSegments(MAX_BLOCK_SEGMENTS_COUNT).ConfigureAwait(false);
resultBlockSegments.AddRange(await BlockSegmentsService.Instance.GetNonExistingSemgentsAsync(blockSegments).ConfigureAwait(false));
var block = await BlocksService.FormFullBlockAsync(resultBlockSegments, NodeSettings.Configs.Node.Id).ConfigureAwait(false);
currentSegments = resultBlockSegments;
blockGenerationTask = Task <BlockVm> .Factory.StartNew(GenerateBlock, block, blockGenerationCancellToken);
try
{
BlockVm generatedBlock = await blockGenerationTask.ConfigureAwait(true);
NodeNoticeService.SendNewBlockNodeNoticeAsync(generatedBlock);
await LicensorClient.Instance.AddNewBlockAsync(generatedBlock).ConfigureAwait(false);
}
catch (BlockGenerationException)
{
blockGenerationTask.Dispose();
cancellationTokenSource = new CancellationTokenSource();
blockGenerationCancellToken = cancellationTokenSource.Token;
}
catch (TaskCanceledException)
{
blockGenerationTask.Dispose();
cancellationTokenSource = new CancellationTokenSource();
blockGenerationCancellToken = cancellationTokenSource.Token;
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
finally
{
blockGenerationTask = null;
}
}
}
public async Task AddNewBlockAsync(BlockVm block)
{
if (!await TryConnectAsync().ConfigureAwait(false))
{
return;
}
AddNewBlockRequest request = new AddNewBlockRequest(block);
await SendRequestAsync(request).ConfigureAwait(false);
var response = await GetResponseAsync(request).ConfigureAwait(false);
if (response is ResultResponse resultResponse)
{
if (!string.IsNullOrWhiteSpace(resultResponse.ErrorMessage))
{
BlockchainSynchronizationService synchronizationService = new BlockchainSynchronizationService();
await synchronizationService.CheckAndSyncBlockchainAsync().ConfigureAwait(false);
}
}
}
public BlocksNodeNotice(NodeNoticeCode noticeCode, BlockVm block)
{
Block = block;
NoticeCode = noticeCode;
}
public void HandleNewBlock(BlockVm block)
{
_blockGenerationHelper.HandleNewBlock(block);
}
