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