public async Task <IActionResult> BlockUser([FromBody] BlockRequest blockRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByNameAsync(blockRequest.Username);
if (user != null)
{
var isAdmin = await _userManager.IsInRoleAsync(user, UserRoleString.Admin);
if (isAdmin)
{
return(Forbid("Admins cannot be blocked"));
}
user.IsBlocked = blockRequest.Block;
await _userManager.UpdateAsync(user);
if (blockRequest.Block)
{
return(Ok($"User \"{blockRequest.Username}\" blocked successfully"));
}
return(Ok($"User \"{blockRequest.Username}\" unblocked successfully"));
}
return(BadRequest($"User with username - \"{blockRequest.Username}\" does not exist"));
}
/// <summary>
/// This method returns a block. The parameter is a <see cref="BlockRequest"/> object, if the value
/// of <see cref="BlockRequest.Hash"/> is not null, the request is by ID, otherwise it will be
/// by height.
/// </summary>
public override async Task <BlockReply> RequestBlock(BlockRequest request, ServerCallContext context)
{
if (request == null || request.Hash == null || _syncStateService.SyncState != SyncState.Finished)
{
return(new BlockReply());
}
Logger.LogDebug($"Peer {context.GetPeerInfo()} requested block {request.Hash}.");
BlockWithTransactions block;
try
{
block = await _blockchainService.GetBlockWithTransactionsByHash(request.Hash);
if (block == null)
{
Logger.LogDebug($"Could not find block {request.Hash} for {context.GetPeerInfo()}.");
}
else
{
var peer = _connectionService.GetPeerByPubkey(context.GetPublicKey());
peer.TryAddKnownBlock(block.GetHash());
}
}
catch (Exception e)
{
Logger.LogError(e, $"Request block error: {context.GetPeerInfo()}");
throw;
}
return(new BlockReply {
Block = block
});
}
internal BlockResponse RequestBlocksAsync(uint startBlock, uint quantity, uint?requestId = null)
{
BlockRequest br = new BlockRequest
{
StartBlock = startBlock,
BlockNumber = quantity,
Operation = NetOperationType.Blocks
};
if (requestId != null)
{
br.RequestId = requestId.Value;
}
using (MemoryStream ms = new MemoryStream())
{
br.SaveToStream(ms);
ms.Position = 0;
SendRaw(ms);
}
WaitForData(10000);
using (var rs = new MemoryStream())
{
var rp = ReadResponseSync(rs);
switch (rp.Operation)
{
case NetOperationType.Blocks:
return(new BlockResponse(rs, rp));
default:
throw new InvalidDataException();
}
}
}
public IActionResult ChangeBlock([FromBody] BlockRequest request)
{
var userContext = _dbContext.Set <User>();
var user = userContext.FirstOrDefault(x => x.Email == request.Email);
if (user == null)
{
return(BadRequest($"User with email: {request.Email} not found"));
}
if (user.Blocked == request.Blocked)
{
var str = user.Blocked ? "already Blocked" : "not Blocked";
return(BadRequest($"This user is { str }"));
}
user.Blocked = request.Blocked;
var result = _dbContext.SaveChanges();
if (result > 0)
{
return(Ok());
}
return(BadRequest("Something wrong in db"));
}
private void SendPiece(PeerConnection peer, BlockRequest request)
{
long dataOffset = application.Metainfo.PieceSize * request.PieceIndex + request.Offset;
byte[] data = application.DataHandler.ReadBlockData(dataOffset, request.Length);
peer.SendMessage(new PieceMessage(request.ToBlock(data)));
}
/// <summary>
/// Gets a block by id
/// path: /api/blocks/get
/// </summary>
/// <param name="req">BlockRequest</param>
/// <returns>BlockResponse with block details</returns>
public async Task <BlockResponse> GetBlockAsync(BlockRequest req)
{
_url.Path = Constants.ApiGetBlocksBlock;
_url.Query = req.ToQuery();
var response = await _client.GetJsonAsync <BlockResponse>(_url.ToString());
ResetPath();
return(response);
}
private void SendPiece(BitTorrentPeer peer, BlockRequest request)
{
long dataOffset = ApplicationProtocol.Metainfo.PieceSize * request.PieceIndex + request.Offset;
byte[] data = ApplicationProtocol.DataHandler.ReadBlockData(dataOffset, request.Length);
peer.SendMessage(new PieceMessage(request.ToBlock(data)));
ApplicationProtocol.UploadedData(data);
}
public PageBlockRequest(BlockRequest block)
{
InitializeComponent();
vm = block;
DataContext = vm;
foreach (string i in Enum.GetNames(typeof(Extreme.Net.HttpMethod)))
{
methodCombobox.Items.Add(i);
}
methodCombobox.SelectedIndex = (int)vm.Method;
foreach (string t in Enum.GetNames(typeof(RequestType)))
{
requestTypeCombobox.Items.Add(t);
}
requestTypeCombobox.SelectedIndex = (int)vm.RequestType;
foreach (string t in Enum.GetNames(typeof(ResponseType)))
{
responseTypeCombobox.Items.Add(t);
}
responseTypeCombobox.SelectedIndex = (int)vm.ResponseType;
customCookiesRTB.AppendText(vm.GetCustomCookies());
customHeadersRTB.AppendText(vm.GetCustomHeaders());
multipartContentsRTB.AppendText(vm.GetMultipartContents());
List <string> commonContentTypes = new List <string>()
{
"application/x-www-form-urlencoded",
"application/json",
"text/plain"
};
foreach (var c in commonContentTypes)
{
contentTypeCombobox.Items.Add(c);
}
foreach (var s in Enum.GetNames(typeof(SecurityProtocol)))
{
securityProtocolCombobox.Items.Add(s);
}
foreach (var p in vm.ProtocolVersions)
{
protocolVersionComboBox.Items.Add(p);
}
protocolVersionComboBox.Text = vm.ProtocolVersion.ToString();
securityProtocolCombobox.SelectedIndex = (int)vm.SecurityProtocol;
}
private async Task DequeueForcedBlocksAsync(BlockRequest blockRequest, List <string> forcedBlockQueueIds)
{
var request = new DequeueForcedBlocksRequest(
new TaskId(blockRequest.ApplicationName, blockRequest.TaskName),
blockRequest.TaskExecutionId,
blockRequest.BlockType,
forcedBlockQueueIds);
await _blockRepository.DequeueForcedBlocksAsync(request).ConfigureAwait(false);
}
private void DequeueForcedBlocks(BlockRequest blockRequest, List <string> forcedBlockQueueIds)
{
var request = new DequeueForcedBlocksRequest(
new TaskId(blockRequest.ApplicationName, blockRequest.TaskName),
blockRequest.TaskExecutionId,
blockRequest.BlockType,
forcedBlockQueueIds);
_blockRepository.DequeueForcedBlocks(request);
}
public async Task <Block> RequestBlockAsync(Hash hash)
{
var blockRequest = new BlockRequest {
Hash = hash
};
var blockReply = await RequestAsync(_client, c => c.RequestBlockAsync(blockRequest),
$"Block request for {hash} failed.");
return(blockReply?.Block);
}
public async Task <IActionResult> Block([FromBody] BlockRequest request)
{
var block = await m_ChainManager.GetBlockAsync(request);
if (block == null)
{
return(NotFound("block not found"));
}
return(Json(block));
}
private List <RangeBlockContext> CreateBlockContexts(BlockRequest blockRequest, IList <RangeBlock> rangeBlocks)
{
var blocks = new List <RangeBlockContext>();
foreach (var rangeBlock in rangeBlocks)
{
var blockContext = CreateBlockContext(blockRequest, rangeBlock);
blocks.Add(blockContext);
}
return(blocks);
}
public override Task <BlocksResponse> GetBlocks(BlockRequest request, ServerCallContext context)
{
var blocks = this.blockChain.GetBlocks(request.PageNumber, request.ResultPerPage);
var response = new BlocksResponse();
foreach (var block in blocks)
{
response.Blocks.Add(ConvertBlockToBlockModel(block));
}
return(Task.FromResult(response));
}
private async Task <List <RangeBlockContext> > CreateBlockContextsAsync(BlockRequest blockRequest, IList <RangeBlock> rangeBlocks)
{
var blocks = new List <RangeBlockContext>();
foreach (var rangeBlock in rangeBlocks)
{
var blockContext = await CreateBlockContextAsync(blockRequest, rangeBlock).ConfigureAwait(false);
blocks.Add(blockContext);
}
return(blocks);
}
public override Task <BlocksResponse> GetBlocks(BlockRequest request, ServerCallContext context)
{
var blocks = Blockchain.GetBlocks(request.PageNumber, request.ResultPerPage);
BlocksResponse response = new BlocksResponse();
foreach (Block block in blocks)
{
BlockModel mdl = ConvertBlock(block);
response.Blocks.Add(mdl);
}
return(Task.FromResult(response));
}
private FindDeadBlocksRequest CreateDeadBlocksRequest(BlockRequest blockRequest, int blockCountLimit)
{
var utcNow = DateTime.UtcNow;
return(new FindDeadBlocksRequest(new TaskId(blockRequest.ApplicationName, blockRequest.TaskName),
blockRequest.TaskExecutionId,
blockRequest.BlockType,
utcNow - blockRequest.DeadTaskDetectionRange,
utcNow.AddMinutes(-1),
blockCountLimit,
blockRequest.TaskDeathMode,
blockRequest.DeadTaskRetryLimit));
}
/// <inheritdoc />
public override string SolveRecaptcha(string siteKey, string siteUrl)
{
// Create task
HttpRequest request = new HttpRequest();
request.AddHeader(HttpHeader.Accept, "application/json");
var content = new Extreme.Net.MultipartContent(BlockRequest.GenerateMultipartBoundary());
content.Add(new Extreme.Net.StringContent(User), "username");
content.Add(new Extreme.Net.StringContent(Pass), "password");
content.Add(new Extreme.Net.StringContent("4"), "type");
content.Add(new Extreme.Net.StringContent(JsonConvert.SerializeObject(new CreateRecaptchaTaskRequest(siteUrl, siteKey))), "token_params");
var response = request.Post("http://api.dbcapi.me/api/captcha", content).ToString();
var split = response.Split('&');
var status = int.Parse(split[0].Split('=')[1]);
var id = split[1].Split('=')[1];
if (status == 255)
{
throw new Exception(response);
}
TaskId = id;
Status = CaptchaStatus.Processing;
// Check if task has been completed
DateTime start = DateTime.Now;
while (Status == CaptchaStatus.Processing && (DateTime.Now - start).TotalSeconds < Timeout)
{
Thread.Sleep(5000);
HttpRequest gRequest = new HttpRequest();
gRequest.AddHeader(HttpHeader.Accept, "application/json");
HttpResponse gResponse = gRequest.Get($"http://api.dbcapi.me/api/captcha/{TaskId}");
var resp = gResponse.ToString();
CreateTaskResponse gtrr = JsonConvert.DeserializeObject <CreateTaskResponse>(resp);
if (gtrr == null)
{
continue;
}
if (!gtrr.is_correct)
{
throw new Exception("No answer could be found");
}
if (gtrr.text != "")
{
Status = CaptchaStatus.Completed;
return(gtrr.text);
}
}
throw new TimeoutException();
}
/// <summary>
/// Receives a message by reading it from the specified reader.
/// <remarks>The length and ID of the message have already been read.</remarks>
/// </summary>
/// <param name="reader">The reader to use.</param>
/// <param name="length">The length of the message, in bytes.</param>
public override void Receive(BinaryReader reader, int length)
{
// Piece index of block
int pieceIndex = reader.ReadInt32();
// Block offset within piece
int blockOffset = reader.ReadInt32();
// Block length
int blockLength = reader.ReadInt32();
// Set block
this.Block = new BlockRequest(pieceIndex, blockOffset, blockLength);
}
public async Task <IActionResult> AddBlock(BlockRequest bData)
{
_logger.LogInformation($"Invoking endpoint: {this.HttpContext.Request.GetDisplayUrl()}");
_logger.LogDebug($"Request - Adding Blocks data - {JsonConvert.SerializeObject(bData)}");
var addEditResponse = await _blockService.AddBlock(bData);
_logger.LogInformation($" Add Block {addEditResponse}");
_logger.LogDebug($"Response - Adding Blocks data - {JsonConvert.SerializeObject(addEditResponse)}");
return(Ok(new AddEditResponse
{
Status = addEditResponse.Status,
Message = addEditResponse.Message,
}));
}
public virtual async Task <Response <object> > BlockAsync(BlockRequest body, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("RosettaClient.Block");
scope.Start();
try
{
return(await RestClient.BlockAsync(body, cancellationToken).ConfigureAwait(false));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
private void LoadFailedAndDeadBlocks(BlockRequest blockRequest, List <RangeBlockContext> blocks)
{
int blocksRemaining = blockRequest.MaxBlocks - blocks.Count;
if (blockRequest.ReprocessDeadTasks)
{
blocks.AddRange(GetDeadBlocks(blockRequest, blocksRemaining));
}
if (GetBlocksRemaining(blockRequest, blocks) > 0 && blockRequest.ReprocessFailedTasks)
{
blocks.AddRange(GetFailedBlocks(blockRequest, blocksRemaining));
}
}
public virtual Response <object> Block(BlockRequest body, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("RosettaClient.Block");
scope.Start();
try
{
return(RestClient.Block(body, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
private async Task LoadFailedAndDeadBlocksAsync(BlockRequest blockRequest, List <RangeBlockContext> blocks)
{
int blocksRemaining = blockRequest.MaxBlocks - blocks.Count;
if (blockRequest.ReprocessDeadTasks)
{
blocks.AddRange(await GetDeadBlocksAsync(blockRequest, blocksRemaining).ConfigureAwait(false));
}
if (GetBlocksRemaining(blockRequest, blocks) > 0 && blockRequest.ReprocessFailedTasks)
{
blocks.AddRange(await GetFailedBlocksAsync(blockRequest, blocksRemaining).ConfigureAwait(false));
}
}
/// <summary>
/// Receives a message by reading it from the specified reader.
/// <remarks>The length and ID of the message have already been read.</remarks>
/// </summary>
/// <param name="reader">The reader to use.</param>
/// <param name="length">The length of the message, in bytes.</param>
public override void Receive(BinaryReader reader, int length)
{
// Index of piece
int pieceIndex = reader.ReadInt32();
// Offset of block
int blockOffset = reader.ReadInt32();
// Length of block
int blockLength = reader.ReadInt32();
// Create block object
Block = new BlockRequest(pieceIndex, blockOffset, blockLength);
}
private async Task <List <RangeBlockContext> > GetFailedBlocksAsync(BlockRequest blockRequest, int blockCountLimit)
{
var failedBlockRequest = new FindFailedBlocksRequest(new TaskId(blockRequest.ApplicationName, blockRequest.TaskName),
blockRequest.TaskExecutionId,
blockRequest.BlockType,
DateTime.UtcNow - blockRequest.FailedTaskDetectionRange,
DateTime.UtcNow,
blockCountLimit,
blockRequest.FailedTaskRetryLimit
);
var failedBlocks = await _blockRepository.FindFailedRangeBlocksAsync(failedBlockRequest).ConfigureAwait(false);
return(await CreateBlockContextsAsync(blockRequest, failedBlocks).ConfigureAwait(false));
}
private List <RangeBlockContext> GetFailedBlocks(BlockRequest blockRequest, int blockCountLimit)
{
var failedBlockRequest = new FindFailedBlocksRequest(new TaskId(blockRequest.ApplicationName, blockRequest.TaskName),
blockRequest.TaskExecutionId,
blockRequest.BlockType,
DateTime.UtcNow - blockRequest.FailedTaskDetectionRange,
DateTime.UtcNow,
blockCountLimit,
blockRequest.FailedTaskRetryLimit
);
var failedBlocks = _blockRepository.FindFailedRangeBlocks(failedBlockRequest);
return(CreateBlockContexts(blockRequest, failedBlocks));
}
public async Task <GetBlockResponse> GetBlockAsync(BlockRequest request)
{
try
{
var block = await m_EosApi.GetBlock(new GetBlockRequest()
{
block_num_or_id = request.BlockNumOrId
});
return(block);
}
catch
{
return(null);
}
}
private void RequestBlockById(byte[] id, int height = 0)
{
// Create the request object
BlockRequest br = new BlockRequest {
Id = ByteString.CopyFrom(id), Height = height
};
Message message = NetRequestFactory.CreateMessage(AElfProtocolMsgType.RequestBlock, br.ToByteArray());
if (message.Payload == null)
{
_logger?.Warn($"[{this}] request for block with id {id.ToHex()} failed because payload is null.");
return;
}
SendTimedRequest(message, br);
}
private void RequestBlockByIndex(int index)
{
// Create the request object
BlockRequest br = new BlockRequest {
Height = index
};
Message message = NetRequestFactory.CreateMessage(AElfProtocolMsgType.RequestBlock, br.ToByteArray());
if (message.Payload == null)
{
_logger?.Warn($"[{this}] request for block at height {index} failed because payload is null.");
return;
}
SendTimedRequest(message, br);
}
public bool CheckValidRequest(BlockRequest message)
{
throw new NotImplementedException();
}
private void ProcessInvMessage(EndpointState endpointState, InvMessage invMessage)
{
DateTime utcNow = SystemTime.UtcNow;
GetDataMessage getDataMessage = null;
lock (lockObject)
{
foreach (InventoryVector vector in invMessage.Inventory)
{
if (vector.Type == InventoryVectorType.MsgBlock)
{
endpointState.AdvertisedBlocks.Add(vector.Hash, utcNow);
}
}
while (endpointState.AdvertisedBlocks.Count > MaxAdvertisedBlocksPerNode)
{
endpointState.AdvertisedBlocks.Remove(endpointState.AdvertisedBlocks.First().Key);
}
int maxBlocksToRequest = MaxConcurrentBlockRequestsPerNode - endpointState.BlockRequests.Count;
List<BlockState> blocksToRequest = new List<BlockState>();
if (maxBlocksToRequest > 0)
{
foreach (BlockState blockState in requiredBlocks.Values)
{
if (blockState.GetPendingRequestCount() >= MaxConcurrentBlockRequestsPerBlock)
{
continue;
}
if (!endpointState.AdvertisedBlocks.ContainsKey(blockState.Hash))
{
continue;
}
//todo: there are situations when request was sent, but timed out and should be requested again
if (endpointState.HasPendingRequest(blockState.Hash))
{
continue;
}
blocksToRequest.Add(blockState);
if (blocksToRequest.Count >= maxBlocksToRequest)
{
break;
}
}
}
if (blocksToRequest.Any())
{
InventoryVector[] inventoryVectors = blocksToRequest.Select(b => new InventoryVector(InventoryVectorType.MsgBlock, b.Hash)).ToArray();
getDataMessage = new GetDataMessage(inventoryVectors);
foreach (BlockState blockState in blocksToRequest)
{
BlockRequest blockRequest = new BlockRequest(blockState, endpointState.Endpoint, utcNow);
endpointState.BlockRequests.Add(blockState.Hash, blockRequest);
blockState.Requests.Add(blockRequest);
}
}
}
if (getDataMessage != null)
{
endpointState.Endpoint.WriteMessage(getDataMessage);
}
}
