public void ToArray_Success() { byte[] sourceArray = new byte[] { 18, 178, 255, 70, 0 }; ByteString result = new ByteString(sourceArray); Assert.Equal<byte>(new byte[] { 18, 178, 255, 70, 0 }, result.ToByteArray()); }
internal PopFollowingResponse(ByteString text) { if (text == null) throw new ArgumentNullException("text"); this.Text = text; }
public static PopDropListing ToDropListing(ByteString[] texts) { ThrowIfTooFewTexts(texts, 2); return new PopDropListing(ToNumber(texts[0]), ToNumber(texts[1])); }
protected override SaslExchangeStatus Exchange(ByteString serverChallenge, out ByteString clientResponse) { if (Credential == null) throw new SaslException("Credential property must be set"); clientResponse = null; switch (step /* challenge */) { case 0: /* case "Username:"******"Password:": */ if (string.IsNullOrEmpty(Credential.Password)) return SaslExchangeStatus.Failed; step++; clientResponse = new ByteString(Credential.Password); return SaslExchangeStatus.Succeeded; default: // unexpected server challenge clientResponse = null; return SaslExchangeStatus.Failed; } }
/** * Method attaches a signature (captured) from the UI to a successfully executed transaction */ public EzeResult attachSignature(string txnId, ImageType imageType, ByteString imageData, int height, int width, double tipAmount) { Console.Error.WriteLine("...attachSignature <" + txnId + ">"); SignatureInput signatureInput = SignatureInput.CreateBuilder() .SetTxnId(txnId) .SetImageType(MapImageType(imageType)) .SetImageBytes(imageData) .SetHeight(height) .SetWidth(width) .SetTipAmount(tipAmount) .Build(); ApiInput apiInput = ApiInput.CreateBuilder() .SetMsgType(ApiInput.Types.MessageType.ATTACH_SIGNATURE) .SetMsgData(signatureInput.ToByteString()).Build(); this.send(apiInput); EzeResult result = null; while (true) { result = this.getResult(this.receive()); if (result.getEventName() == EventName.ATTACH_SIGNATURE) break; } return result; }
/// <summary> /// Parses a message from the given byte string. /// </summary> /// <param name="data">The data to parse.</param> /// <returns>The parsed message.</returns> public IMessage ParseFrom(ByteString data) { Preconditions.CheckNotNull(data, "data"); IMessage message = factory(); message.MergeFrom(data); return message; }
public OutboundTransaction(ByteString recordKey, long amount, ByteString version, string target) { this.RecordKey = recordKey; this.Amount = amount; this.Version = version; this.Target = target; }
protected override SaslExchangeStatus Exchange(ByteString serverChallenge, out ByteString clientResponse) { // 2. The Anonymous Mechanism // The mechanism consists of a single message from the client to the // server. The client may include in this message trace information in // the form of a string of [UTF-8]-encoded [Unicode] characters prepared // in accordance with [StringPrep] and the "trace" stringprep profile // defined in Section 3 of this document. The trace information, which // has no semantical value, should take one of two forms: an Internet // email address, or an opaque string that does not contain the '@' // (U+0040) character and that can be interpreted by the system // administrator of the client's domain. For privacy reasons, an // Internet email address or other information identifying the user // should only be used with permission from the user. if (Credential == null) throw new SaslException("Credential property must be set"); clientResponse = null; if (string.IsNullOrEmpty(Credential.UserName)) return SaslExchangeStatus.Failed; // XXX clientResponse = new ByteString(Encoding.UTF8.GetBytes(Credential.UserName)); return SaslExchangeStatus.Succeeded; }
/// <summary> /// Initializes a new instance of the <see cref="Mutation"/> class. /// </summary> /// <param name="@namespace">The namespace in which the mutation operates.</param> /// <param name="records">A collection of all the records affected by the mutation.</param> /// <param name="metadata">The metadata associated with the mutation.</param> public Mutation(ByteString @namespace, IEnumerable<Record> records, ByteString metadata) { if (@namespace == null) throw new ArgumentNullException(nameof(@namespace)); if (records == null) throw new ArgumentNullException(nameof(records)); if (metadata == null) throw new ArgumentNullException(nameof(metadata)); this.Namespace = @namespace; this.Records = records.ToList().AsReadOnly(); this.Metadata = metadata; // Records must not be null if (this.Records.Any(entry => entry == null)) throw new ArgumentNullException(nameof(records)); // There must not be any duplicate keys HashSet<ByteString> keys = new HashSet<ByteString>(); foreach (Record record in this.Records) { if (keys.Contains(record.Key)) throw new ArgumentNullException(nameof(records)); keys.Add(record.Key); } }
public async Task<ByteString> PostTransaction(ByteString rawMutation, IReadOnlyList<SignatureEvidence> authentication) { Mutation mutation; try { // Verify that the mutation can be deserialized mutation = MessageSerializer.DeserializeMutation(rawMutation); } catch (InvalidProtocolBufferException) { throw new TransactionInvalidException("InvalidMutation"); } if (!mutation.Namespace.Equals(this.ledgerId)) throw new TransactionInvalidException("InvalidNamespace"); if (mutation.Records.Count == 0) throw new TransactionInvalidException("InvalidMutation"); if (mutation.Records.Any(record => record.Key.Value.Count > MaxKeySize)) throw new TransactionInvalidException("InvalidMutation"); ValidateAuthentication(authentication, MessageSerializer.ComputeHash(rawMutation.ToByteArray())); ParsedMutation parsedMutation = ParsedMutation.Parse(mutation); // All assets must have an overall zero balance IReadOnlyDictionary<AccountKey, AccountStatus> accounts = await this.store.GetAccounts(parsedMutation.AccountMutations.Select(entry => entry.AccountKey)); var groups = parsedMutation.AccountMutations .GroupBy(account => account.AccountKey.Asset.FullPath) .Select(group => group.Sum(entry => entry.Balance - accounts[entry.AccountKey].Balance)); if (groups.Any(group => group != 0)) throw new TransactionInvalidException("UnbalancedTransaction"); DateTime date = DateTime.UtcNow; await this.validator.Validate(parsedMutation, authentication, accounts); TransactionMetadata metadata = new TransactionMetadata(authentication); byte[] rawMetadata = SerializeMetadata(metadata); Transaction transaction = new Transaction(rawMutation, date, new ByteString(rawMetadata)); byte[] serializedTransaction = MessageSerializer.SerializeTransaction(transaction); try { await this.store.AddTransactions(new[] { new ByteString(serializedTransaction) }); } catch (ConcurrentMutationException) { throw new TransactionInvalidException("OptimisticConcurrency"); } return new ByteString(MessageSerializer.ComputeHash(serializedTransaction)); }
public static async Task<Record> GetRecordVersion(this ILedgerQueries queries, ByteString key, ByteString version) { if (version.Value.Count == 0) { return new Record(key, ByteString.Empty, ByteString.Empty); } else { ByteString rawTransaction = await queries.GetTransaction(version); if (rawTransaction == null) { return null; } else { Transaction transaction = MessageSerializer.DeserializeTransaction(rawTransaction); Mutation mutation = MessageSerializer.DeserializeMutation(transaction.Mutation); Record result = mutation.Records.FirstOrDefault(record => record.Key.Equals(key) && record.Value != null); if (result == null) return null; else return result; } } }
public void TestContains() { var str = new ByteString("ababdabdbdabcab"); Assert.IsTrue(str.Contains(new ByteString("abc"))); Assert.IsTrue(str.Contains(new ByteString("abd"))); Assert.IsFalse(str.Contains(new ByteString("abe"))); }
public UnknownFieldSetTest() { descriptor = TestAllTypes.Descriptor; allFields = TestUtil.GetAllSet(); allFieldsData = allFields.ToByteString(); emptyMessage = TestEmptyMessage.ParseFrom(allFieldsData); unknownFields = emptyMessage.UnknownFields; }
/// <summary> /// Merges data from the given byte string into an existing message. /// </summary> /// <param name="message">The message to merge the data into.</param> /// <param name="data">The data to merge, which must be protobuf-encoded binary data.</param> public static void MergeFrom(this IMessage message, ByteString data) { ProtoPreconditions.CheckNotNull(message, "message"); ProtoPreconditions.CheckNotNull(data, "data"); CodedInputStream input = data.CreateCodedInput(); message.MergeFrom(input); input.CheckReadEndOfStreamTag(); }
public void TestConstructFromString() { var s = new ByteString("abc"); Assert.IsFalse(s.IsEmpty); Assert.AreEqual(3, s.Length); Assert.AreEqual(new byte[] {0x61, 0x62, 0x63}, s.ByteArray); }
public AkkaProtocolSpec() { testEnvelope = codec.ConstructMessage(localAkkaAddress, testActor, testMsg); testMsgPdu = codec.ConstructPayload(testEnvelope); testHeartbeat = new InboundPayload(codec.ConstructHeartbeat()); testPayload = new InboundPayload(testMsgPdu); }
public string DecodeEscapedString(int end, int skip, Encoding encoding) { if(CheckValue('\"')) { var sb = new StringBuilder(end - Position); ByteString bs = null; var bytes = new byte[end - Position + 1]; Skip(); while(Position < end) { var c = ReadChar(); if(c == '\\') { var nc = CurrentChar; if(nc.IsOctDigit()) { if(bs == null) { var bufferSize = end - Position; if(bufferSize < 1) bufferSize = 1; bs = new ByteString(end - Position); } int len = 1; int start = Position; Skip(); while(CurrentChar.IsOctDigit()) { Skip(); ++len; } bs.AppendByte(ByteFromOctString(String, start, len)); } else { ByteString.Dump(bs, sb, encoding); HandleEscapeCode(sb, nc); Skip(); } } else if(c == '\"') { ByteString.Dump(bs, sb, encoding); break; } else { ByteString.Dump(bs, sb, encoding); sb.Append(c); } } Position = end + skip; return sb.ToString(); } else { return ReadStringUpTo(end, skip); } }
public void Constructor_Success() { byte[] sourceArray = new byte[] { 18, 178, 255, 70, 0 }; ByteString result = new ByteString(sourceArray); sourceArray[4] = 1; Assert.NotSame(sourceArray, result.Value); Assert.Equal<byte>(new byte[] { 18, 178, 255, 70, 0 }, result.Value); }
public static long ToMessageNumber(ByteString text) { var val = ToNumber(text); if (val == 0L) throw new PopMalformedTextException(string.Format("must be non-zero positive number, but was {0}", val)); return val; }
public void Parse_Data() { ByteString data = new ByteString(Encoding.UTF8.GetBytes("/aka/name/:DATA:record:name")); RecordKey key = RecordKey.Parse(data); Assert.Equal(RecordType.Data, key.RecordType); Assert.Equal("/aka/name/", key.Path.FullPath); Assert.Equal("record:name", key.Name); }
public async Task<IReadOnlyList<ByteString>> GetRecordMutations(ByteString recordKey) { var key = recordKey.ToByteArray(); var res = await TransactionCollection.Find(Builders<MongoDbTransaction>.Filter.AnyEq(x=>x.Records, key)) .Project(x=>x.MutationHash) .SortBy(x=>x.Timestamp) .ToListAsync(); return res.Select(x=>new ByteString(x)).ToList().AsReadOnly(); }
public void Parse_Account() { ByteString data = new ByteString(Encoding.UTF8.GetBytes("/account/name/:ACC:/asset/name/")); RecordKey key = RecordKey.Parse(data); Assert.Equal(RecordType.Account, key.RecordType); Assert.Equal("/account/name/", key.Path.FullPath); Assert.Equal("/asset/name/", key.Name); }
public AkkaProtocolSpec() : base(@"akka.test.default-timeout = 1.5 s") { testEnvelope = codec.ConstructMessage(localAkkaAddress, TestActor, testMsg); testMsgPdu = codec.ConstructPayload(testEnvelope); testHeartbeat = new InboundPayload(codec.ConstructHeartbeat()); testPayload = new InboundPayload(testMsgPdu); }
public static async Task<IReadOnlyList<Record>> GetSubaccounts(this ILedgerQueries queries, string rootAccount) { ByteString prefix = new ByteString(Encoding.UTF8.GetBytes(rootAccount)); IReadOnlyList<Record> records = await queries.GetKeyStartingFrom(prefix); return records .Where(record => !record.Value.Equals(ByteString.Empty)) .ToList() .AsReadOnly(); }
public static async Task<IReadOnlyList<AccountStatus>> GetAccount(this ILedgerQueries queries, string account) { ByteString prefix = new ByteString(Encoding.UTF8.GetBytes(account + ":ACC:")); IReadOnlyList<Record> records = await queries.GetKeyStartingFrom(prefix); return records .Select(record => AccountStatus.FromRecord(RecordKey.Parse(record.Key), record)) .ToList() .AsReadOnly(); }
/// <summary> /// Converts a <see cref="ByteString"/> structure into a Helios <see cref="NetworkData"/> structure /// </summary> /// <param name="byteString">The data to send over the network</param> /// <param name="address">The address that we received data from / are sending data to</param> /// <returns>a new <see cref="NetworkData"/> struct</returns> public static NetworkData ToData(ByteString byteString, Address address) { var data = new NetworkData() { Buffer = byteString.ToByteArray(), RemoteHost = HeliosTransport.AddressToNode(address) }; data.Length = data.Buffer.Length; return data; }
public override void Setup() { base.Setup(); testEnvelope = codec.ConstructMessage(localAkkaAddress, testActor, testMsg); testMsgPdu = codec.ConstructPayload(testEnvelope); testHeartbeat = new InboundPayload(codec.ConstructHeartbeat()); testPayload = new InboundPayload(testMsgPdu); }
public async Task<IReadOnlyList<ByteString>> GetRecordMutations(ByteString recordKey) { return await ExecuteQuery<ByteString>( "EXEC [Openchain].[GetRecordMutations] @instance, @recordKey;", reader => new ByteString((byte[])reader[0]), new Dictionary<string, object>() { ["instance"] = this.instanceId, ["recordKey"] = recordKey.ToByteArray() }); }
public async Task<IReadOnlyList<ByteString>> GetRecordMutations(ByteString recordKey) { return await ExecuteAsync(@" SELECT MutationHash FROM RecordMutations WHERE RecordKey = @recordKey", reader => new ByteString((byte[])reader.GetValue(0)), new Dictionary<string, object>() { ["@recordKey"] = recordKey.ToByteArray() }); }
/// <summary> /// Initializes a new instance of the <see cref="Record"/> class. /// </summary> /// <param name="key">The key of the record.</param> /// <param name="value">The value of the record.</param> /// <param name="version">The version of the record.</param> public Record(ByteString key, ByteString value, ByteString version) { if (key == null) throw new ArgumentNullException(nameof(key)); if (version == null) throw new ArgumentNullException(nameof(version)); this.Key = key; this.Value = value; this.Version = version; }
private static IEnumerable <ByteString> StringToByteString(IEnumerable <string> str) => str.Select(s => ByteString.CopyFrom(Encoding.UTF8.GetBytes(s)));
public static object Deserialize(string typeName, ByteString bytes, int serializerId) => Serializers[serializerId].Deserialize(bytes, typeName);
private static object ConvertValue(ProtoBuf.Share.DataEntry.Types.Type dataEntryType, ByteString value) { NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger(); switch (dataEntryType) { case ProtoBuf.Share.DataEntry.Types.Type.ThirdPartyAttribute: return(ThirdPartyAttributeConverter.ParseThirdPartyAttribute(value.ToByteArray())); default: logger.Warn($"Unsupported data entry '{dataEntryType.ToString()}', skipping..."); return(null); } }
public static objectCoords ParseFrom(ByteString data) { return(CreateBuilder().MergeFrom(data).BuildParsed()); }
public override void ConfigureServices(ServiceConfigurationContext context) { base.ConfigureServices(context); var dictionary = new Dictionary <long, Hash> { { 1, Hash.FromString("1") }, { 2, Hash.FromString("2") }, { 3, Hash.FromString("3") } }; Configure <GrpcCrossChainConfigOption>(option => { option.ListeningPort = 5001; option.ParentChainServerIp = "127.0.0.1"; option.ParentChainServerPort = 5000; }); Configure <CrossChainConfigOptions>(option => { option.ParentChainId = ChainHelper.ConvertChainIdToBase58(ChainHelper.GetChainId(1)); }); context.Services.AddTransient(provider => { var kernelTestHelper = context.Services.GetRequiredServiceLazy <KernelTestHelper>(); var mockBlockChainService = new Mock <IBlockchainService>(); mockBlockChainService.Setup(m => m.GetChainAsync()).Returns(() => { var chain = new Chain { LastIrreversibleBlockHeight = 10 }; return(Task.FromResult(chain)); }); mockBlockChainService.Setup(m => m.GetBlockHashByHeightAsync(It.IsAny <Chain>(), It.IsAny <long>(), It.IsAny <Hash>())) .Returns <Chain, long, Hash>((chain, height, hash) => { if (height > 0 && height <= 3) { return(Task.FromResult(dictionary[height])); } return(Task.FromResult <Hash>(null)); }); mockBlockChainService.Setup(m => m.GetBlockByHashAsync(It.IsAny <Hash>())).Returns <Hash>(hash => { foreach (var kv in dictionary) { if (kv.Value.Equals(hash)) { var block = kernelTestHelper.Value.GenerateBlock(kv.Key - 1, dictionary[kv.Key - 1]); return(Task.FromResult(block)); } } return(Task.FromResult <Block>(null)); }); return(mockBlockChainService.Object); }); context.Services.AddTransient(provider => { var mockBlockExtraDataService = new Mock <IBlockExtraDataService>(); mockBlockExtraDataService .Setup(m => m.GetExtraDataFromBlockHeader(It.IsAny <string>(), It.IsAny <BlockHeader>())).Returns( () => { var crossExtraData = new CrossChainExtraData { TransactionStatusMerkleTreeRoot = Hash.FromString("SideChainBlockHeadersRoot"), }; return(ByteString.CopyFrom(crossExtraData.ToByteArray())); }); return(mockBlockExtraDataService.Object); }); context.Services.AddTransient(provider => { var mockCrossChainIndexingDataService = new Mock <ICrossChainIndexingDataService>(); mockCrossChainIndexingDataService .Setup(m => m.GetIndexedCrossChainBlockDataAsync(It.IsAny <Hash>(), It.IsAny <long>())) .Returns(() => { var crossChainBlockData = new CrossChainBlockData { SideChainBlockData = { new SideChainBlockData { ChainId = 123, Height = 1, TransactionStatusMerkleTreeRoot = Hash.FromString("fakeTransactionMerkleTree") } } }; return(Task.FromResult(crossChainBlockData)); }); mockCrossChainIndexingDataService .Setup(m => m.GetIndexedSideChainBlockDataAsync(It.IsAny <Hash>(), It.IsAny <long>())).Returns( () => { var indexedSideChainBlockData = new IndexedSideChainBlockData { SideChainBlockData = { new SideChainBlockData { ChainId = 123, Height = 1, TransactionStatusMerkleTreeRoot = Hash.FromString("fakeTransactionMerkleTree") } } }; return(Task.FromResult(indexedSideChainBlockData)); }); return(mockCrossChainIndexingDataService.Object); }); context.Services.AddTransient(provider => { var mockCrossChainClientProvider = new Mock <ICrossChainClientProvider>(); mockCrossChainClientProvider.Setup(m => m.CreateCrossChainClient(It.IsAny <CrossChainClientDto>())) .Returns(() => { var mockCrossChainClient = new Mock <ICrossChainClient>(); mockCrossChainClient.Setup(m => m.RequestChainInitializationDataAsync(It.IsAny <int>())).Returns(() => { var chainInitialization = new ChainInitializationData { CreationHeightOnParentChain = 1 }; return(Task.FromResult(chainInitialization)); }); mockCrossChainClient.Setup(m => m.RequestCrossChainDataAsync(It.IsAny <long>(), It.IsAny <Func <IBlockCacheEntity, bool> >())).Returns(() => { var chainInitialization = new ChainInitializationData { CreationHeightOnParentChain = 1 }; return(Task.FromResult(chainInitialization)); }); return(mockCrossChainClient.Object); }); return(mockCrossChainClientProvider.Object); }); context.Services.AddSingleton <CrossChainPlugin>(); }
private static IEnumerable <ByteString> StringToByteString(IEnumerable <ReadOnlyMemory <char> > str) => str.Select(s => ByteString.CopyFrom(Encoding.UTF8.GetBytes(s.ToString())));
public static Quaternion ParseFrom(ByteString data, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed()); }
public override void OnPush() { _buffer += Grab(_stage.Inlet); Rechunk(); }
public static ServerNotifyResult ParseFrom(ByteString data) { return(ServerNotifyResult.CreateBuilder().MergeFrom(data).BuildParsed()); }
public static ServerNotifyResult ParseFrom( ByteString data, ExtensionRegistry extensionRegistry) { return(ServerNotifyResult.CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed()); }
/// <exception cref="Com.Google.Protobuf.InvalidProtocolBufferException"/> public static ConcatVectorTableProto.ConcatVectorTable ParseFrom(ByteString data, ExtensionRegistryLite extensionRegistry) { return(Parser.ParseFrom(data, extensionRegistry)); }
/// <exception cref="Com.Google.Protobuf.InvalidProtocolBufferException"/> public static ConcatVectorTableProto.ConcatVectorTable ParseFrom(ByteString data) { return(Parser.ParseFrom(data)); }
private void SendMessage(Message message) { ack = false; SendData(ByteString.FromBytes(message.ToArray())); }
private static ByteStringContext.ExternalScope CreateCounterKeySlice(DocumentsOperationContext context, ByteString buffer, Slice documentIdPrefix, Slice counterName, out Slice counterKeySlice) { var scope = Slice.External(context.Allocator, buffer.Ptr, buffer.Length, out counterKeySlice); documentIdPrefix.CopyTo(buffer.Ptr); counterName.CopyTo(buffer.Ptr + documentIdPrefix.Size); return(scope); }
public static Quaternion ParseFrom(ByteString data) { return(CreateBuilder().MergeFrom(data).BuildParsed()); }
private static Flow <ByteString, string, NotUsed> SimpleLines(string delimiter, int maximumBytes, bool allowTruncation = true) { return(Framing.Delimiter(ByteString.FromString(delimiter), maximumBytes, allowTruncation) .Select(x => x.ToString(Encoding.UTF8)).Named("LineFraming")); }
public async Task ClientStream_HttpClientWithTimeout_Success() { SetExpectedErrorsFilter(writeContext => { if (writeContext.LoggerName == "Grpc.Net.Client.Internal.GrpcCall" && writeContext.Exception is TaskCanceledException) { return(true); } if (writeContext.LoggerName == "Grpc.Net.Client.Internal.GrpcCall" && writeContext.EventId.Name == "WriteMessageError" && writeContext.Exception is InvalidOperationException && writeContext.Exception.Message == "Can't write the message because the call is complete.") { return(true); } if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName) { return(true); } return(false); }); using var httpEventListener = new HttpEventSourceListener(LoggerFactory); var tcs = new TaskCompletionSource <object?>(TaskCreationOptions.RunContinuationsAsynchronously); async Task <DataComplete> ClientStreamedData(IAsyncStreamReader <DataMessage> requestStream, ServerCallContext context) { Logger.LogInformation("Server started"); context.CancellationToken.Register(() => { Logger.LogInformation("Server completed TCS"); tcs.SetResult(null); }); var total = 0L; await foreach (var message in requestStream.ReadAllAsync()) { total += message.Data.Length; if (message.ServerDelayMilliseconds > 0) { await Task.Delay(message.ServerDelayMilliseconds); } } return(new DataComplete { Size = total }); } // Arrange var data = CreateTestData(1024); // 1 KB var method = Fixture.DynamicGrpc.AddClientStreamingMethod <DataMessage, DataComplete>(ClientStreamedData, "ClientStreamedDataTimeout"); var httpClient = Fixture.CreateClient(); httpClient.Timeout = TimeSpan.FromSeconds(0.5); var channel = GrpcChannel.ForAddress(httpClient.BaseAddress !, new GrpcChannelOptions { HttpClient = httpClient, LoggerFactory = LoggerFactory }); var client = TestClientFactory.Create(channel, method); var dataMessage = new DataMessage { Data = ByteString.CopyFrom(data) }; // Act var call = client.ClientStreamingCall(); Logger.LogInformation("Client writing message"); await call.RequestStream.WriteAsync(dataMessage).DefaultTimeout(); Logger.LogInformation("Client waiting for TCS to complete"); await tcs.Task.DefaultTimeout(); var ex = await ExceptionAssert.ThrowsAsync <RpcException>(() => call.RequestStream.WriteAsync(dataMessage)).DefaultTimeout(); // Assert Assert.AreEqual(StatusCode.Cancelled, ex.StatusCode); Assert.AreEqual(StatusCode.Cancelled, call.GetStatus().StatusCode); AssertHasLog(LogLevel.Information, "GrpcStatusError", "Call failed with gRPC error status. Status code: 'Cancelled', Message: ''."); await TestHelpers.AssertIsTrueRetryAsync( () => HasLog(LogLevel.Error, "ErrorExecutingServiceMethod", "Error when executing service method 'ClientStreamedDataTimeout'."), "Wait for server error so it doesn't impact other tests.").DefaultTimeout(); }
public static RustProto.Blueprint ParseFrom(ByteString data, ExtensionRegistry extensionRegistry) { return(CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed()); }
public static RustProto.Blueprint ParseFrom(ByteString data) { return(CreateBuilder().MergeFrom(data).BuildParsed()); }
public void Convert_ByteArray_To_ByteString_Should_Fail() { var testBytes = new byte[500]; testBytes.ToByteString().Should().Equal(ByteString.CopyFrom(testBytes)); }
private static ByteString StringToByteString(ReadOnlyMemory <char> str) => ByteString.CopyFrom(Encoding.UTF8.GetBytes(str.ToString()));
public async ETVoid DispatchAsync(Session session, ushort opcode, object message) { // 根据消息接口判断是不是Actor消息,不同的接口做不同的处理 switch (message) { case IFrameMessage iFrameMessage: // 如果是帧消息,构造成OneFrameMessage发给对应的unit { long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId; ActorLocationSender actorLocationSender = Game.Scene.GetComponent <ActorLocationSenderComponent>().Get(unitId); // 这里设置了帧消息的id,防止客户端伪造 iFrameMessage.Id = unitId; OneFrameMessage oneFrameMessage = new OneFrameMessage { Op = opcode, AMessage = ByteString.CopyFrom(session.Network.MessagePacker.SerializeTo(iFrameMessage)) }; //actorLocationSender.Send(oneFrameMessage); Game.Scene.GetComponent <ServerFrameComponent>().Add(oneFrameMessage); return; } case IActorLocationRequest actorLocationRequest: // gate session收到actor rpc消息,先向actor 发送rpc请求,再将请求结果返回客户端 { long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId; ActorLocationSender actorLocationSender = Game.Scene.GetComponent <ActorLocationSenderComponent>().Get(unitId); int rpcId = actorLocationRequest.RpcId; // 这里要保存客户端的rpcId long instanceId = session.InstanceId; IResponse response = await actorLocationSender.Call(actorLocationRequest); response.RpcId = rpcId; // session可能已经断开了,所以这里需要判断 if (session.InstanceId == instanceId) { session.Reply(response); } break; } case IActorLocationMessage actorLocationMessage: { long unitId = session.GetComponent <SessionPlayerComponent>().Player.UnitId; ActorLocationSender actorLocationSender = Game.Scene.GetComponent <ActorLocationSenderComponent>().Get(unitId); actorLocationSender.Send(actorLocationMessage); break; } case IActorRequest actorRequest: // 分发IActorRequest消息,目前没有用到,需要的自己添加 { break; } case IActorMessage actorMessage: // 分发IActorMessage消息,目前没有用到,需要的自己添加 { break; } default: { // 非Actor消息 Game.Scene.GetComponent <MessageDispatcherComponent>().Handle(session, new MessageInfo(opcode, message)); break; } } }
public async Task Create_ProposalFailed_Test() { var organizationAddress = await CreateOrganizationAsync(); var blockTime = BlockTimeProvider.GetBlockTime(); var createProposalInput = new CreateProposalInput { ToAddress = SampleAddress.AddressList[0], Params = ByteString.CopyFromUtf8("Test"), ExpiredTime = blockTime.AddDays(1), OrganizationAddress = organizationAddress }; //"Invalid proposal." //ContractMethodName is null or white space { var transactionResult = await ParliamentAuthContractStub.CreateProposal.SendWithExceptionAsync(createProposalInput); transactionResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); transactionResult.TransactionResult.Error.Contains("Invalid proposal.").ShouldBeTrue(); } //ToAddress is null { createProposalInput.ContractMethodName = "Test"; createProposalInput.ToAddress = null; var transactionResult = await ParliamentAuthContractStub.CreateProposal.SendWithExceptionAsync(createProposalInput); transactionResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); transactionResult.TransactionResult.Error.Contains("Invalid proposal.").ShouldBeTrue(); } //ExpiredTime is null { createProposalInput.ExpiredTime = null; createProposalInput.ToAddress = SampleAddress.AddressList[0]; var transactionResult = await ParliamentAuthContractStub.CreateProposal.SendWithExceptionAsync(createProposalInput); transactionResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); transactionResult.TransactionResult.Error.Contains("Invalid proposal.").ShouldBeTrue(); } //"Expired proposal." { createProposalInput.ExpiredTime = blockTime.AddMilliseconds(5); Thread.Sleep(10); var transactionResult = await ParliamentAuthContractStub.CreateProposal.SendWithExceptionAsync(createProposalInput); transactionResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); } //"No registered organization." { createProposalInput.ExpiredTime = BlockTimeProvider.GetBlockTime().AddDays(1); createProposalInput.OrganizationAddress = SampleAddress.AddressList[1]; var transactionResult = await ParliamentAuthContractStub.CreateProposal.SendWithExceptionAsync(createProposalInput); transactionResult.TransactionResult.Status.ShouldBe(TransactionResultStatus.Failed); transactionResult.TransactionResult.Error.Contains("No registered organization.").ShouldBeTrue(); } //"Proposal with same input." { createProposalInput.OrganizationAddress = organizationAddress; var transactionResult1 = await ParliamentAuthContractStub.CreateProposal.SendAsync(createProposalInput); transactionResult1.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined); var transactionResult2 = await ParliamentAuthContractStub.CreateProposal.SendAsync(createProposalInput); transactionResult2.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined); } }
public async Task Candidates_NotEnough_Test() { await InitializeCandidates(EconomicContractsTestConstants.InitialCoreDataCenterCount); var firstRound = await AEDPoSContractStub.GetCurrentRoundInformation.CallAsync(new Empty()); var randomHashes = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount) .Select(_ => HashHelper.ComputeFrom("hash3")).ToList(); var triggers = Enumerable.Range(0, EconomicContractsTestConstants.InitialCoreDataCenterCount).Select(i => new AElfConsensusTriggerInformation { Pubkey = ByteString.CopyFrom(InitialCoreDataCenterKeyPairs[i].PublicKey), InValue = randomHashes[i] }).ToDictionary(t => t.Pubkey.ToHex(), t => t); var voter = GetElectionContractTester(VoterKeyPairs[0]); foreach (var candidateKeyPair in ValidationDataCenterKeyPairs.Take(EconomicContractsTestConstants .InitialCoreDataCenterCount)) { await voter.Vote.SendAsync(new VoteMinerInput { CandidatePubkey = candidateKeyPair.PublicKey.ToHex(), Amount = 100 + new Random().Next(1, 200), EndTimestamp = TimestampHelper.GetUtcNow().AddDays(100) }); } foreach (var minerInRound in firstRound.RealTimeMinersInformation.Values.OrderBy(m => m.Order)) { var currentKeyPair = InitialCoreDataCenterKeyPairs.First(p => p.PublicKey.ToHex() == minerInRound.Pubkey); KeyPairProvider.SetKeyPair(currentKeyPair); BlockTimeProvider.SetBlockTime(minerInRound.ExpectedMiningTime); var tester = GetAEDPoSContractStub(currentKeyPair); var headerInformation = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync(triggers[minerInRound.Pubkey] .ToBytesValue())).ToConsensusHeaderInformation(); // Update consensus information. var toUpdate = headerInformation.Round.ExtractInformationToUpdateConsensus(minerInRound.Pubkey); await tester.UpdateValue.SendAsync(toUpdate); } var changeTermTime = BlockchainStartTimestamp.ToDateTime() .AddMinutes(AEDPoSContractTestConstants.PeriodSeconds + 1); BlockTimeProvider.SetBlockTime(changeTermTime.ToTimestamp()); var nextTermInformation = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync( new AElfConsensusTriggerInformation { Behaviour = AElfConsensusBehaviour.NextTerm, Pubkey = ByteString.CopyFrom(BootMinerKeyPair.PublicKey) }.ToBytesValue())).ToConsensusHeaderInformation(); await AEDPoSContractStub.NextTerm.SendAsync(nextTermInformation.Round); // First candidate cheat others with in value. var oneCandidate = GetAEDPoSContractStub(ValidationDataCenterKeyPairs[0]); var anotherCandidate = GetAEDPoSContractStub(ValidationDataCenterKeyPairs[1]); var randomHash = HashHelper.ComputeFrom("hash5"); var informationOfSecondRound = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync( new AElfConsensusTriggerInformation { Behaviour = AElfConsensusBehaviour.UpdateValue, PreviousInValue = Hash.Empty, InValue = randomHash, Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey) }.ToBytesValue())).ToConsensusHeaderInformation(); var updateResult = await oneCandidate.UpdateValue.SendAsync( informationOfSecondRound.Round.ExtractInformationToUpdateConsensus(ValidationDataCenterKeyPairs[0] .PublicKey.ToHex())); var thirdRoundStartTime = changeTermTime.AddMinutes(AEDPoSContractTestConstants.PeriodSeconds + 2); BlockTimeProvider.SetBlockTime(thirdRoundStartTime.ToTimestamp()); var thirdRound = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync( new AElfConsensusTriggerInformation { Behaviour = AElfConsensusBehaviour.NextRound, Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey) }.ToBytesValue())).ToConsensusHeaderInformation().Round; await oneCandidate.NextRound.SendAsync(thirdRound); var cheatInformation = (await AEDPoSContractStub.GetConsensusExtraData.CallAsync( new AElfConsensusTriggerInformation { Behaviour = AElfConsensusBehaviour.UpdateValue, PreviousInValue = HashHelper.ComputeFrom(randomHash), // Not same as before. InValue = HashHelper.ComputeFrom("InValue"), // Don't care this value in current test case. Pubkey = ByteString.CopyFrom(ValidationDataCenterKeyPairs[0].PublicKey) }.ToBytesValue())).ToConsensusHeaderInformation(); await oneCandidate.UpdateValue.SendAsync( cheatInformation.Round.ExtractInformationToUpdateConsensus(ValidationDataCenterKeyPairs[0].PublicKey .ToHex())); }
public async Task <Object.Object> GetObject(CancellationToken context, GetObjectParams param, CallOptions options = null) { var object_client = new ObjectService.ObjectServiceClient(channel); var object_address = param.Address; var opts = DefaultCallOptions.ApplyCustomOptions(options); var req = new GetRequest { Body = new GetRequest.Types.Body { Raw = param.Raw, Address = object_address, } }; var meta = opts.GetRequestMetaHeader(); AttachObjectSessionToken(opts, meta, object_address, ObjectSessionContext.Types.Verb.Get); req.MetaHeader = meta; req.SignRequest(key); var stream = object_client.Get(req, cancellationToken: context).ResponseStream; var obj = new Object.Object(); var payload = new byte[] { }; int offset = 0; while (await stream.MoveNext()) { var resp = stream.Current; if (!resp.VerifyResponse()) { throw new InvalidOperationException("invalid object get response"); } switch (resp.Body.ObjectPartCase) { case GetResponse.Types.Body.ObjectPartOneofCase.Init: { obj.ObjectId = resp.Body.Init.ObjectId; obj.Signature = resp.Body.Init.Signature; obj.Header = resp.Body.Init.Header; payload = new byte[obj.Header.PayloadLength]; break; } case GetResponse.Types.Body.ObjectPartOneofCase.Chunk: { resp.Body.Chunk.CopyTo(payload, offset); offset += resp.Body.Chunk.Length; break; } case GetResponse.Types.Body.ObjectPartOneofCase.SplitInfo: { throw new SplitInfoException(resp.Body.SplitInfo); } default: throw new FormatException("malformed object get reponse"); } } obj.Payload = ByteString.CopyFrom(payload); return(obj); }
private static ByteString StringToByteString(string str) => ByteString.CopyFrom(Encoding.UTF8.GetBytes(str));
public void Convert_ByteArray_To_ByteString_Should_Succeed(int arraySize) { var testBytes = ByteUtil.GenerateRandomByteArray(arraySize); testBytes.ToByteString().Should().Equal(ByteString.CopyFrom(testBytes)); }
private static void WriteRawBlob(DocumentsOperationContext context, List <string> dbIds, List <CounterDetail> counters, ByteString newVal, ManualBlittableJsonDocumentBuilder <UnmanagedWriteBuffer> builder) { foreach (var counterDetail in counters) { var dbId = ExtractDbId(context, counterDetail.CounterKey); int dbIdIndex; for (dbIdIndex = 0; dbIdIndex < dbIds.Count; dbIdIndex++) { if (dbIds[dbIdIndex] == dbId) { break; } } var counterEtag = context.DocumentDatabase.DocumentsStorage.GenerateNextEtag(); var newEntry = (CountersStorage.CounterValues *)newVal.Ptr + dbIdIndex; newEntry->Value = counterDetail.TotalValue; newEntry->Etag = counterEtag; } builder.WriteRawBlob(newVal.Ptr, newVal.Length); }
private Unknown6 GenerateSignature(IEnumerable <IMessage> requests) { var ticketBytes = _authTicket.ToByteArray(); //Added var sig = new Signature() { LocationHash1 = Utils.GenerateLocation1(ticketBytes, _latitude, _longitude, _altitude), LocationHash2 = Utils.GenerateLocation2(_latitude, _longitude, _altitude), SensorInfo = new Signature.Types.SensorInfo() { AccelNormalizedZ = GenRandom(9.8), AccelNormalizedX = GenRandom(0.02), AccelNormalizedY = GenRandom(0.3), TimestampSnapshot = (ulong)_internalWatch.ElapsedMilliseconds - 230, MagnetometerX = GenRandom(0.12271042913198471), MagnetometerY = GenRandom(-0.015570580959320068), MagnetometerZ = GenRandom(0.010850906372070313), AngleNormalizedX = GenRandom(17.950439453125), AngleNormalizedY = GenRandom(-23.36273193359375), AngleNormalizedZ = GenRandom(-48.8250732421875), AccelRawX = GenRandom(-0.0120010357350111), AccelRawY = GenRandom(-0.04214850440621376), AccelRawZ = GenRandom(0.94571763277053833), GyroscopeRawX = GenRandom(7.62939453125e-005), GyroscopeRawY = GenRandom(-0.00054931640625), GyroscopeRawZ = GenRandom(0.0024566650390625), AccelerometerAxes = 3 }, DeviceInfo = new Signature.Types.DeviceInfo() { DeviceId = Client.DeviceId, AndroidBoardName = Client.AndroidBoardName, AndroidBootloader = Client.AndroidBootloader, DeviceBrand = Client.DeviceBrand, DeviceModel = Client.DeviceModel, DeviceModelIdentifier = Client.DeviceModelIdentifier, DeviceModelBoot = Client.DeviceModelBoot, HardwareManufacturer = Client.HardwareManufacturer, HardwareModel = Client.HardwareModel, FirmwareBrand = Client.FirmwareBrand, FirmwareTags = Client.FirmwareTags, FirmwareType = Client.FirmwareType, FirmwareFingerprint = Client.FirmwareFingerprint } }; sig.LocationFix.Add(new Signature.Types.LocationFix() { Provider = "network", //Unk4 = 120, Latitude = (float)_latitude, Longitude = (float)_longitude, Altitude = (float)_altitude, TimestampSinceStart = (ulong)_internalWatch.ElapsedMilliseconds - 200, Floor = 3, LocationType = 1 }); //Compute 10 var x = new System.Data.HashFunction.xxHash(32, 0x1B845238); var firstHash = BitConverter.ToUInt32(x.ComputeHash(_authTicket.ToByteArray()), 0); x = new System.Data.HashFunction.xxHash(32, firstHash); var locationBytes = BitConverter.GetBytes(_latitude).Reverse() .Concat(BitConverter.GetBytes(_longitude).Reverse()) .Concat(BitConverter.GetBytes(_altitude).Reverse()).ToArray(); sig.LocationHash1 = BitConverter.ToUInt32(x.ComputeHash(locationBytes), 0); //Compute 20 x = new System.Data.HashFunction.xxHash(32, 0x1B845238); sig.LocationHash2 = BitConverter.ToUInt32(x.ComputeHash(locationBytes), 0); //Compute 24 x = new System.Data.HashFunction.xxHash(64, 0x1B845238); var seed = BitConverter.ToUInt64(x.ComputeHash(_authTicket.ToByteArray()), 0); x = new System.Data.HashFunction.xxHash(64, seed); foreach (var req in requests) { sig.RequestHash.Add(BitConverter.ToUInt64(x.ComputeHash(req.ToByteArray()), 0)); } Unknown6 val = new Unknown6(); val.RequestType = 6; val.Unknown2 = new Unknown6.Types.Unknown2(); val.Unknown2.Unknown1 = ByteString.CopyFrom(Encrypt(sig.ToByteArray())); foreach (var request in requests) { sig.RequestHash.Add(BitConverter.ToUInt64(x.ComputeHash(request.ToByteArray()), 0)); } sig.Unk22 = ByteString.CopyFrom(new byte[16] { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }); sig.Unk25 = BitConverter.ToUInt32(new System.Data.HashFunction.xxHash(64, 0x88533787).ComputeHash(System.Text.Encoding.ASCII.GetBytes("\"0f15301fe1d0e824738ef5d93355e56a6fb910d4\"")), 0); return(val); }
protected override void ProcessRecord() { base.ProcessRecord(); var db = DatastoreDb.Create(Project); var keyFactory = db.CreateKeyFactory(Kind); _gKey = string.IsNullOrEmpty(Key) ? keyFactory.CreateIncompleteKey() : keyFactory.CreateKey(Key); var entity = new Entity(); entity.Key = _gKey; foreach (var k in Properties.Keys) { var val = new Value(); switch (Properties[k]) {// I'm surprised there's no built in method in Value to handle this scenario case NullValue c: { val.NullValue = c; break; } case bool c: { val.BooleanValue = c; break; } case int c: { val.IntegerValue = (long)c; break; } case long c: { val.IntegerValue = c; break; } case float c: { val.DoubleValue = (double)c; break; } case double c: { val.DoubleValue = c; break; } case Timestamp c: { val.TimestampValue = c; break; } case DateTime c: { val.TimestampValue = c.ToTimestamp(); break; } case Cloud.Datastore.V1.Key c: { val.KeyValue = c; break; } case string c: { val.StringValue = c; break; } case byte[] c: { if (c.Length > 1000000) { var e = new ArgumentException("Max byte count exceeded"); var er = new ErrorRecord(e, "ByteCountLimitExceeded", ErrorCategory.InvalidData, Properties); ThrowTerminatingError(er); } val.BlobValue = ByteString.CopyFrom(c); break; } case LatLng c: { val.GeoPointValue = c; break; } case Entity c: { val.EntityValue = c; break; } case ArrayValue c: { val.ArrayValue = c; break; } default: { // It's either this or throw - not sure of best approach WriteWarning($"Unexpected type in properties dictionary: {Properties[k].GetType().FullName}"); val.StringValue = Properties[k].ToString(); break; } } entity.Properties.Add(k.ToString(), val); } WriteObject(entity); }