/// <summary>
/// An Enhanced Packet Block is the standard container for storing the packets coming from the network. The Enhanced Packet Block
/// is optional because packets can be stored either by means of this block or the Simple Packet Block, which can be used to speed
/// up dump generation.
/// The Enhanced Packet Block is an improvement over the original Packet Block:
/// it stores the Interface Identifier as a 32bit integer value. This is a requirement when a capture stores packets coming from
/// a large number of interfaces differently from the Packet Block, the number of packets dropped by the capture system between
/// this packet and the previous one is not stored in the header, but rather in an option of the block itself.
/// </summary>
public EnchantedPacketBlock(int InterfaceID, TimestampHelper Timestamp, int PacketLength, byte[] Data, EnchantedPacketOption Options, long PositionInStream = 0)
{
Contract.Requires <ArgumentNullException>(Timestamp != null, "Timestamp cannot be null");
Contract.Requires <ArgumentNullException>(Options != null, "Options cannot be null");
Contract.Requires <ArgumentNullException>(Data != null, "Data cannot be null");
this.InterfaceID = InterfaceID;
this.Timestamp = Timestamp;
this.PacketLength = PacketLength;
this.data = Data;
this.options = Options;
this.PositionInStream = PositionInStream;
}
public ActionResult <Dictionary <string, object> > QueryVerifyCode()
{
RspMsg rspMsg = new RspMsg(RspType.OK);
string code = string.Empty;
rspMsg.Add("VerifyBase64Str", VerifyCodeHelper.GetVerifyCodeBase64String(out code));
rspMsg.Add("VerifyToken", DBCenter.JwtImage.SetJwtEncode(new Dictionary <string, object>
{
{ "CheckCode", code },
{ "exp", TimestampHelper.GetTimestampSecond() + 300 }
}));
return(rspMsg.GetKeyValues());
}
public async Task PrepareExtraDataForNextMiningAsync_Expired_Test()
{
var sideChainId = 123;
var sideChainBlockInfoCache = new List <SideChainBlockData>();
var cachingCount = 5;
for (int i = 0; i < cachingCount + CrossChainConstants.DefaultBlockCacheEntityCount; i++)
{
sideChainBlockInfoCache.Add(new SideChainBlockData()
{
ChainId = sideChainId,
Height = (i + 1),
TransactionStatusMerkleTreeRoot = Hash.FromString((sideChainId + 1).ToString())
});
}
_crossChainTestHelper.AddFakeSideChainIdHeight(sideChainId, 1);
var fakeCache = new Dictionary <int, List <IBlockCacheEntity> >
{
{ sideChainId, sideChainBlockInfoCache.ToList <IBlockCacheEntity>() }
};
AddFakeCacheData(fakeCache);
var crossChainBlockData = new CrossChainBlockData
{
SideChainBlockDataList = { sideChainBlockInfoCache }
};
_crossChainTestHelper.AddFakePendingCrossChainIndexingProposal(
new GetPendingCrossChainIndexingProposalOutput
{
Proposer = SampleAddress.AddressList[0],
ProposalId = Hash.FromString("ProposalId"),
ProposedCrossChainBlockData = crossChainBlockData,
ToBeReleased = true,
ExpiredTime = TimestampHelper.GetUtcNow().AddSeconds(-1)
});
var res = await _crossChainIndexingDataService.PrepareExtraDataForNextMiningAsync(Hash.Empty, 1);
Assert.Empty(res);
var crossChainTransactionInput =
await _crossChainIndexingDataService.GetCrossChainTransactionInputForNextMiningAsync(Hash.Empty, 1);
Assert.NotNull(crossChainTransactionInput);
var crossChainBlockDataFromInput = CrossChainBlockData.Parser.ParseFrom(crossChainTransactionInput.Value);
Assert.Equal(CrossChainConstants.DefaultBlockCacheEntityCount,
crossChainBlockDataFromInput.SideChainBlockDataList.Count);
}
public async Task WrongParallelTest()
{
var chain = await _blockchainService.GetChainAsync();
await _blockchainService.SetIrreversibleBlockAsync(chain, chain.BestChainHeight, chain.BestChainHash);
var transactions =
_parallelTestHelper.GenerateBasicFunctionWithParallelTransactions(_groupCount, _transactionCount);
await _parallelTestHelper.BroadcastTransactions(transactions);
var poolSize = await _txHub.GetTransactionPoolSizeAsync();
poolSize.ShouldBe(transactions.Count);
var groupedTransactions = await _grouper.GroupAsync(
new ChainContext { BlockHash = chain.BestChainHash, BlockHeight = chain.BestChainHeight },
transactions);
groupedTransactions.Parallelizables.Count.ShouldBe(_transactionCount);
groupedTransactions.NonParallelizables.Count.ShouldBe(0);
var block = await _minerService.MineAsync(chain.BestChainHash, chain.BestChainHeight, TimestampHelper.GetUtcNow(),
TimestampHelper.DurationFromSeconds(4));
block.TransactionIds.Count().ShouldBe(_groupCount);
await _blockchainService.AddBlockAsync(block);
await _blockAttachService.AttachBlockAsync(block);
var codeRemarks =
await _codeRemarksManager.GetCodeRemarksAsync(
Hash.FromRawBytes(_parallelTestHelper.BasicFunctionWithParallelContractCode));
codeRemarks.ShouldNotBeNull();
codeRemarks.NonParallelizable.ShouldBeTrue();
groupedTransactions = await _grouper.GroupAsync(new ChainContext { BlockHash = block.GetHash(), BlockHeight = block.Height },
transactions);
groupedTransactions.Parallelizables.Count.ShouldBe(0);
groupedTransactions.NonParallelizables.Count.ShouldBe(_transactionCount);
poolSize = await _txHub.GetTransactionPoolSizeAsync();
poolSize.ShouldBe(transactions.Count - block.TransactionIds.Count());
block = await _minerService.MineAsync(block.GetHash(), block.Height, TimestampHelper.GetUtcNow(),
TimestampHelper.DurationFromSeconds(4));
block.TransactionIds.Count().ShouldBe(poolSize);
}
/// <summary>
/// Basically update the consensus scheduler with latest consensus command.
/// </summary>
/// <param name="chainContext"></param>
/// <returns></returns>
public async Task TriggerConsensusAsync(ChainContext chainContext)
{
var now = TimestampHelper.GetUtcNow();
_blockTimeProvider.SetBlockTime(now);
Logger.LogDebug($"Set block time to utc now: {now.ToDateTime():hh:mm:ss.ffffff}. Trigger.");
var triggerInformation =
_triggerInformationProvider.GetTriggerInformationForConsensusCommand(new BytesValue());
Logger.LogDebug($"Mining triggered, chain context: {chainContext.BlockHeight} - {chainContext.BlockHash}");
// Upload the consensus command.
var contractReaderContext =
await _consensusReaderContextService.GetContractReaderContextAsync(chainContext);
_consensusCommand = await _contractReaderFactory
.Create(contractReaderContext).GetConsensusCommand
.CallAsync(triggerInformation);
if (_consensusCommand == null)
{
Logger.LogWarning("Consensus command is null.");
return;
}
Logger.LogDebug($"Updated consensus command: {_consensusCommand}");
// Update next mining time, also block time of both getting consensus extra data and txs.
_nextMiningTime = _consensusCommand.ArrangedMiningTime;
var leftMilliseconds = _consensusCommand.ArrangedMiningTime - TimestampHelper.GetUtcNow();
leftMilliseconds = leftMilliseconds.Seconds > ConsensusConstants.MaximumLeftMillisecondsForNextBlock
? new Duration {
Seconds = ConsensusConstants.MaximumLeftMillisecondsForNextBlock
}
: leftMilliseconds;
// Update consensus scheduler.
var blockMiningEventData = new ConsensusRequestMiningEventData(chainContext.BlockHash,
chainContext.BlockHeight,
_nextMiningTime,
TimestampHelper.DurationFromMilliseconds(_consensusCommand.LimitMillisecondsOfMiningBlock),
_consensusCommand.MiningDueTime);
_consensusScheduler.CancelCurrentEvent();
_consensusScheduler.NewEvent(leftMilliseconds.Milliseconds(), blockMiningEventData);
Logger.LogDebug($"Set next mining time to: {_nextMiningTime.ToDateTime():hh:mm:ss.ffffff}");
}
public override void ConfigureServices(ServiceConfigurationContext context)
{
context.Services.Replace(ServiceDescriptor.Singleton <INetworkService, NetworkService>());
context.Services.Replace(ServiceDescriptor.Singleton <IAElfNetworkServer>(o =>
{
var pool = o.GetService <IPeerPool>();
var serverMock = new Mock <IAElfNetworkServer>();
serverMock.Setup(p => p.DisconnectAsync(It.IsAny <IPeer>(), It.IsAny <bool>()))
.Returns(Task.CompletedTask)
.Callback <IPeer, bool>((peer, disc) => pool.RemovePeer(peer.Info.Pubkey));
return(serverMock.Object);
}));
context.Services.AddSingleton(provider =>
{
var mockService = new Mock <IBlockExtraDataService>();
mockService.Setup(m => m.GetExtraDataFromBlockHeader(It.IsAny <string>(), It.IsAny <BlockHeader>()))
.Returns(ByteString.CopyFrom(new AElfConsensusHeaderInformation
{
Behaviour = AElfConsensusBehaviour.NextRound,
Round = new Round
{
RoundNumber = 12,
TermNumber = 1,
BlockchainAge = 3,
ExtraBlockProducerOfPreviousRound = "bp2-pubkey",
MainChainMinersRoundNumber = 3,
RealTimeMinersInformation =
{
{
"bp1-pubkey", new MinerInRound
{
Order = 2,
ProducedBlocks = 3,
ExpectedMiningTime = TimestampHelper.GetUtcNow().AddSeconds(3),
ActualMiningTimes = { },
MissedTimeSlots = 1
}
}
}
},
SenderPubkey = ByteString.CopyFromUtf8("pubkey")
}.ToByteArray()));
return(mockService.Object);
});
}
public void ValidateQueueAvailabilityBeforeDownload_Test()
{
_blockDownloadService.ValidateQueueAvailabilityBeforeDownload().ShouldBeTrue();
_blockSyncStateProvider.SetEnqueueTime(OSConstants.BlockSyncAttachQueueName,
TimestampHelper.GetUtcNow()
.AddMilliseconds(-BlockSyncConstants.BlockSyncAttachBlockAgeLimit - 1000));
_blockDownloadService.ValidateQueueAvailabilityBeforeDownload().ShouldBeFalse();
_blockSyncStateProvider.SetEnqueueTime(KernelConstants.UpdateChainQueueName,
TimestampHelper.GetUtcNow()
.AddMilliseconds(-BlockSyncConstants.BlockSyncAttachAndExecuteBlockAgeLimit - 1000));
_blockDownloadService.ValidateQueueAvailabilityBeforeDownload().ShouldBeFalse();
}
public Task <bool> ValidateBeforeAttachAsync(IBlock block)
{
if (block?.Header == null || block.Body == null)
{
Logger.LogWarning("Block header or body is null.");
return(Task.FromResult(false));
}
if (block.Body.TransactionsCount == 0)
{
Logger.LogWarning("Block transactions is empty");
return(Task.FromResult(false));
}
var hashSet = new HashSet <Hash>();
if (block.Body.TransactionIds.Select(item => hashSet.Add(item)).Any(addResult => !addResult))
{
Logger.LogWarning("Block contains duplicates transaction");
return(Task.FromResult(false));
}
if (_blockchainService.GetChainId() != block.Header.ChainId)
{
Logger.LogWarning($"Block chain id mismatch {block.Header.ChainId}");
return(Task.FromResult(false));
}
if (block.Header.Height != AElfConstants.GenesisBlockHeight && !block.VerifySignature())
{
Logger.LogWarning("Block verify signature failed.");
return(Task.FromResult(false));
}
if (block.Body.CalculateMerkleTreeRoot() != block.Header.MerkleTreeRootOfTransactions)
{
Logger.LogWarning("Block merkle tree root mismatch.");
return(Task.FromResult(false));
}
if (block.Header.Height != AElfConstants.GenesisBlockHeight &&
block.Header.Time.ToDateTime() - TimestampHelper.GetUtcNow().ToDateTime() >
KernelConstants.AllowedFutureBlockTimeSpan.ToTimeSpan())
{
Logger.LogWarning($"Future block received {block}, {block.Header.Time.ToDateTime()}");
return(Task.FromResult(false));
}
return(Task.FromResult(true));
}
private BlockHeader GenerateBlockHeader()
{
return(new BlockHeader
{
ChainId = 1234,
Height = 10,
PreviousBlockHash = HashHelper.ComputeFrom("hash3"),
MerkleTreeRootOfTransactions = Hash.Empty,
MerkleTreeRootOfWorldState = Hash.Empty,
Time = TimestampHelper.GetUtcNow(),
MerkleTreeRootOfTransactionStatus = Hash.Empty,
SignerPubkey = ByteString.CopyFromUtf8("SignerPubkey")
});
}
public async Task CheckExtraDataIsNeeded_NotToBeReleased_Test()
{
var sideChainId = 123;
var utcNow = TimestampHelper.GetUtcNow();
_crossChainTestHelper.AddFakePendingCrossChainIndexingProposal(sideChainId,
CreatePendingChainIndexingProposalStatus(SampleAddress.AddressList[0],
HashHelper.ComputeFrom("ProposalId"),
new CrossChainBlockData(), false));
var res = await _crossChainIndexingDataService.CheckExtraDataIsNeededAsync(Hash.Empty, 1, utcNow);
res.ShouldBe(false);
}
public void EnqueueTime_Test()
{
var testQueueName = "TestQueue";
var testEnqueueTime = TimestampHelper.GetUtcNow();
var enqueueTime = _blockSyncStateProvider.GetEnqueueTime(testQueueName);
enqueueTime.ShouldBeNull();
_blockSyncStateProvider.SetEnqueueTime(testQueueName, testEnqueueTime);
enqueueTime = _blockSyncStateProvider.GetEnqueueTime(testQueueName);
enqueueTime.ShouldBe(testEnqueueTime);
}
public async Task <SmartContractRegistration> GetSmartContractRegistrationAsync(IChainContext chainContext, Address address)
{
var zeroAddress = _defaultContractZeroCodeProvider.ContractZeroAddress;
var tx = new Transaction
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ACS0Container.ACS0Stub.GetSmartContractRegistrationByAddress),
Params = address.ToByteString()
};
return(await _transactionReadOnlyExecutionService.ExecuteAsync <SmartContractRegistration>(
chainContext, tx, TimestampHelper.GetUtcNow(), false));
}
public static BlockHeader CreateFakeBlockHeader(int chainId, long height, ECKeyPair producer)
{
return(new BlockHeader
{
ChainId = chainId,
Height = height,
PreviousBlockHash = HashHelper.ComputeFrom(new byte[] { 1, 2, 3 }),
Time = TimestampHelper.GetUtcNow(),
MerkleTreeRootOfTransactions = Hash.Empty,
MerkleTreeRootOfWorldState = Hash.Empty,
MerkleTreeRootOfTransactionStatus = Hash.Empty,
SignerPubkey = ByteString.CopyFrom(producer.PublicKey)
});
}
public async Task RunPriceListSynchronizationAsync()
{
var statistics = new PriceListSynchronizationStatistics();
try
{
await _ekSearchManagementClient.CreateProductIndexIfNotExistAsync();
var from = 0;
const int count = 1_000;
using (var searchIndexClient = _ekSearchManagementClient.CreateSearchIndexClient())
{
searchIndexClient.IndexName = _ekSearchManagementClient.ProductsIndexName;
var updateUtcTimestamp = TimestampHelper.GetCurrentUtcTotalMinutes();
while (true)
{
var isFinalPage = await RequestAndIndexPriceListPageAsync(searchIndexClient, from, count, updateUtcTimestamp, statistics);
if (isFinalPage)
{
break;
}
from += count;
}
// wait half of minute until changes are applied
await Task.Delay(TimeSpan.FromSeconds(30));
await PriceListHelper.CleanExpiredRecordsAsync(
searchIndexClient,
EkProductSourceEnum.OmegaAutoBiz,
updateUtcTimestamp,
statistics,
_logger);
}
}
catch (Exception ex)
{
_logger.LogError(LoggingEvents.UnhandledException, ex, "Omega price list synchronization failed.");
await _notificationManager.SendWorkerMessageAsync($"ERROR! Omega price list synchronization failed, {statistics}: {ex.Message}");
throw;
}
await _notificationManager.SendWorkerMessageAsync($"Omega price list synchronization succeed, {statistics}.");
}
public Task BroadcastAnnounceAsync(BlockHeader blockHeader, bool hasFork)
{
var blockHash = blockHeader.GetHash();
if (!TryAddKnownBlock(blockHeader))
{
return(Task.CompletedTask);
}
if (IsOldBlock(blockHeader))
{
return(Task.CompletedTask);
}
var announce = new BlockAnnouncement
{
BlockHash = blockHash,
BlockHeight = blockHeader.Height,
HasFork = hasFork
};
var beforeEnqueue = TimestampHelper.GetUtcNow();
_taskQueueManager.Enqueue(async() =>
{
var execTime = TimestampHelper.GetUtcNow();
if (execTime > beforeEnqueue +
TimestampHelper.DurationFromMilliseconds(NetworkConstants.AnnouncementQueueJobTimeout))
{
Logger.LogWarning($"Announcement too old: {execTime - beforeEnqueue}");
return;
}
foreach (var peer in _peerPool.GetPeers())
{
try
{
await peer.SendAnnouncementAsync(announce);
}
catch (NetworkException ex)
{
Logger.LogError(ex, $"Error while announcing to {peer}.");
await HandleNetworkException(peer, ex);
}
}
}, NetworkConstants.AnnouncementBroadcastQueueName);
return(Task.CompletedTask);
}
public async Task PrepareExtraDataForNextMiningAsync_AlmostExpired_Test()
{
var sideChainId = 123;
var sideChainBlockInfoCache = new List <SideChainBlockData>();
var cachingCount = 5;
for (int i = 0; i < cachingCount + CrossChainConstants.DefaultBlockCacheEntityCount; i++)
{
sideChainBlockInfoCache.Add(new SideChainBlockData()
{
ChainId = sideChainId,
Height = (i + 1),
TransactionStatusMerkleTreeRoot = Hash.FromString((sideChainId + 1).ToString())
});
}
_crossChainTestHelper.AddFakeSideChainIdHeight(sideChainId, 1);
var fakeCache = new Dictionary <int, List <IBlockCacheEntity> >
{
{ sideChainId, sideChainBlockInfoCache.ToList <IBlockCacheEntity>() }
};
AddFakeCacheData(fakeCache);
var crossChainBlockData = new CrossChainBlockData
{
SideChainBlockDataList = { sideChainBlockInfoCache }
};
_crossChainTestHelper.AddFakePendingCrossChainIndexingProposal(
new GetPendingCrossChainIndexingProposalOutput
{
Proposer = SampleAddress.AddressList[0],
ProposalId = Hash.FromString("ProposalId"),
ProposedCrossChainBlockData = crossChainBlockData,
ToBeReleased = true,
ExpiredTime = TimestampHelper.GetUtcNow().AddMilliseconds(500)
});
var res = await _crossChainIndexingDataService.PrepareExtraDataForNextMiningAsync(Hash.Empty, 1);
var crossChainExtraData = CrossChainExtraData.Parser.ParseFrom(res);
var expectedMerkleTreeRoot = BinaryMerkleTree
.FromLeafNodes(sideChainBlockInfoCache.Select(s => s.TransactionStatusMerkleTreeRoot)).Root;
Assert.Equal(expectedMerkleTreeRoot, crossChainExtraData.TransactionStatusMerkleTreeRoot);
Assert.Equal(res,
_crossChainIndexingDataService.ExtractCrossChainExtraDataFromCrossChainBlockData(crossChainBlockData));
}
private async Task <Address> GetSmartContractAddressFromStateAsync(IChainContext chainContext, string name)
{
var zeroAddress = _defaultContractZeroCodeProvider.ContractZeroAddress;
var tx = new Transaction
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ACS0Container.ACS0Stub.GetContractAddressByName),
Params = Hash.LoadFromBase64(name).ToByteString()
};
var address = await _transactionReadOnlyExecutionService.ExecuteAsync <Address>(
chainContext, tx, TimestampHelper.GetUtcNow(), false);
return(address == null || address.Value.IsEmpty ? null : address);
}
public void CleanIdleExecutive()
{
foreach (var executivePool in _smartContractExecutiveProvider.GetExecutivePools())
{
var executiveBag = executivePool.Value;
if (executiveBag.Count > ExecutiveClearLimit && executiveBag.Min(o => o.LastUsedTime) <
TimestampHelper.GetUtcNow() - TimestampHelper.DurationFromSeconds(ExecutiveExpirationTime))
{
if (executiveBag.TryTake(out _))
{
Logger.LogDebug($"Cleaned an idle executive for address {executivePool.Key}.");
}
}
}
}
public void RemoveReconnectionPeer_Test()
{
var endpoint = "127.0.0.1:5677";
var utcNow = TimestampHelper.GetUtcNow();
_reconnectionProvider.AddReconnectingPeer(endpoint, new ReconnectingPeer {
Endpoint = endpoint, NextAttempt = utcNow
});
_reconnectionProvider.RemoveReconnectionPeer(endpoint).ShouldBeTrue();
_reconnectionProvider.GetReconnectingPeer(endpoint).ShouldBeNull();
_reconnectionProvider.GetPeersReadyForReconnection(utcNow.AddSeconds(1)).Count.ShouldBe(0);
_reconnectionProvider.RemoveReconnectionPeer(endpoint).ShouldBeFalse();
}
public async Task <List <ChatMessageDto> > SeekHistory(string channel, string dateStart, string dateEnd)
{
List <ChatMessage> messagesData = new List <ChatMessage>();
List <ChatMessageDto> result = new List <ChatMessageDto>();
try
{
DateTime start = DateTime.ParseExact(dateStart, "ddMMyyyyHH:mm:ss", CultureInfo.InvariantCulture);
DateTime end = DateTime.ParseExact(dateEnd, "ddMMyyyyHH:mm:ss", CultureInfo.InvariantCulture);
messagesData = await _chatRepository.SeekHistoryMessage(channel, start, end);
}
catch (ArgumentNullException argumentEx)
{
throw HttpHelper.HttpError(System.Net.HttpStatusCode.BadRequest, "Some argument are null");
}
catch (FormatException formatEx)
{
throw HttpHelper.HttpError(System.Net.HttpStatusCode.BadRequest, "Date format not supported");
}
catch (Exception ex)
{
_logger.Log(LogLevel.Error, _logCategory, "An error occured when seek history in chat repository", ex.Message);
throw HttpHelper.HttpError(System.Net.HttpStatusCode.InternalServerError, "Server Internal error(s)");
}
if (result.Count == 0)
{
throw HttpHelper.HttpError(System.Net.HttpStatusCode.NoContent, $"No data found in request date range DateStart={dateStart}, DateEnd={dateEnd}");
}
else
{
foreach (ChatMessage msg in messagesData)
{
var message = new ChatMessageDto
{
Message = msg.Message,
TimeStamp = TimestampHelper.DateTimeToUnixTimeStamp(msg.Date),
UserInfo = new ChatUserInfoDto
{
UserId = msg.UserInfo.UserId,
Data = msg.UserInfo.Data.ToString(),
}
};
result.Add(message);
}
return(result);
}
}
public async Task ChangeSymbolsToPayTXSizeFeeController_Success_Test()
{
var primaryToken = await TokenContractStub.GetPrimaryTokenSymbol.CallAsync(new Empty());
var newSymbolList = new SymbolListToPayTxSizeFee();
newSymbolList.SymbolsToPayTxSizeFee.Add(new SymbolToPayTxSizeFee
{
TokenSymbol = primaryToken.Value,
AddedTokenWeight = 1,
BaseTokenWeight = 1
});
// create a new organization to be replace the controller of SetSymbolsToPayTxSizeFee
var newAuthority = await CreateNewParliamentAddressAsync();
// get the default parliament that is the controller of SetSymbolsToPayTxSizeFee
var defaultParliamentAddress = await GetDefaultParliamentAddressAsync();
// create a proposal to replace the controller
var createProposalInput = new CreateProposalInput
{
ToAddress = TokenContractAddress,
Params = newAuthority.ToByteString(),
OrganizationAddress = defaultParliamentAddress,
ContractMethodName = nameof(TokenContractImplContainer.TokenContractImplStub
.ChangeSymbolsToPayTXSizeFeeController),
ExpiredTime = TimestampHelper.GetUtcNow().AddHours(1)
};
await MainChainTesterCreatApproveAndReleaseProposalForParliamentAsync(createProposalInput);
// the new controller try to send SetSymbolsToPayTxSizeFee
var updateInput = new CreateProposalInput
{
ToAddress = TokenContractAddress,
Params = newSymbolList.ToByteString(),
OrganizationAddress = newAuthority.OwnerAddress,
ContractMethodName = nameof(TokenContractImplContainer.TokenContractImplStub.SetSymbolsToPayTxSizeFee),
ExpiredTime = TimestampHelper.GetUtcNow().AddHours(1)
};
await MainChainTesterCreatApproveAndReleaseProposalForParliamentAsync(updateInput);
var symbolSet = await TokenContractStub.GetSymbolsToPayTxSizeFee.CallAsync(new Empty());
symbolSet.SymbolsToPayTxSizeFee.Count.ShouldBe(1);
}
public Task <GetHistoryResult> GetHistory(GetHistoryRequest body)
{
return(Task.Run(() =>
{
var request = FilterRequestForWPS(Request);
if (!request.Status)
{
return new GetHistoryResult {
code = request.code, msg = request.msg
};
}
// 从数据库查询用户、文件信息等......
// 创建时间和修改时间默认全是现在
var now = TimestampHelper.GetCurrentTimestamp();
// 不需要使用历史版本功能的此处也请返回，如果此接口不通时，文档加载会报错：“GetFileInfoFailed”
var result = new GetHistoryResult
{
histories = new List <HistroyModel>
{
new HistroyModel
{
id = request.FileId,
name = "文件名",
size = 1024, // 单位B
version = 1,
download_url = "文件下载链接",
create_time = now,
modify_time = now,
creator = new UserModel
{
id = "创建者ID",
name = "创建者名",
avatar_url = "创建者头像url"
},
modifier = new UserModel
{
id = "修改者ID",
name = "修改者名",
avatar_url = "修改者头像url"
}
}
}
};
return result;
}));
}
public JsonResult Version(int version)
{
_log.WriteInfo("开始请求接口【file/version】");
GetFileByVersionResult result = new GetFileByVersionResult();
try
{
var request = GetFilterRequest.GetParams(HttpContext.ApplicationInstance.Request);
if (!request.Status)
{
result.code = request.code;
result.message = request.message;
result.details = request.details;
result.hint = request.hint;
}
else
{
// 从数据库查询文件信息......
// 创建时间和修改时间默认全是现在
var now = TimestampHelper.GetCurrentTimestamp();
var fileName = version == 1 ? "TestFile_v1.docx" : (version == 2 ? "TestFile_v2.docx" : "TestFile.docx");
string filePath = Server.MapPath($"/Files/{fileName}");
result.file = new GetFileResult
{
id = request.FileId,
name = fileName,
version = version,
size = FileHelper.FileSize(filePath), // WPS单位是B,
create_time = now,
creator = "天玺",
modify_time = now,
modifier = "天玺",
download_url = $"{ConfigurationManager.AppSettings["WPSTokenUrl"]}/Files/{fileName}"
};
}
}
catch (Exception ex)
{
_log.WriteError("【系统异常】-【" + ex.Message + "】", ex);
result.code = (int)Enumerator.ErrorCode.ServerError;
result.message = Enumerator.ErrorCode.ServerError.ToString();
result.details = result.hint = EnumExtension.GetDescription(Enumerator.ErrorCode.ServerError);
}
_log.WriteInfo("请求接口【file/version】完成,返回数据：" + JsonConvert.SerializeObject(result));
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void Execute()
{
var s = CurrentTransactionContext.Trace.StartTime = TimestampHelper.GetUtcNow().ToDateTime();
var methodName = CurrentTransactionContext.Transaction.MethodName;
var observer = IsSystemContract ?
new ExecutionObserver(-1, -1) : // Counters are active but no threshold
new ExecutionObserver(CurrentTransactionContext.ExecutionCallThreshold,
CurrentTransactionContext.ExecutionBranchThreshold);
try
{
if (!_callHandlers.TryGetValue(methodName, out var handler))
{
throw new RuntimeException(
$"Failed to find handler for {methodName}. We have {_callHandlers.Count} handlers: " +
string.Join(", ", _callHandlers.Keys.OrderBy(k => k))
);
}
_smartContractProxy.SetExecutionObserver(observer);
ExecuteTransaction(handler);
if (!handler.IsView())
{
CurrentTransactionContext.Trace.StateSet = GetChanges();
}
else
{
CurrentTransactionContext.Trace.StateSet = new TransactionExecutingStateSet();
}
}
catch (Exception ex)
{
CurrentTransactionContext.Trace.ExecutionStatus = ExecutionStatus.SystemError;
CurrentTransactionContext.Trace.Error += ex + "\n";
}
finally
{
CurrentTransactionContext.Trace.ExecutionCallCount = observer.GetCallCount();
CurrentTransactionContext.Trace.ExecutionBranchCount = observer.GetBranchCount();
Cleanup();
}
var e = CurrentTransactionContext.Trace.EndTime = TimestampHelper.GetUtcNow().ToDateTime();
CurrentTransactionContext.Trace.Elapsed = (e - s).Ticks;
}
public async Task Register_With_Invalid_Timestamp()
{
var endTime = TimestampHelper.GetUtcNow();
var input = new VotingRegisterInput
{
TotalSnapshotNumber = 0,
EndTimestamp = endTime,
StartTimestamp = endTime.AddDays(1),
Options = { GenerateOptions(1) },
AcceptedCurrency = TestTokenSymbol,
IsLockToken = true
};
var transactionResult = (await VoteContractStub.Register.SendWithExceptionAsync(input)).TransactionResult;
transactionResult.Error.ShouldContain("Invalid active time.");
}
public Handshake CreateHandshake(ECKeyPair initiatorPeer, int chainId = NetworkTestConstants.DefaultChainId)
{
var data = new HandshakeData
{
ChainId = _blockchainService.GetChainId(),
Version = KernelConstants.ProtocolVersion,
Pubkey = ByteString.CopyFrom(initiatorPeer.PublicKey),
Time = TimestampHelper.GetUtcNow()
};
var signature = CryptoHelper.SignWithPrivateKey(initiatorPeer.PrivateKey, Hash.FromMessage(data).ToByteArray());
return(new Handshake {
HandshakeData = data, Signature = ByteString.CopyFrom(signature)
});
}
public async Task BroadcastAnnounce_Test()
{
var blockHeader = _kernelTestHelper.GenerateBlock(10, Hash.FromString("test")).Header;
//old block
blockHeader.Time = TimestampHelper.GetUtcNow() - TimestampHelper.DurationFromMinutes(20);
await _networkService.BroadcastAnnounceAsync(blockHeader, false);
//known block
blockHeader.Time = TimestampHelper.GetUtcNow();
await _networkService.BroadcastAnnounceAsync(blockHeader, false);
//broadcast again
blockHeader = _kernelTestHelper.GenerateBlock(11, Hash.FromString("new")).Header;
await _networkService.BroadcastAnnounceAsync(blockHeader, false);
}
public void SaveSandboxHeader()
{
if (ignoreChangeEvents)
{
return;
}
Session.mapVariantFile.MapVariant.VariantAuthor = editedMapAuthor.text.Replace(" ", "");
Session.mapVariantFile.MapVariant.VariantDescription = editedMapDescription.text.Replace(" ", "");;
Session.mapVariantFile.MapVariant.VariantName = editedMapName.text.Replace(" ", "");;
Session.mapVariantFile.MapVariant.VariantCreationDate = TimestampHelper.ToTimestamp(DateTime.Now);
Session.mapVariantFile.SaveFile();
UpdateDisplay(Session.mapVariantFile.MapVariant);
}
public async Task Connect_PeerAlreadyInPoolAndIsInvalid_Test()
{
var peer = CreatePeerAndAddToPeerPool(NetworkTestConstants.GoodPeerEndpoint, NetworkTestConstants.FakePubkey2);
peer.IsConnected = false;
peer.Info.ConnectionTime = TimestampHelper.GetUtcNow()
.AddMilliseconds(-NetworkConstants.PeerConnectionTimeout - 1000);
var added = await _connectionService.ConnectAsync(peer.RemoteEndpoint);
added.ShouldBeTrue();
var currentPeer = _peerPool.FindPeerByPublicKey(NetworkTestConstants.FakePubkey);
currentPeer.ShouldNotBeNull();
}
public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
var peerPool = context.ServiceProvider.GetRequiredService <IPeerPool>();
var osTestHelper = context.ServiceProvider.GetRequiredService <OSTestHelper>();
{
var normalPeer = new Mock <IPeer>();
normalPeer.Setup(m => m.RemoteEndpoint).Returns(new DnsEndPoint("192.168.100.200", 5000));
var blockWithTransactions = osTestHelper.GenerateBlockWithTransactions(Hash.Empty, 10);
normalPeer.Setup(p => p.Info).Returns(new PeerConnectionInfo
{
Pubkey = "NormalPeer", ConnectionTime = TimestampHelper.GetUtcNow()
});
normalPeer.Setup(p => p.GetBlocksAsync(It.IsAny <Hash>(), It.IsAny <int>()))
.Returns <Hash, int>((h, cnt) => Task.FromResult(new List <BlockWithTransactions>()));
normalPeer.Setup(p => p.IsReady).Returns(true);
normalPeer.Setup(p => p.GetBlockByHashAsync(It.Is <Hash>(h => h == HashHelper.ComputeFrom("bHash1"))))
.Returns <Hash>(h => Task.FromResult(blockWithTransactions));
normalPeer.Setup(m => m.GetNodesAsync(It.IsAny <int>()))
.Returns(Task.FromResult(new NodeList
{
Nodes =
{
new NodeInfo
{
Endpoint = "http://192.168.100.88:8000",
Pubkey = ByteString.CopyFromUtf8("p2")
}
}
}));
peerPool.TryAddPeer(normalPeer.Object);
}
{
var failedPeerPeer = new Mock <IPeer>();
failedPeerPeer.Setup(p => p.RemoteEndpoint).Returns(new DnsEndPoint("192.168.100.400", 80));
failedPeerPeer.Setup(p => p.Info).Returns(new PeerConnectionInfo
{
Pubkey = "FailedPeer", ConnectionTime = TimestampHelper.GetUtcNow()
});
failedPeerPeer.Setup(p => p.IsInvalid).Returns(true);
failedPeerPeer.Setup(p => p.GetBlockByHashAsync(It.IsAny <Hash>())).Throws(new NetworkException());
failedPeerPeer.Setup(p => p.GetBlocksAsync(It.IsAny <Hash>(), It.IsAny <int>())).Throws(new NetworkException());
peerPool.TryAddPeer(failedPeerPeer.Object);
}
}
