public void Execute_Prepared_With_Param_Test() { using (var connection = CreateConnection()) { connection.Open().Wait(); var prepareRequest = new PrepareRequest(GetSerializer(), "SELECT * FROM system.local WHERE key = ?", null, null); var task = connection.Send(prepareRequest); var prepareOutput = ValidateResult <OutputPrepared>(task.Result); var options = new QueryProtocolOptions(ConsistencyLevel.One, new object[] { "local" }, false, 100, null, ConsistencyLevel.Any); var executeRequest = new ExecuteRequest( GetSerializer(), prepareOutput.QueryId, null, new ResultMetadata(prepareOutput.ResultMetadataId, prepareOutput.ResultRowsMetadata), options, false, null); task = connection.Send(executeRequest); var output = ValidateResult <OutputRows>(task.Result); var rows = output.RowSet.ToList(); Assert.Greater(rows.Count, 0); Assert.NotNull(rows[0].GetValue <string>("key"), "It should contain a key column value"); } }
public void Execute_Prepared_Test() { using (var connection = CreateConnection()) { connection.Open().Wait(); //Prepare a query var prepareRequest = new PrepareRequest(GetSerializer(), BasicQuery, null, null); var task = connection.Send(prepareRequest); var prepareOutput = ValidateResult <OutputPrepared>(task.Result); //Execute the prepared query var executeRequest = new ExecuteRequest( GetSerializer(), prepareOutput.QueryId, null, new ResultMetadata(prepareOutput.ResultMetadataId, prepareOutput.ResultRowsMetadata), QueryProtocolOptions.Default, false, null); task = connection.Send(executeRequest); var output = ValidateResult <OutputRows>(task.Result); var rs = output.RowSet; var rows = rs.ToList(); Assert.Greater(rows.Count, 0); Assert.True(rows[0].GetValue <string>("key") != null, "It should contain a key column"); } }
public async Task Acceptor_OlderPrepareRequest_Rejected() { var acceptor = new Acceptor <string>("sample-acceptor"); var winningProposal = new Proposal <string>(100, "192.168.0.100"); var winningRequest = new PrepareRequest(winningProposal); var winningResponse = await acceptor.ReceivePrepareRequestAsync(winningRequest) .ConfigureAwait(false); var newProposal = new Proposal <string>(99, "192.168.0.99"); var newRequest = new PrepareRequest(newProposal); var newResponse = await acceptor.ReceivePrepareRequestAsync(newRequest) .ConfigureAwait(false); Assert.NotNull(newResponse); Assert.False(newResponse.Promised); Assert.NotNull(newResponse.AcceptedProposal); Assert.IsType <Proposal <string> >(newResponse.AcceptedProposal); Assert.IsNotType <Proposal <object> >(newResponse.AcceptedProposal); Assert.IsNotType <Proposal <int> >(newResponse.AcceptedProposal); Assert.Equal(winningProposal, winningResponse.AcceptedProposal); Assert.Equal(100, acceptor.PromisedProposalNumber); Assert.NotNull(acceptor.PromisedProposal.As <Proposal <string> >()); Assert.Equal("192.168.0.100", acceptor.PromisedProposal.As <Proposal <string> >() !.Value); Assert.Equal($"sample-acceptor: Proposal {{ Number = 100, Value = 192.168.0.100 }}", acceptor.ToString()); }
public async Task InitiatePrepareForMoveResourcesAsync() { using (var context = MockContext.Start(this.GetType())) { this.TestHelper.Initialize(context); var client = this.TestHelper.ResourceMoverServiceClient; var prepareRequest = new PrepareRequest() { MoveResources = new List <string>() { VirtualMachineId, NetworkInterfaceId, PublicIpId, LoadBalancerId, VirtualNetworkId, NetworkSecurityGroupId }, MoveResourceInputType = MoveResourceInputType.MoveResourceSourceId }; var operationStatus = (await client.MoveCollections.PrepareWithHttpMessagesAsync( MoveCollectionResourceGroup, MoveCollectionName, prepareRequest)).Body; Assert.True(OperationStatusSucceeded.Equals( operationStatus.Status, StringComparison.OrdinalIgnoreCase), "Prepare operation should have succeeded."); } }
public override Task <Empty> Prepare(PrepareRequest request, ServerCallContext context) { _bus.Publish(new ElectionMessage.Prepare( Uuid.FromDto(request.ServerId).ToGuid(), new IPEndPoint(IPAddress.Parse(request.ServerInternalHttp.Address), (int)request.ServerInternalHttp.Port), request.View)); return(EmptyResult); }
private async Task SendPrepareAsync(Guid serverId, EndPoint serverHttpEndPoint, int view, DateTime deadline) { var request = new PrepareRequest { ServerId = Uuid.FromGuid(serverId).ToDto(), ServerHttp = new GossipEndPoint(serverHttpEndPoint.GetHost(), (uint)serverHttpEndPoint.GetPort()), View = view }; await _electionsClient.PrepareAsync(request, deadline : deadline.ToUniversalTime()); }
public void OnPrepareRequestReceived(ConsensusPayload payload, PrepareRequest request) { if (!_consensus.TryGetValue(ConsensusMessageType.PrepareRequest, out var state)) { state = new ConsensusPhaseStat(); } state.Add(payload); }
private async Task SendPrepareAsync(Guid serverId, IPEndPoint serverInternalHttp, int view, DateTime deadline) { var request = new PrepareRequest { ServerId = Uuid.FromGuid(serverId).ToDto(), ServerInternalHttp = new EndPoint(serverInternalHttp.Address.ToString(), (uint)serverInternalHttp.Port), View = view }; await _electionsClient.PrepareAsync(request, deadline : deadline.ToUniversalTime()); }
public virtual Task <PrepareResponse> ReceivePrepareRequestAsync(PrepareRequest request) { if (request.Proposal.Number > PromisedProposalNumber) { _promisedProposal.Value = request.Proposal; return(Task.FromResult(new PrepareResponse(true, PromisedProposal))); } return(Task.FromResult(new PrepareResponse(false, PromisedProposal))); }
public async Task <ActionResult <StringResult> > Prepare([FromBody] PrepareRequest request) { if (!await _configRepository.IsNeedInstallAsync()) { return(Unauthorized()); } var(success, errorMessage) = await _administratorRepository.InsertValidateAsync(request.UserName, request.AdminPassword, request.Email, request.Mobile); if (!success) { return(this.Error(errorMessage)); } if (_settingsManager.Containerized) { if (_settingsManager.DatabaseType == DatabaseType.SQLite) { var filePath = PathUtils.Combine(_settingsManager.ContentRootPath, Constants.LocalDbContainerVirtualPath.Substring(1)); if (!FileUtils.IsFileExists(filePath)) { await FileUtils.WriteTextAsync(filePath, string.Empty); } } } else { if (request.DatabaseType == DatabaseType.SQLite) { var filePath = PathUtils.Combine(_settingsManager.ContentRootPath, Constants.LocalDbHostVirtualPath.Substring(1)); if (!FileUtils.IsFileExists(filePath)) { await FileUtils.WriteTextAsync(filePath, string.Empty); } } var databaseConnectionString = InstallUtils.GetDatabaseConnectionString(request.DatabaseType, request.DatabaseHost, request.IsDatabaseDefaultPort, TranslateUtils.ToInt(request.DatabasePort), request.DatabaseUserName, request.DatabasePassword, request.DatabaseName); var redisConnectionString = string.Empty; if (request.IsRedis) { redisConnectionString = InstallUtils.GetRedisConnectionString(request.RedisHost, request.IsRedisDefaultPort, request.RedisPort, request.IsSsl, request.RedisPassword); } _settingsManager.SaveSettings(request.IsProtectData, false, false, request.DatabaseType, databaseConnectionString, redisConnectionString, string.Empty, null, null); } return(new StringResult { Value = _settingsManager.SecurityKey }); }
public void PrepareQuery() { using (var connection = CreateConnection()) { connection.Init(); var request = new PrepareRequest(connection.ProtocolVersion, "SELECT * FROM system.schema_keyspaces"); var task = connection.Send(request); task.Wait(); Assert.AreEqual(TaskStatus.RanToCompletion, task.Status); var output = ValidateResult <OutputPrepared>(task.Result); } }
public void Prepare_Query() { using (var connection = CreateConnection()) { connection.Open().Wait(); var request = new PrepareRequest(BasicQuery); var task = connection.Send(request); task.Wait(); Assert.AreEqual(TaskStatus.RanToCompletion, task.Status); ValidateResult <OutputPrepared>(task.Result); } }
/// <inheritdoc /> public async Task <PreparedStatement> PrepareAsync(string query, IDictionary <string, byte[]> customPayload) { var request = new PrepareRequest(query) { Payload = customPayload }; var handler = new RequestHandler <PreparedStatement>(this, _serializer, request); var ps = await handler.Send().ConfigureAwait(false); await SetPrepareTableInfo(ps).ConfigureAwait(false); return(ps); }
public void Prepare_With_Keyspace_On_Lower_Protocol_Version_Should_Ignore_Keyspace() { const string query = "SELECT col1, col2 FROM table1"; var serializer = new SerializerManager(ProtocolVersion.V2).GetCurrentSerializer(); var request = new PrepareRequest(serializer, query, "my_keyspace", null); // The request only contains the query var buffer = GetBodyBuffer(request, serializer); var queryLength = BeConverter.ToInt32(buffer); Assert.AreEqual(query.Length, queryLength); Assert.AreEqual(4 + queryLength, buffer.Length); }
public override async Task <Empty> Prepare(PrepareRequest request, ServerCallContext context) { var user = context.GetHttpContext().User; if (!await _authorizationProvider.CheckAccessAsync(user, PrepareOperation, context.CancellationToken).ConfigureAwait(false)) { throw AccessDenied(); } _bus.Publish(new ElectionMessage.Prepare( Uuid.FromDto(request.ServerId).ToGuid(), new IPEndPoint(IPAddress.Parse(request.ServerInternalHttp.Address), (int)request.ServerInternalHttp.Port), request.View)); return(EmptyResult); }
public void PrepareResponseErrorFaultsTask() { using (var connection = CreateConnection()) { connection.Init(); var request = new PrepareRequest(connection.ProtocolVersion, "SELECT WILL FAIL"); var task = connection.Send(request); task.ContinueWith(t => { Assert.AreEqual(TaskStatus.Faulted, t.Status); Assert.IsInstanceOf <SyntaxError>(t.Exception.InnerException); }, TaskContinuationOptions.ExecuteSynchronously).Wait(); } }
public void Prepare_ResponseError_Faults_Task() { using (var connection = CreateConnection()) { connection.Open().Wait(); var request = new PrepareRequest(GetSerializer(), "SELECT WILL FAIL", null, null); var task = connection.Send(request); task.ContinueWith(t => { Assert.AreEqual(TaskStatus.Faulted, t.Status); Assert.NotNull(t.Exception); Assert.IsInstanceOf <SyntaxError>(t.Exception.InnerException); }, TaskContinuationOptions.ExecuteSynchronously).Wait(); } }
public PrepareResponse Packet_Prepare(PrepareRequest req) { if (!_blender.TryPrepare(req.Version)) { return new PrepareResponse() { Message = $"Failed to prepare version {req.Version}", Success = false } } ; return(new PrepareResponse() { Success = true }); }
/// <summary> /// Runs proxy forwarding requests to downstream server. /// </summary> /// <param name="app"> /// The application builder. /// </param> /// <param name="handleProxyRequest"> /// A delegate that can resolve the destination Uri. /// </param> /// <param name="prepareRequest"> /// A delegate to allow modification of the request prior to /// forwarding. /// </param> public static void RunProxy( this IApplicationBuilder app, HandleProxyRequest handleProxyRequest, PrepareRequest prepareRequest = null) { if (app == null) { throw new ArgumentNullException(nameof(app)); } var proxyOptions = new ProxyOptions { HandleProxyRequest = handleProxyRequest, PrepareRequest = prepareRequest }; app.UseMiddleware <ProxyMiddleware>(proxyOptions); }
public void Execute_Prepared_Test() { using (var connection = CreateConnection()) { connection.Open().Wait(); //Prepare a query var prepareRequest = new PrepareRequest("SELECT * FROM system.local"); var task = connection.Send(prepareRequest); var prepareOutput = ValidateResult <OutputPrepared>(task.Result); //Execute the prepared query var executeRequest = new ExecuteRequest(GetLatestProtocolVersion(), prepareOutput.QueryId, null, false, QueryProtocolOptions.Default); task = connection.Send(executeRequest); var output = ValidateResult <OutputRows>(task.Result); var rs = output.RowSet; var rows = rs.ToList(); Assert.Greater(rows.Count, 0); Assert.True(rows[0].GetValue <string>("key") != null, "It should contain a key column"); } }
public void ExecutePreparedTest() { using (var connection = CreateConnection()) { connection.Init(); //Prepare a query var prepareRequest = new PrepareRequest(connection.ProtocolVersion, "SELECT * FROM system.schema_keyspaces"); var task = connection.Send(prepareRequest); var prepareOutput = ValidateResult <OutputPrepared>(task.Result); //Execute the prepared query var executeRequest = new ExecuteRequest(connection.ProtocolVersion, prepareOutput.QueryId, null, false, QueryProtocolOptions.Default); task = connection.Send(executeRequest); var output = ValidateResult <OutputRows>(task.Result); var rs = output.RowSet; var rows = rs.ToList(); Assert.Greater(rows.Count, 0); Assert.True(rows[0].GetValue <string>("keyspace_name") != null, "It should contain a keyspace name"); } }
public void ExecutePreparedWithParamTest() { using (var connection = CreateConnection()) { connection.Init(); var prepareRequest = new PrepareRequest(connection.ProtocolVersion, "SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = ?"); var task = connection.Send(prepareRequest); var prepareOutput = ValidateResult <OutputPrepared>(task.Result); var options = new QueryProtocolOptions(ConsistencyLevel.One, new[] { "system" }, false, 100, null, ConsistencyLevel.Any); var executeRequest = new ExecuteRequest(connection.ProtocolVersion, prepareOutput.QueryId, null, false, options); task = connection.Send(executeRequest); var output = ValidateResult <OutputRows>(task.Result); var rows = output.RowSet.ToList(); Assert.Greater(rows.Count, 0); Assert.True(rows[0].GetValue <string>("columnfamily_name") != null, "It should contain a column family name"); } }
public void Reset() { ResetComponents(); _onStarting = null; _onCompleted = null; _responseStarted = false; _keepAlive = false; _autoChunk = false; _applicationException = null; ResetFeatureCollection(); Scheme = null; Method = null; RequestUri = null; PathBase = null; Path = null; QueryString = null; _httpVersion = HttpVersionType.Unknown; StatusCode = 200; ReasonPhrase = null; var httpConnectionFeature = this as IHttpConnectionFeature; httpConnectionFeature.RemoteIpAddress = RemoteEndPoint?.Address; httpConnectionFeature.RemotePort = RemoteEndPoint?.Port ?? 0; httpConnectionFeature.LocalIpAddress = LocalEndPoint?.Address; httpConnectionFeature.LocalPort = LocalEndPoint?.Port ?? 0; httpConnectionFeature.ConnectionId = ConnectionId; PrepareRequest?.Invoke(this); _manuallySetRequestAbortToken = null; _abortedCts = null; }
public void Prepare_With_Keyspace_Should_Send_Keyspace_And_Flag() { const string query = "QUERY1"; const string keyspace = "ks1"; var request = new PrepareRequest(RequestHandlerTests.Serializer, query, keyspace, null); // The request is composed by: <query><flags>[<keyspace>] var buffer = GetBodyBuffer(request); var queryLength = BeConverter.ToInt32(buffer); Assert.AreEqual(query.Length, queryLength); var offset = 4 + queryLength; var flags = (PrepareFlags)BeConverter.ToInt32(buffer, offset); offset += 4; Assert.True(flags.HasFlag(PrepareFlags.WithKeyspace)); var keyspaceLength = BeConverter.ToInt16(buffer, offset); offset += 2; Assert.AreEqual(keyspace.Length, keyspaceLength); Assert.AreEqual(keyspace, Encoding.UTF8.GetString(buffer.Skip(offset).Take(keyspaceLength).ToArray())); }
public async Task NewAcceptor_ReceivePrepareRequest_Promised() { var acceptor = new Acceptor <string>("sample-acceptor"); var proposal = new Proposal <string>(1, "192.168.0.1"); var request = new PrepareRequest(proposal); var response = await acceptor.ReceivePrepareRequestAsync(request) .ConfigureAwait(false); Assert.NotNull(response); Assert.True(response.Promised); Assert.NotNull(response.AcceptedProposal); Assert.IsType <Proposal <string> >(response.AcceptedProposal); Assert.IsNotType <Proposal <object> >(response.AcceptedProposal); Assert.IsNotType <Proposal <int> >(response.AcceptedProposal); Assert.Equal(proposal, response.AcceptedProposal); Assert.Equal(1, acceptor.PromisedProposalNumber); Assert.NotNull(acceptor.PromisedProposal.As <Proposal <string> >()); Assert.Equal("192.168.0.1", acceptor.PromisedProposal.As <Proposal <string> >() !.Value); Assert.Equal($"sample-acceptor: Proposal {{ Number = 1, Value = 192.168.0.1 }}", acceptor.ToString()); }
/// <summary> /// This request is used to create create a new Statement with the given query in the Phoenix query server. /// </summary> public async Task <PrepareResponse> PrepareRequestAsync(string connectionId, string sql, long maxRowsTotal, RequestOptions options) { PrepareRequest req = new PrepareRequest { ConnectionId = connectionId, Sql = sql, MaxRowsTotal = maxRowsTotal }; WireMessage msg = new WireMessage { Name = Constants.WireMessagePrefix + "PrepareRequest", WrappedMessage = req.ToByteString() }; using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options)) { if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK) { WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream()); ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage); throw new WebException( string.Format( "PrepareRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}", connectionId, webResponse.WebResponse.StatusCode, res.ToString())); } else { WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream()); PrepareResponse res = PrepareResponse.Parser.ParseFrom(output.WrappedMessage); return(res); } } }
public void Reset() { FrameRequestHeaders?.Reset(); FrameResponseHeaders?.Reset(); _onStarting = null; _onCompleted = null; _requestProcessingStatus = RequestProcessingStatus.RequestPending; _keepAlive = false; _autoChunk = false; _applicationException = null; ResetFeatureCollection(); Scheme = null; Method = null; PathBase = null; Path = null; QueryString = null; _httpVersion = HttpVersionType.Unset; StatusCode = 200; ReasonPhrase = null; RemoteIpAddress = RemoteEndPoint?.Address; RemotePort = RemoteEndPoint?.Port ?? 0; LocalIpAddress = LocalEndPoint?.Address; LocalPort = LocalEndPoint?.Port ?? 0; ConnectionIdFeature = ConnectionId; PrepareRequest?.Invoke(this); _manuallySetRequestAbortToken = null; _abortedCts = null; }
public void ConsensusService_Primary_Sends_PrepareRequest_After_OnStart() { TestProbe subscriber = CreateTestProbe(); var mockConsensusContext = new Mock <IConsensusContext>(); var mockStore = new Mock <Store>(); // context.Reset(): do nothing //mockConsensusContext.Setup(mr => mr.Reset()).Verifiable(); // void mockConsensusContext.SetupGet(mr => mr.MyIndex).Returns(2); // MyIndex == 2 mockConsensusContext.SetupGet(mr => mr.BlockIndex).Returns(2); mockConsensusContext.SetupGet(mr => mr.PrimaryIndex).Returns(2); mockConsensusContext.SetupGet(mr => mr.ViewNumber).Returns(0); mockConsensusContext.SetupProperty(mr => mr.Nonce); mockConsensusContext.SetupProperty(mr => mr.NextConsensus); mockConsensusContext.Object.NextConsensus = UInt160.Zero; mockConsensusContext.SetupGet(mr => mr.PreparationPayloads).Returns(new ConsensusPayload[7]); mockConsensusContext.SetupGet(mr => mr.CommitPayloads).Returns(new ConsensusPayload[7]); int timeIndex = 0; var timeValues = new[] { //new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc), // For tests here new DateTime(1968, 06, 01, 0, 0, 1, DateTimeKind.Utc), // For receiving block new DateTime(1968, 06, 01, 0, 0, (int)Blockchain.SecondsPerBlock, DateTimeKind.Utc), // For Initialize new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc), // unused new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc) // unused }; //TimeProvider.Current.UtcNow.ToTimestamp().Should().Be(4244941711); //1968-06-01 00:00:15 Console.WriteLine($"time 0: {timeValues[0].ToString()} 1: {timeValues[1].ToString()} 2: {timeValues[2].ToString()} 3: {timeValues[3].ToString()}"); //mockConsensusContext.Object.block_received_time = new DateTime(1968, 06, 01, 0, 0, 1, DateTimeKind.Utc); //mockConsensusContext.Setup(mr => mr.GetUtcNow()).Returns(new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc)); var timeMock = new Mock <TimeProvider>(); timeMock.SetupGet(tp => tp.UtcNow).Returns(() => timeValues[timeIndex]) .Callback(() => timeIndex++); //new DateTime(1968, 06, 01, 0, 0, 15, DateTimeKind.Utc)); TimeProvider.Current = timeMock.Object; //public void Log(string message, LogLevel level) // TODO: create ILogPlugin for Tests /* * mockConsensusContext.Setup(mr => mr.Log(It.IsAny<string>(), It.IsAny<LogLevel>())) * .Callback((string message, LogLevel level) => { * Console.WriteLine($"CONSENSUS LOG: {message}"); * } * ); */ // Creating proposed block Header header = new Header(); TestUtils.SetupHeaderWithValues(header, UInt256.Zero, out UInt256 merkRootVal, out UInt160 val160, out uint timestampVal, out uint indexVal, out ulong consensusDataVal, out Witness scriptVal); header.Size.Should().Be(109); Console.WriteLine($"header {header} hash {header.Hash} timstamp {timestampVal}"); timestampVal.Should().Be(4244941696); //1968-06-01 00:00:00 // check basic ConsensusContext mockConsensusContext.Object.MyIndex.Should().Be(2); //mockConsensusContext.Object.block_received_time.ToTimestamp().Should().Be(4244941697); //1968-06-01 00:00:01 MinerTransaction minerTx = new MinerTransaction { Attributes = new TransactionAttribute[0], Inputs = new CoinReference[0], Outputs = new TransactionOutput[0], Witnesses = new Witness[0], Nonce = 42 }; PrepareRequest prep = new PrepareRequest { Nonce = mockConsensusContext.Object.Nonce, NextConsensus = mockConsensusContext.Object.NextConsensus, TransactionHashes = new UInt256[0], MinerTransaction = minerTx //(MinerTransaction)Transactions[TransactionHashes[0]], }; ConsensusPayload prepPayload = new ConsensusPayload { Version = 0, PrevHash = mockConsensusContext.Object.PrevHash, BlockIndex = mockConsensusContext.Object.BlockIndex, ValidatorIndex = (ushort)mockConsensusContext.Object.MyIndex, ConsensusMessage = prep }; mockConsensusContext.Setup(mr => mr.MakePrepareRequest()).Returns(prepPayload); // ============================================================================ // creating ConsensusService actor // ============================================================================ TestActorRef <ConsensusService> actorConsensus = ActorOfAsTestActorRef <ConsensusService>( Akka.Actor.Props.Create(() => new ConsensusService(subscriber, subscriber, mockConsensusContext.Object)) ); Console.WriteLine("will trigger OnPersistCompleted!"); actorConsensus.Tell(new Blockchain.PersistCompleted { Block = new Block { Version = header.Version, PrevHash = header.PrevHash, MerkleRoot = header.MerkleRoot, Timestamp = header.Timestamp, Index = header.Index, ConsensusData = header.ConsensusData, NextConsensus = header.NextConsensus } }); // OnPersist will not launch timer, we need OnStart Console.WriteLine("will start consensus!"); actorConsensus.Tell(new ConsensusService.Start()); Console.WriteLine("OnTimer should expire!"); Console.WriteLine("Waiting for subscriber message!"); // Timer should expire in one second (block_received_time at :01, initialized at :02) var answer = subscriber.ExpectMsg <LocalNode.SendDirectly>(); Console.WriteLine($"MESSAGE 1: {answer}"); //var answer2 = subscriber.ExpectMsg<LocalNode.SendDirectly>(); // expects to fail! // ============================================================================ // finalize ConsensusService actor // ============================================================================ //Thread.Sleep(4000); Sys.Stop(actorConsensus); TimeProvider.ResetToDefault(); Assert.AreEqual(1, 1); }
public void TestSerializeAndDeserializeConsensusContext() { var consensusContext = new ConsensusContext(null, null) { Block = new Block { PrevHash = Blockchain.GenesisBlock.Hash, Index = 1, Timestamp = 4244941711, NextConsensus = UInt160.Parse("5555AAAA5555AAAA5555AAAA5555AAAA5555AAAA"), ConsensusData = new ConsensusData { PrimaryIndex = 6 } }, ViewNumber = 2, Validators = new ECPoint[7] { ECPoint.Parse("02486fd15702c4490a26703112a5cc1d0923fd697a33406bd5a1c00e0013b09a70", Cryptography.ECC.ECCurve.Secp256r1), ECPoint.Parse("024c7b7fb6c310fccf1ba33b082519d82964ea93868d676662d4a59ad548df0e7d", Cryptography.ECC.ECCurve.Secp256r1), ECPoint.Parse("02aaec38470f6aad0042c6e877cfd8087d2676b0f516fddd362801b9bd3936399e", Cryptography.ECC.ECCurve.Secp256r1), ECPoint.Parse("02ca0e27697b9c248f6f16e085fd0061e26f44da85b58ee835c110caa5ec3ba554", Cryptography.ECC.ECCurve.Secp256r1), ECPoint.Parse("02df48f60e8f3e01c48ff40b9b7f1310d7a8b2a193188befe1c2e3df740e895093", Cryptography.ECC.ECCurve.Secp256r1), ECPoint.Parse("03b209fd4f53a7170ea4444e0cb0a6bb6a53c2bd016926989cf85f9b0fba17a70c", Cryptography.ECC.ECCurve.Secp256r1), ECPoint.Parse("03b8d9d5771d8f513aa0869b9cc8d50986403b78c6da36890638c3d46a5adce04a", Cryptography.ECC.ECCurve.Secp256r1) }, MyIndex = -1 }; var testTx1 = TestUtils.CreateRandomHashTransaction(); var testTx2 = TestUtils.CreateRandomHashTransaction(); int txCountToInlcude = 256; consensusContext.TransactionHashes = new UInt256[txCountToInlcude]; Transaction[] txs = new Transaction[txCountToInlcude]; for (int i = 0; i < txCountToInlcude; i++) { txs[i] = TestUtils.CreateRandomHashTransaction(); consensusContext.TransactionHashes[i] = txs[i].Hash; } // consensusContext.TransactionHashes = new UInt256[2] {testTx1.Hash, testTx2.Hash}; consensusContext.Transactions = txs.ToDictionary(p => p.Hash); consensusContext.PreparationPayloads = new ConsensusPayload[consensusContext.Validators.Length]; var prepareRequestMessage = new PrepareRequest { TransactionHashes = consensusContext.TransactionHashes, Timestamp = 23 }; consensusContext.PreparationPayloads[6] = MakeSignedPayload(consensusContext, prepareRequestMessage, 6, new[] { (byte)'3', (byte)'!' }); consensusContext.PreparationPayloads[0] = MakeSignedPayload(consensusContext, new PrepareResponse { PreparationHash = consensusContext.PreparationPayloads[6].Hash }, 0, new[] { (byte)'t', (byte)'e' }); consensusContext.PreparationPayloads[1] = MakeSignedPayload(consensusContext, new PrepareResponse { PreparationHash = consensusContext.PreparationPayloads[6].Hash }, 1, new[] { (byte)'s', (byte)'t' }); consensusContext.PreparationPayloads[2] = null; consensusContext.PreparationPayloads[3] = MakeSignedPayload(consensusContext, new PrepareResponse { PreparationHash = consensusContext.PreparationPayloads[6].Hash }, 3, new[] { (byte)'1', (byte)'2' }); consensusContext.PreparationPayloads[4] = null; consensusContext.PreparationPayloads[5] = null; consensusContext.CommitPayloads = new ConsensusPayload[consensusContext.Validators.Length]; using (SHA256 sha256 = SHA256.Create()) { consensusContext.CommitPayloads[3] = MakeSignedPayload(consensusContext, new Commit { Signature = sha256.ComputeHash(testTx1.Hash.ToArray()) }, 3, new[] { (byte)'3', (byte)'4' }); consensusContext.CommitPayloads[6] = MakeSignedPayload(consensusContext, new Commit { Signature = sha256.ComputeHash(testTx2.Hash.ToArray()) }, 3, new[] { (byte)'6', (byte)'7' }); } consensusContext.Block.Timestamp = TimeProvider.Current.UtcNow.ToTimestamp(); consensusContext.ChangeViewPayloads = new ConsensusPayload[consensusContext.Validators.Length]; consensusContext.ChangeViewPayloads[0] = MakeSignedPayload(consensusContext, new ChangeView { ViewNumber = 1, Timestamp = 6 }, 0, new[] { (byte)'A' }); consensusContext.ChangeViewPayloads[1] = MakeSignedPayload(consensusContext, new ChangeView { ViewNumber = 1, Timestamp = 5 }, 1, new[] { (byte)'B' }); consensusContext.ChangeViewPayloads[2] = null; consensusContext.ChangeViewPayloads[3] = MakeSignedPayload(consensusContext, new ChangeView { ViewNumber = 1, Timestamp = uint.MaxValue }, 3, new[] { (byte)'C' }); consensusContext.ChangeViewPayloads[4] = null; consensusContext.ChangeViewPayloads[5] = null; consensusContext.ChangeViewPayloads[6] = MakeSignedPayload(consensusContext, new ChangeView { ViewNumber = 1, Timestamp = 1 }, 6, new[] { (byte)'D' }); consensusContext.LastChangeViewPayloads = new ConsensusPayload[consensusContext.Validators.Length]; var copiedContext = TestUtils.CopyMsgBySerialization(consensusContext, new ConsensusContext(null, null)); copiedContext.Block.PrevHash.Should().Be(consensusContext.Block.PrevHash); copiedContext.Block.Index.Should().Be(consensusContext.Block.Index); copiedContext.ViewNumber.Should().Be(consensusContext.ViewNumber); copiedContext.Validators.ShouldAllBeEquivalentTo(consensusContext.Validators); copiedContext.MyIndex.Should().Be(consensusContext.MyIndex); copiedContext.Block.ConsensusData.PrimaryIndex.Should().Be(consensusContext.Block.ConsensusData.PrimaryIndex); copiedContext.Block.Timestamp.Should().Be(consensusContext.Block.Timestamp); copiedContext.Block.NextConsensus.Should().Be(consensusContext.Block.NextConsensus); copiedContext.TransactionHashes.ShouldAllBeEquivalentTo(consensusContext.TransactionHashes); copiedContext.Transactions.ShouldAllBeEquivalentTo(consensusContext.Transactions); copiedContext.Transactions.Values.ShouldAllBeEquivalentTo(consensusContext.Transactions.Values); copiedContext.PreparationPayloads.ShouldAllBeEquivalentTo(consensusContext.PreparationPayloads); copiedContext.CommitPayloads.ShouldAllBeEquivalentTo(consensusContext.CommitPayloads); copiedContext.ChangeViewPayloads.ShouldAllBeEquivalentTo(consensusContext.ChangeViewPayloads); }
/// <inheritdoc /> public Task<PreparedStatement> PrepareAsync(string query, IDictionary<string, byte[]> customPayload) { var request = new PrepareRequest(query) { Payload = customPayload }; return new RequestHandler<PreparedStatement>(this, _serializer, request) .Send() .Then(SetPrepareTableInfo); }
public Task<PreparedStatement> PrepareAsync(string query, IDictionary<string, byte[]> customPayload) { var request = new PrepareRequest(BinaryProtocolVersion, query) { Payload = customPayload }; return new RequestHandler<PreparedStatement>(this, request) .Send() .Continue(SetPrepareTableInfo); }
private async Task <object> InvokeCore(HttpServiceRequest request, Type resultReturnType, JsonSerializerSettings jsonSettings) { if (request == null) { throw new ArgumentNullException(nameof(request)); } request.TracingData = new TracingData { HostName = CurrentApplicationInfo.HostName?.ToUpperInvariant(), ServiceName = CurrentApplicationInfo.Name, RequestID = TracingContext.TryGetRequestID(), SpanID = Guid.NewGuid().ToString("N"), //Each call is new span ParentSpanID = TracingContext.TryGetSpanID(), SpanStartTime = DateTimeOffset.UtcNow, AbandonRequestBy = TracingContext.AbandonRequestBy }; PrepareRequest?.Invoke(request); while (true) { var config = GetConfig(); var clientCallEvent = EventPublisher.CreateEvent(); clientCallEvent.TargetService = ServiceName; clientCallEvent.RequestId = request.TracingData?.RequestID; clientCallEvent.TargetMethod = request.Target.MethodName; clientCallEvent.SpanId = request.TracingData?.SpanID; clientCallEvent.ParentSpanId = request.TracingData?.ParentSpanID; string responseContent; HttpResponseMessage response; var nodeAndLoadBalancer = await ServiceDiscovery.GetNode().ConfigureAwait(false); // can throw int?effectivePort = GetEffectivePort(nodeAndLoadBalancer.Node, config); if (effectivePort == null) { throw new ConfigurationException("Cannot access service. Service Port not configured. See tags to find missing configuration", unencrypted: new Tags { { "ServiceName", ServiceName }, { "Required configuration key", $"Discovery.{ServiceName}.DefaultPort" } }); } // The URL is only for a nice experience in Fiddler, it's never parsed/used for anything. var uri = BuildUri(nodeAndLoadBalancer.Node.Hostname, effectivePort.Value, config) + ServiceName; if (request.Target.MethodName != null) { uri += $".{request.Target.MethodName}"; } if (request.Target.Endpoint != null) { uri += $"/{request.Target.Endpoint}"; } try { Log.Debug(_ => _("ServiceProxy: Calling remote service. See tags for details.", unencryptedTags: new { remoteEndpoint = nodeAndLoadBalancer.Node.Hostname, remotePort = effectivePort, remoteServiceName = ServiceName, remoteMethodName = request.Target.MethodName })); clientCallEvent.TargetHostName = nodeAndLoadBalancer.Node.Hostname; clientCallEvent.TargetPort = effectivePort.Value; request.Overrides = TracingContext.TryGetOverrides()?.ShallowCloneWithDifferentPreferredEnvironment(nodeAndLoadBalancer.PreferredEnvironment) ?? new RequestOverrides { PreferredEnvironment = nodeAndLoadBalancer.PreferredEnvironment }; string requestContent = _serializationTime.Time(() => JsonConvert.SerializeObject(request, jsonSettings)); var httpContent = new StringContent(requestContent, Encoding.UTF8, "application/json"); httpContent.Headers.Add(GigyaHttpHeaders.ProtocolVersion, HttpServiceRequest.ProtocolVersion); clientCallEvent.RequestStartTimestamp = Stopwatch.GetTimestamp(); try { response = await GetHttpClient(config).PostAsync(uri, httpContent).ConfigureAwait(false); responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false); } finally { clientCallEvent.ResponseEndTimestamp = Stopwatch.GetTimestamp(); } if (response.Headers.TryGetValues(GigyaHttpHeaders.ExecutionTime, out IEnumerable <string> values)) { var time = values.FirstOrDefault(); if (TimeSpan.TryParse(time, out TimeSpan executionTime)) { clientCallEvent.ServerTimeMs = executionTime.TotalMilliseconds; } } } catch (HttpRequestException ex) { Log.Error("The remote service failed to return a valid HTTP response. Continuing to next " + "host. See tags for URL and exception for details.", exception: ex, unencryptedTags: new { uri }); _hostFailureCounter.Increment("RequestFailure"); clientCallEvent.Exception = ex; EventPublisher.TryPublish(clientCallEvent); // fire and forget! if (nodeAndLoadBalancer.LoadBalancer != null) { nodeAndLoadBalancer.LoadBalancer.ReportUnreachable(nodeAndLoadBalancer.Node, ex); continue; } throw; } catch (TaskCanceledException ex) { _failureCounter.Increment("RequestTimeout"); Exception rex = new RemoteServiceException("The request to the remote service exceeded the " + "allotted timeout. See the 'RequestUri' property on this exception for the URL that was " + "called and the tag 'requestTimeout' for the configured timeout.", uri, ex, unencrypted: new Tags { { "requestTimeout", LastHttpClient?.Timeout.ToString() }, { "requestUri", uri } }); clientCallEvent.Exception = rex; EventPublisher.TryPublish(clientCallEvent); // fire and forget! throw rex; } if (response.Headers.Contains(GigyaHttpHeaders.ServerHostname) || response.Headers.Contains(GigyaHttpHeaders.ProtocolVersion)) { try { if (response.IsSuccessStatusCode) { var returnObj = _deserializationTime.Time(() => JsonConvert.DeserializeObject(responseContent, resultReturnType, jsonSettings)); clientCallEvent.ErrCode = 0; EventPublisher.TryPublish(clientCallEvent); // fire and forget! _successCounter.Increment(); return(returnObj); } else { Exception remoteException; try { remoteException = _deserializationTime.Time(() => ExceptionSerializer.Deserialize(responseContent)); } catch (Exception ex) { _applicationExceptionCounter.Increment("ExceptionDeserializationFailure"); throw new RemoteServiceException("The remote service returned a failure response " + "that failed to deserialize. See the 'RequestUri' property on this exception " + "for the URL that was called, the inner exception for the exact error and the " + "'responseContent' encrypted tag for the original response content.", uri, ex, unencrypted: new Tags { { "requestUri", uri } }, encrypted: new Tags { { "responseContent", responseContent } }); } _applicationExceptionCounter.Increment(); clientCallEvent.Exception = remoteException; EventPublisher.TryPublish(clientCallEvent); // fire and forget! if (remoteException is RequestException || remoteException is EnvironmentException) { ExceptionDispatchInfo.Capture(remoteException).Throw(); } if (remoteException is UnhandledException) { remoteException = remoteException.InnerException; } throw new RemoteServiceException("The remote service returned a failure response. See " + "the 'RequestUri' property on this exception for the URL that was called, and the " + "inner exception for details.", uri, remoteException, unencrypted: new Tags { { "requestUri", uri } }); } } catch (JsonException ex) { _failureCounter.Increment("Serialization"); Log.Error("The remote service returned a response with JSON that failed " + "deserialization. See the 'uri' tag for the URL that was called, the exception for the " + "exact error and the 'responseContent' encrypted tag for the original response content.", exception: ex, unencryptedTags: new { uri }, encryptedTags: new { responseContent }); clientCallEvent.Exception = ex; EventPublisher.TryPublish(clientCallEvent); // fire and forget! throw new RemoteServiceException("The remote service returned a response with JSON that " + "failed deserialization. See the 'RequestUri' property on this exception for the URL " + "that was called, the inner exception for the exact error and the 'responseContent' " + "encrypted tag for the original response content.", uri, ex, new Tags { { "responseContent", responseContent } }, new Tags { { "requestUri", uri } }); } } else { var exception = response.StatusCode == HttpStatusCode.ServiceUnavailable ? new Exception($"The remote service is unavailable (503) and is not recognized as a Gigya host at uri: {uri}") : new Exception($"The remote service returned a response but is not recognized as a Gigya host at uri: {uri}"); nodeAndLoadBalancer.LoadBalancer.ReportUnreachable(nodeAndLoadBalancer.Node, exception); _hostFailureCounter.Increment("NotGigyaHost"); if (response.StatusCode == HttpStatusCode.ServiceUnavailable) { Log.Error("The remote service is unavailable (503) and is not recognized as a Gigya host. Continuing to next host.", unencryptedTags: new { uri }); } else { Log.Error("The remote service returned a response but is not recognized as a Gigya host. Continuing to next host.", unencryptedTags: new { uri, statusCode = response.StatusCode }, encryptedTags: new { responseContent }); } clientCallEvent.ErrCode = 500001; //(int)GSErrors.General_Server_Error; EventPublisher.TryPublish(clientCallEvent); // fire and forget! } } }
/// <summary> /// This request is used to create create a new Statement with the given query in the Phoenix query server. /// </summary> public async Task<PrepareResponse> PrepareRequestAsync(string connectionId, string sql, long maxRowsTotal, RequestOptions options) { PrepareRequest req = new PrepareRequest { ConnectionId = connectionId, Sql = sql, MaxRowsTotal = maxRowsTotal }; WireMessage msg = new WireMessage { Name = Constants.WireMessagePrefix + "PrepareRequest", WrappedMessage = req.ToByteString() }; using (Response webResponse = await PostRequestAsync(msg.ToByteArray(), options)) { if (webResponse.WebResponse.StatusCode != HttpStatusCode.OK) { WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream()); ErrorResponse res = ErrorResponse.Parser.ParseFrom(output.WrappedMessage); throw new WebException( string.Format( "PrepareRequestAsync failed! connectionId: {0}, Response code was: {1}, Response body was: {2}", connectionId, webResponse.WebResponse.StatusCode, res.ToString())); } else { WireMessage output = WireMessage.Parser.ParseFrom(webResponse.WebResponse.GetResponseStream()); PrepareResponse res = PrepareResponse.Parser.ParseFrom(output.WrappedMessage); return res; } } }