public override Task <Empty> UploadTemplate(BytesValue data, ServerCallContext context) => Task.Factory.StartNew(() => { _logger.LogDebug("UploadTemplate() called with {0} bytes data.", data.Value.Length); GetOrCreateWrapper(context).LoadTemplateFromData(data.Value.ToStream()); return(new Empty()); });
public override ValidationResult ValidateConsensusAfterExecution(BytesValue input) { return(new ValidationResult { Success = true }); }
internal static ConsensusCommand ToConsensusCommand(this BytesValue bytesValue) { var consensusCommand = new ConsensusCommand(); consensusCommand.MergeFrom(bytesValue.Value); return(consensusCommand); }
/// <summary> /// In this method, `Context.CurrentBlockTime` is the time one miner start request his next consensus command. /// </summary> /// <param name="input"></param> /// <returns></returns> public override ConsensusCommand GetConsensusCommand(BytesValue input) { Assert(input.Value.Any(), "Invalid public key."); if (Context.CurrentHeight == 1) { return(GetInvalidConsensusCommand()); } if (!TryToGetCurrentRoundInformation(out var currentRound)) { return(GetInvalidConsensusCommand()); } var publicKey = input.Value.ToHex(); var behaviour = GetConsensusBehaviour(currentRound, publicKey); Context.LogDebug(() => currentRound.ToString(publicKey)); Context.LogDebug(() => $"Current behaviour: {behaviour.ToString()}"); return(behaviour == AElfConsensusBehaviour.Nothing ? GetInvalidConsensusCommand() // Handle this situation previously. : GetConsensusCommand(behaviour, currentRound, publicKey)); }
internal static AElfConsensusHeaderInformation ToConsensusHeaderInformation(this BytesValue bytesValue) { var headerInformation = new AElfConsensusHeaderInformation(); headerInformation.MergeFrom(bytesValue.Value); return(headerInformation); }
public override BytesValue GetRandomBytes(BytesValue input) { var height = new Int64Value(); height.MergeFrom(input.Value); return(GetRandomHash(height).ToBytesValue()); }
/// <summary> /// In this method, `Context.CurrentBlockTime` is the time one miner start request his next consensus command. /// </summary> /// <param name="input"></param> /// <returns></returns> public override ConsensusCommand GetConsensusCommand(BytesValue input) { _processingBlockMinerPubkey = input.Value.ToHex(); if (Context.CurrentHeight < 2) { return(ConsensusCommandProvider.InvalidConsensusCommand); } if (!TryToGetCurrentRoundInformation(out var currentRound)) { return(ConsensusCommandProvider.InvalidConsensusCommand); } if (!currentRound.IsInMinerList(_processingBlockMinerPubkey)) { return(ConsensusCommandProvider.InvalidConsensusCommand); } var blockchainStartTimestamp = GetBlockchainStartTimestamp(); var behaviour = IsMainChain ? new MainChainConsensusBehaviourProvider(currentRound, _processingBlockMinerPubkey, GetMaximumBlocksCount(), Context.CurrentBlockTime, blockchainStartTimestamp, State.TimeEachTerm.Value) .GetConsensusBehaviour() : new SideChainConsensusBehaviourProvider(currentRound, _processingBlockMinerPubkey, GetMaximumBlocksCount(), Context.CurrentBlockTime).GetConsensusBehaviour(); Context.LogDebug(() => $"{currentRound.ToString(_processingBlockMinerPubkey)}\nArranged behaviour: {behaviour.ToString()}"); return(behaviour == AElfConsensusBehaviour.Nothing ? ConsensusCommandProvider.InvalidConsensusCommand : GetConsensusCommand(behaviour, currentRound, _processingBlockMinerPubkey)); }
public void TestValid() { var request = new BytesValue { Value = ByteString.CopyFrom("Hello", Encoding.Default) }; Client.Bytes(request); }
public override ConsensusCommand GetConsensusCommand(BytesValue input) { return(new ConsensusCommand { ArrangedMiningTime = Context.CurrentBlockTime.AddMilliseconds(1000), LimitMillisecondsOfMiningBlock = 1000, MiningDueTime = Context.CurrentBlockTime.AddMilliseconds(3000) }); }
public void TestInvalid() { var request = new BytesValue { Value = ByteString.Empty }; var exception = Assert.Throws <RpcException>(() => Client.Bytes(request)); Assert.AreEqual(StatusCode.InvalidArgument, exception.StatusCode, exception.Message); }
public override Task <BytesValue> Download(Empty _, ServerCallContext context) => Task.Factory.StartNew(() => { _logger.LogDebug("Download()"); var ret = new BytesValue { Value = ByteString.FromStream(GetOrCreateWrapper(context).Download()) }; _logger.LogTrace(" --------------------- Current memory usage: {0} bytes ---------------------", Environment.WorkingSet); return(ret); });
public override TransactionList GenerateConsensusTransactions(BytesValue input) { return(new TransactionList { Transactions = { GenerateTransaction(nameof(Record), new Empty()) } }); }
protected internal virtual void verifyByteArrayValue(IDictionary <string, object> byteArrayValue) { BytesValue exampleValue = MockProvider.EXAMPLE_HISTORIC_DECISION_BYTE_ARRAY_VALUE; assertThat(byteArrayValue, hasEntry("type", (object)VariableValueDto.toRestApiTypeName(exampleValue.Type.Name))); string byteString = Base64.encodeBase64String(exampleValue.Value).Trim(); assertThat(byteArrayValue, hasEntry("value", (object)byteString)); assertThat(byteArrayValue, hasEntry("valueInfo", (object)Collections.emptyMap())); }
public override BytesValue GetChainInitializationInformation(BytesValue input) { return(new BytesValue { Value = new MinerListWithRoundNumber { MinerList = GetCurrentMinerList(new Empty()), RoundNumber = State.CurrentRoundNumber.Value }.ToByteString() }); }
private BytesValue GetConsensusBlockExtraData(BytesValue input, bool isGeneratingTransactions = false) { var triggerInformation = new AElfConsensusTriggerInformation(); triggerInformation.MergeFrom(input.Value); Assert(triggerInformation.Pubkey.Any(), "Invalid pubkey."); if (!TryToGetCurrentRoundInformation(out var currentRound)) { Assert(false, "Failed to get current round information."); } var publicKeyBytes = triggerInformation.Pubkey; var pubkey = publicKeyBytes.ToHex(); LogIfPreviousMinerHasNotProduceEnoughTinyBlocks(currentRound, pubkey); var information = new AElfConsensusHeaderInformation(); switch (triggerInformation.Behaviour) { case AElfConsensusBehaviour.UpdateValue: information = GetConsensusExtraDataToPublishOutValue(currentRound, pubkey, triggerInformation); if (!isGeneratingTransactions) { information.Round = information.Round.GetUpdateValueRound(pubkey); } break; case AElfConsensusBehaviour.TinyBlock: information = GetConsensusExtraDataForTinyBlock(currentRound, pubkey, triggerInformation); break; case AElfConsensusBehaviour.NextRound: information = GetConsensusExtraDataForNextRound(currentRound, pubkey, triggerInformation); break; case AElfConsensusBehaviour.NextTerm: information = GetConsensusExtraDataForNextTerm(pubkey, triggerInformation); break; } if (!isGeneratingTransactions) { information.Round.DeleteSecretSharingInformation(); } return(information.ToBytesValue()); }
public void BytesWrapper_Standalone() { ByteString data = ByteString.CopyFrom(1, 2, 3); // Can't do this with attributes... var parsed = TextParser.Default.Parse <BytesValue>(WrapInQuotes(data.ToBase64())); var expected = new BytesValue { Value = data }; Assert.Equal(expected, parsed); }
public void BytesWrapper_Standalone() { ByteString data = ByteString.CopyFrom(1, 2, 3); // Can't do this with attributes... var parsed = TextParser.Default.Parse <BytesValue>(TextFormatter.EncodeByteString(data)); var expected = new BytesValue { Value = data }; Assert.Equal(expected, parsed); }
public BytesValue GetTriggerInformationForConsensusTransactions(BytesValue consensusCommandBytes) { if (consensusCommandBytes == null) { return(new AElfConsensusTriggerInformation { Pubkey = Pubkey, Behaviour = AElfConsensusBehaviour.UpdateValue }.ToBytesValue()); } var command = consensusCommandBytes.ToConsensusCommand(); var hint = command.Hint.ToAElfConsensusHint(); if (hint.Behaviour == AElfConsensusBehaviour.UpdateValue) { var inValue = _inValueCache.GetInValue(hint.RoundId); var trigger = new AElfConsensusTriggerInformation { Pubkey = Pubkey, InValue = inValue, PreviousInValue = _inValueCache.GetInValue(hint.PreviousRoundId), Behaviour = hint.Behaviour, }; var secretPieces = _secretSharingService.GetEncryptedPieces(hint.RoundId); foreach (var secretPiece in secretPieces) { trigger.EncryptedPieces.Add(secretPiece.Key, ByteString.CopyFrom(secretPiece.Value)); } var decryptedPieces = _secretSharingService.GetDecryptedPieces(hint.RoundId); foreach (var decryptedPiece in decryptedPieces) { trigger.DecryptedPieces.Add(decryptedPiece.Key, ByteString.CopyFrom(decryptedPiece.Value)); } var revealedInValues = _secretSharingService.GetRevealedInValues(hint.RoundId); foreach (var revealedInValue in revealedInValues) { trigger.RevealedInValues.Add(revealedInValue.Key, revealedInValue.Value); } return(trigger.ToBytesValue()); } return(new AElfConsensusTriggerInformation { Pubkey = Pubkey, Behaviour = hint.Behaviour }.ToBytesValue()); }
public override int GetHashCode() { int hash = 1; if (valueTypeCase_ == ValueTypeOneofCase.NullValue) { hash ^= NullValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.BooleanValue) { hash ^= BooleanValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.IntegerValue) { hash ^= IntegerValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.DoubleValue) { hash ^= DoubleValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.TimestampValue) { hash ^= TimestampValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.StringValue) { hash ^= StringValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.BytesValue) { hash ^= BytesValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.ReferenceValue) { hash ^= ReferenceValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.GeoPointValue) { hash ^= GeoPointValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.ArrayValue) { hash ^= ArrayValue.GetHashCode(); } if (valueTypeCase_ == ValueTypeOneofCase.MapValue) { hash ^= MapValue.GetHashCode(); } hash ^= (int)valueTypeCase_; return(hash); }
public override int GetHashCode() { int hash = 1; if (column_ != null) { hash ^= Column.GetHashCode(); } if (NegateComparator != false) { hash ^= NegateComparator.GetHashCode(); } if (Comparator != global::LukeKennedy.LSQL.Net.Comparator.UnknownComparator) { hash ^= Comparator.GetHashCode(); } if (valueCase_ == ValueOneofCase.StringValue) { hash ^= StringValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.Int64Value) { hash ^= Int64Value.GetHashCode(); } if (valueCase_ == ValueOneofCase.Uint64Value) { hash ^= Uint64Value.GetHashCode(); } if (valueCase_ == ValueOneofCase.DoubleValue) { hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DoubleValue); } if (valueCase_ == ValueOneofCase.BoolValue) { hash ^= BoolValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.BytesValue) { hash ^= BytesValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.TimeValue) { hash ^= TimeValue.GetHashCode(); } hash ^= (int)valueCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
public override int GetHashCode() { int hash = 1; if (Type != 0) { hash ^= Type.GetHashCode(); } if (valueCase_ == ValueOneofCase.IntValue) { hash ^= IntValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.LongIntValue) { hash ^= LongIntValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.BoolValue) { hash ^= BoolValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.StringValue) { hash ^= StringValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.BytesValue) { hash ^= BytesValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.FloatValue) { hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(FloatValue); } if (valueCase_ == ValueOneofCase.DoubleValue) { hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DoubleValue); } if (ObjectTypeId != 0) { hash ^= ObjectTypeId.GetHashCode(); } hash ^= (int)valueCase_; if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
/// <summary> /// Converts the serialized protobuf data to human friendly representation. /// </summary> /// <returns></returns> public byte[] ToFriendlyBytes() { switch (Type) { case Types.RetType.Bool: var boolval = new BoolValue(); ((IMessage)boolval).MergeFrom(this.Data); return(BitConverter.GetBytes(boolval.Value)); case Types.RetType.Int32: var sint32Val = new SInt32Value(); ((IMessage)sint32Val).MergeFrom(this.Data); return(GetFriendlyBytes(sint32Val.Value)); case Types.RetType.Uint32: var uint32Val = new UInt32Value(); ((IMessage)uint32Val).MergeFrom(this.Data); return(GetFriendlyBytes(uint32Val.Value)); case Types.RetType.Int64: var sint64Val = new SInt64Value(); ((IMessage)sint64Val).MergeFrom(this.Data); return(GetFriendlyBytes(sint64Val.Value)); case Types.RetType.Uint64: var uint64Val = new UInt64Value(); ((IMessage)uint64Val).MergeFrom(this.Data); return(GetFriendlyBytes(uint64Val.Value)); case Types.RetType.String: var stringVal = new StringValue(); ((IMessage)stringVal).MergeFrom(this.Data); return(GetFriendlyBytes(stringVal.Value)); case Types.RetType.Bytes: var bytesVal = new BytesValue(); ((IMessage)bytesVal).MergeFrom(this.Data); return(GetFriendlyBytes(bytesVal.Value.ToByteArray())); case Types.RetType.PbMessage: case Types.RetType.UserType: // Both are treated as bytes return(GetFriendlyBytes(Data.ToByteArray())); } return(new byte[0]); }
/// <summary> /// In this method, `Context.CurrentBlockTime` is the time one miner start request his next consensus command. /// </summary> /// <param name="input"></param> /// <returns></returns> public override ConsensusCommand GetConsensusCommand(BytesValue input) { _processingBlockMinerPubkey = input.Value.ToHex(); if (Context.CurrentHeight < 2) { return(ConsensusCommandProvider.InvalidConsensusCommand); } if (!TryToGetCurrentRoundInformation(out var currentRound)) { return(ConsensusCommandProvider.InvalidConsensusCommand); } if (!currentRound.IsInMinerList(_processingBlockMinerPubkey)) { return(ConsensusCommandProvider.InvalidConsensusCommand); } if (currentRound.RealTimeMinersInformation.Count != 1 && currentRound.RoundNumber > 2 && State.LatestPubkeyToTinyBlocksCount.Value != null && State.LatestPubkeyToTinyBlocksCount.Value.Pubkey == _processingBlockMinerPubkey && State.LatestPubkeyToTinyBlocksCount.Value.BlocksCount < 0) { return(GetConsensusCommand(AElfConsensusBehaviour.NextRound, currentRound, _processingBlockMinerPubkey, Context.CurrentBlockTime)); } var blockchainStartTimestamp = GetBlockchainStartTimestamp(); var behaviour = IsMainChain ? new MainChainConsensusBehaviourProvider(currentRound, _processingBlockMinerPubkey, GetMaximumBlocksCount(), Context.CurrentBlockTime, blockchainStartTimestamp, State.PeriodSeconds.Value) .GetConsensusBehaviour() : new SideChainConsensusBehaviourProvider(currentRound, _processingBlockMinerPubkey, GetMaximumBlocksCount(), Context.CurrentBlockTime).GetConsensusBehaviour(); Context.LogDebug(() => $"{currentRound.ToString(_processingBlockMinerPubkey)}\nArranged behaviour: {behaviour.ToString()}"); return(behaviour == AElfConsensusBehaviour.Nothing ? ConsensusCommandProvider.InvalidConsensusCommand : GetConsensusCommand(behaviour, currentRound, _processingBlockMinerPubkey, Context.CurrentBlockTime)); }
public async Task TestRoundtrip() { var bytes = new byte[1024 * 1024]; var random = new Random(); random.NextBytes(bytes); var client = new HttpClient(new Base64Handler()); var request = new BytesValue { Value = ByteString.CopyFrom(bytes) }; var uri = $"http://{EndPoint}/Echo/Bytes"; var response = await client.PostGrpcWebAsync <BytesValue, BytesValue>(uri, request); Assert.AreEqual(request.Value.ToByteArray(), response.Value.ToByteArray()); }
public override TransactionList GenerateConsensusTransactions(BytesValue input) { var triggerInformation = new AElfConsensusTriggerInformation(); triggerInformation.MergeFrom(input.Value); // Some basic checks. Assert(triggerInformation.Pubkey.Any(), "Data to request consensus information should contain pubkey."); var pubkey = triggerInformation.Pubkey; var consensusInformation = new AElfConsensusHeaderInformation(); consensusInformation.MergeFrom(GetConsensusBlockExtraData(input, true).Value); var transactionList = GenerateTransactionListByExtraData(consensusInformation, pubkey); return(transactionList); }
public override int GetHashCode() { int hash = 1; if (BytesValue.Length != 0) { hash ^= BytesValue.GetHashCode(); } if (StringValue.Length != 0) { hash ^= StringValue.GetHashCode(); } if (_unknownFields != null) { hash ^= _unknownFields.GetHashCode(); } return(hash); }
public override int GetHashCode() { int hash = 1; if (Type != 0) { hash ^= Type.GetHashCode(); } if (valueCase_ == ValueOneofCase.Int32Value) { hash ^= Int32Value.GetHashCode(); } if (valueCase_ == ValueOneofCase.Int64Value) { hash ^= Int64Value.GetHashCode(); } if (valueCase_ == ValueOneofCase.FloatValue) { hash ^= FloatValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.DoubleValue) { hash ^= DoubleValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.BooleanValue) { hash ^= BooleanValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.StringValue) { hash ^= StringValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.BytesValue) { hash ^= BytesValue.GetHashCode(); } if (valueCase_ == ValueOneofCase.MetaValue) { hash ^= MetaValue.GetHashCode(); } hash ^= (int)valueCase_; return(hash); }
public override BytesValue GetRandomBytes(BytesValue input) { var serializedInput = new GetRandomBytesInput(); serializedInput.MergeFrom(input.Value); var value = new Hash(); value.MergeFrom(serializedInput.Value); var randomHashFromContext = Context.GetRandomHash(value); return(new BytesValue { Value = serializedInput.Kind == 1 ? new BytesValue { Value = randomHashFromContext.Value }.ToByteString() : new Int64Value { Value = Context.ConvertHashToInt64(randomHashFromContext, 1, 10000) }.ToByteString() }); }
public override Empty UpdateInformationFromCrossChain(BytesValue input) { Assert( Context.Sender == Context.GetContractAddressByName(SmartContractConstants.CrossChainContractSystemName), "Only Cross Chain Contract can call this method."); Assert(!State.IsMainChain.Value, "Only side chain can update consensus information."); // For now we just extract the miner list from main chain consensus information, then update miners list. if (input == null || input.Value.IsEmpty) { return(new Empty()); } var consensusInformation = AElfConsensusHeaderInformation.Parser.ParseFrom(input.Value); // check round number of shared consensus, not term number if (consensusInformation.Round.RoundNumber <= State.MainChainRoundNumber.Value) { return(new Empty()); } Context.LogDebug(() => $"Shared miner list of round {consensusInformation.Round.RoundNumber}:" + $"{consensusInformation.Round.ToString("M")}"); DistributeResourceTokensToPreviousMiners(); State.MainChainRoundNumber.Value = consensusInformation.Round.RoundNumber; var minersKeys = consensusInformation.Round.RealTimeMinersInformation.Keys; State.MainChainCurrentMinerList.Value = new MinerList { Pubkeys = { minersKeys.Select(ByteStringHelper.FromHexString) } }; return(new Empty()); }
public override ValidationResult ValidateConsensusAfterExecution(BytesValue input) { var headerInformation = new AElfConsensusHeaderInformation(); headerInformation.MergeFrom(input.Value); if (TryToGetCurrentRoundInformation(out var currentRound)) { if (headerInformation.Behaviour == AElfConsensusBehaviour.UpdateValue) { headerInformation.Round = currentRound.RecoverFromUpdateValue(headerInformation.Round, headerInformation.SenderPubkey.ToHex()); } if (headerInformation.Behaviour == AElfConsensusBehaviour.TinyBlock) { headerInformation.Round = currentRound.RecoverFromTinyBlock(headerInformation.Round, headerInformation.SenderPubkey.ToHex()); } var isContainPreviousInValue = !currentRound.IsMinerListJustChanged; if (headerInformation.Round.GetHash(isContainPreviousInValue) != currentRound.GetHash(isContainPreviousInValue)) { Context.LogDebug(() => $"Round information of block header:\n{headerInformation.Round}"); Context.LogDebug(() => $"Round information of executing result:\n{currentRound}"); return(new ValidationResult { Success = false, Message = "Current round information is different with consensus extra data." }); } } return(new ValidationResult { Success = true }); }