public IvxrPluginContext(PluginConfig config) { var seLog = new SeLog( Assembly.GetExecutingAssembly().GetName().Version.ToString(), "ivxr-plugin", alwaysFlush: true ); Log = seLog; ContinuousMovementController = new ContinuousMovementController(seLog, m_gameSession); var se = new RealSpaceEngineers(m_gameSession, Log, config); MethodCallContext = new MethodCallContext(Log); JsonRpcStarter = new JsonRpcStarter( new SynchronizedSpaceEngineers(se, MethodCallContext), hostname: config.Hostname, port: config.JsonRpcPort ) { Log = Log }; }
public async Task HandleAsync(IncomingInvocationDescriptor info, ITransportChannel channel) { var invocation = _incomingInvocationFactory.CreateAsync <TRequest, TResponse>(info, channel); var cancellation = new CancellationTokenSource(); invocation.Completion .ContinueWithSynchronously(_ => cancellation.Cancel(), CancellationToken.None) .IgnoreAwait(); try { await invocation.StartCompletion.ConfigureAwait(false); var context = new MethodCallContext( info.Source.ApplicationId, info.Source.ApplicationInstanceId, info.Source.ConnectionId, cancellation.Token); await HandleCoreAsync(invocation, context).ConfigureAwait(false); invocation.Out.TryComplete(); } catch (Exception ex) { invocation.Out.TryTerminate(ex); invocation.In.ConsumeBufferedItems(x => { }); throw; } finally { await invocation.Completion.ConfigureAwait(false); } }
public Task <UniqueId> RequestInstanceId(RequestInstanceIdRequest request, MethodCallContext context) { var appInstanceId = Plexus.UniqueId.Generate(); RegisterInstanceId(appInstanceId); return(Task.FromResult(appInstanceId.ToProto())); }
protected override void PreProcess(MethodCallContext ctx) { base.PreProcess(ctx); Type type = m_InterceptedObject.GetType(); MethodBase method = ctx.CallMessage.MethodBase; try { AutoCompleteAttribute auto = method.GetSingleAttribute<AutoCompleteAttribute>(); _txParticipant = (auto != null); if (_txParticipant) { TransactionAttribute tx = type.GetSingleAttribute<TransactionAttribute>(); if (tx == null) ContainerExceptionHelper.ThrowComponentTransactionNotDefine(type, method); TransactionOptions txOptions = new TransactionOptions(); txOptions.IsolationLevel = tx.TxIsolationLevel; _txScope = new TransactionScope(tx.Option, txOptions); _log.Info("Transaction [{0}] started on [{1}.{2}].", Transaction.Current.TransactionInformation, type.Name, method.Name); } } catch (Exception ex) { _log.Error("Transaction failed to start on [{1}.{2}]. [{0}]", ex.ToString(), type.Name, method.Name); throw; } }
public override void DoAfterMethod(MethodCallContext inputContext) { string useMethodName = null == inputContext.ThisMethod ? "N/A" : inputContext.ThisMethod.Name; Console.WriteLine(string.Format("{0}执行结束", useMethodName)); base.DoAfterMethod(inputContext); }
public async Task <AppLaunchResponse> Launch(AppLaunchRequest request, MethodCallContext context) { if (!_clientFactories.TryGetValue(request.AppId, out var clientFactory)) { throw new InvalidOperationException($"Unknown application launch requested: {request.AppId}"); } var client = await clientFactory.CreateClientAsync( _broker, UniqueId.FromHiLo( request.SuggestedAppInstanceId.Hi, request.SuggestedAppInstanceId.Lo)); OnStop(client.Disconnect); await client.ConnectAsync().ConfigureAwait(false); return(new AppLaunchResponse { AppInstanceId = new Generated.UniqueId { Hi = client.ApplicationInstanceId.Hi, Lo = client.ApplicationInstanceId.Lo } }); }
private async Task <CcyPairRate> GetRateAsync(CcyPair request, MethodCallContext context) { Console.WriteLine("Received request: {0}", request); CcyPairRate response; switch (request.CcyPairName) { case "EURUSD": response = new CcyPairRate { CcyPairName = "EURUSD", Rate = 1.15 + 0.05 * _random.NextDouble() }; break; case "EURGBP": response = new CcyPairRate { CcyPairName = "EURGBP", Rate = 0.87 + 0.05 * _random.NextDouble() }; break; default: throw new ArgumentOutOfRangeException($"Unknown currency pair: {request.CcyPairName}"); } Console.WriteLine("Sending response: {0}", response); return(response); }
public async Task HandleAsync(IncomingInvocationDescriptor info, ITransportChannel channel) { var invocation = _incomingInvocationFactory.CreateAsync <TRequest, TResponse>(info, channel); try { TRequest request = default; while (await invocation.In.WaitForNextSafeAsync().ConfigureAwait(false)) { while (invocation.In.TryReadSafe(out var item)) { request = item; } } var context = new MethodCallContext(info.Source.ApplicationId, info.Source.ConnectionId); await _handler(request, invocation.Out, context).ConfigureAwait(false); invocation.Out.TryComplete(); } catch (Exception ex) { invocation.Out.TryTerminate(ex); throw; } finally { await invocation.Completion.ConfigureAwait(false); } }
protected override void PreProcess(MethodCallContext ctx) { base.PreProcess(ctx); Type type = m_InterceptedObject.GetType(); MethodBase method = ctx.CallMessage.MethodBase; try { AutoCompleteAttribute auto = method.GetSingleAttribute <AutoCompleteAttribute>(); _txParticipant = (auto != null); if (_txParticipant) { TransactionAttribute tx = type.GetSingleAttribute <TransactionAttribute>(); if (tx == null) { ContainerExceptionHelper.ThrowComponentTransactionNotDefine(type, method); } TransactionOptions txOptions = new TransactionOptions(); txOptions.IsolationLevel = tx.TxIsolationLevel; _txScope = new TransactionScope(tx.Option, txOptions); _log.Info("Transaction [{0}] started on [{1}.{2}].", Transaction.Current.TransactionInformation, type.Name, method.Name); } } catch (Exception ex) { _log.Error("Transaction failed to start on [{1}.{2}]. [{0}]", ex.ToString(), type.Name, method.Name); throw; } }
public async Task <AppLaunchResponse> Launch(AppLaunchRequest request, MethodCallContext context) { var appId = request.AppId; var suggestedAppInstanceId = UniqueId.FromHiLo( request.SuggestedAppInstanceId.Hi, request.SuggestedAppInstanceId.Lo); Task <IClient> clientTask = null; lock (_sync) { if (request.LaunchMode == AppLaunchMode.SingleInstance && _createdClients.TryGetValue(appId, out var clientList) && clientList.Any()) { var existingClient = clientList.First(); clientTask = Task.FromResult(existingClient); } if (request.LaunchMode != AppLaunchMode.MultiInstance && clientTask == null) { if (_createClientTasks.TryGetValue(appId, out var list) && list.Any()) { clientTask = list.First(); } } clientTask = clientTask ?? CreateClientAsync(appId, suggestedAppInstanceId); } var client = await clientTask.ConfigureAwait(false); OnStop(client.Disconnect); await client.ConnectAsync().ConfigureAwait(false); if (client.ApplicationInstanceId == suggestedAppInstanceId) { lock (_sync) { if (_createClientTasks.TryGetValue(appId, out var list)) { list.Remove(clientTask); if (!list.Any()) { _createClientTasks.Remove(appId); } } } } return(new AppLaunchResponse { AppInstanceId = new Generated.UniqueId { Hi = client.ApplicationInstanceId.Hi, Lo = client.ApplicationInstanceId.Lo } }); }
// Implementation of unary method GetRate public Task <CcyPairRate> GetRate(CcyPair request, MethodCallContext context) { Console.WriteLine("Received request: {0}", request); var response = GetCcyPairRate(request); Console.WriteLine("Sending response: {0}", response); return(Task.FromResult(response)); }
public override void EnterMethodCall([NotNull] MethodCallContext context) { MethodCallExpression expr = new MethodCallExpression(Result, context); expr.Name = context.IDENTIFIER().GetText(); expr.ParentAccessor = null; expr.Parameters = GetMethodCallParameters(expr, context, context.expressionList()); this.Result.Insert(expr); }
public Task <GreetingResponse> Unary(GreetingRequest request, MethodCallContext context) { Console.WriteLine("Received unary request from {{{0}}}", context); Console.WriteLine("Received: {0}", request.Name); var greeting = $"Hello, {request.Name}! This is .NET app."; Console.WriteLine("Sending response: {0}", greeting); return(Task.FromResult(new GreetingResponse { Greeting = greeting })); }
public Task <ContextsList> GetContexts(Empty request, MethodCallContext callContext) { return(Task.Factory.StartNew(() => { var allContexts = _contextsSet.GetContextsOf(callContext.ConsumerApplicationInstanceId); return new ContextsList { Contexts = { allContexts.Select(context => ConvertContextToProto(context, callContext.ConsumerApplicationInstanceId)) } }; })); }
public Task <ContextDto> CreateContext2(CreateContextRequest request, MethodCallContext callContext) { return(Task.Factory.StartNew(() => { var newContext = _contextsSet.CreateContext(request.Kind, callContext.ConsumerApplicationInstanceId); foreach (var appConnection in _appLifecycleManager.GetAppInstanceConnections(callContext.ConsumerApplicationInstanceId)) { newContext.AppConnected(appConnection.Info); } return ConvertContextToProto(newContext, callContext.ConsumerApplicationInstanceId); })); }
public Task <InvocationsList> GetLinkedInvocations(ContextDto request, MethodCallContext callContext) { return(Task.Factory.StartNew(() => { var context = _contextsSet.GetContext(request.Id); if (context == null) { throw new Exception($"There is no context with {request.Id} id"); } return CreateInvocationsList(context); })); }
public Task <ContextDto> CreateContext(Empty request, MethodCallContext callContext) { return(Task.Factory.StartNew(() => { var newContext = _contextsSet.CreateContext(); foreach (var appConnection in _appLifecycleManager.GetAppInstanceConnections(callContext.ConsumerApplicationInstanceId)) { newContext.AppConnected(appConnection.Info); } return new ContextDto { Id = newContext.Id }; })); }
public Task <Empty> JoinContext(ContextDto request, MethodCallContext callContext) { return(Task.Factory.StartNew(() => { var context = _contextsSet.GetContext(request.Id); if (context == null) { throw new Exception($"There is no context with {request.Id} id"); } foreach (var appConnection in _appLifecycleManager.GetAppInstanceConnections(callContext.ConsumerApplicationInstanceId)) { context.AppConnected(appConnection.Info); } return new Empty(); })); }
private static async Task <RpcResponse> MakeRequestAsync(string methodName, params object[] args) { var response = await client.PostAsync("", new StringContent(MethodCallContext.ToJson(MyVersion, methodName, args))); var result = RpcResponse.FromJson(await ReadContent(response)); if (result.JsonRpcVersion != MyVersion) { throw new Exception($"Incompatible RPC versions result {result.JsonRpcVersion} vs current {MyVersion}"); } if (result.Error != null) { throw new Exception(result.Error?.Message); } return(result); }
private async void Start() { while (listener.IsListening) { try { HttpListenerContext context = await listener.GetContextAsync(); var requestContent = new StreamReader(context.Request.InputStream).ReadToEnd(); Result <object, RpcError> result; MethodCallContext? call = null; try { call = MethodCallContext.FromJson(requestContent); if (call.JsonRpcVersion != RpcManager.JsonRpcVersion) { result = new Result <object, RpcError>( new InvalidRequest($"Incompatible RPC versions call {call.JsonRpcVersion} vs current {RpcManager.JsonRpcVersion}")); } else { result = RpcManager.Invoke(call.MethodName, call.Params.ToArray()); } } catch (Exception e) { result = new Result <object, RpcError>((ParseError)e); } var response = RpcResponse.ToJson(RpcManager.JsonRpcVersion, result, call == null ? 0 : call.Id); byte[] buffer = System.Text.Encoding.UTF8.GetBytes(response); context.Response.ContentLength64 = buffer.Length; context.Response.OutputStream.Write(buffer, 0, buffer.Length); context.Response.OutputStream.Close(); // Must close output stream } catch (ObjectDisposedException) { return; } } }
private Task <AppLaunchResponse> LaunchAsync(AppLaunchRequest request, MethodCallContext context) { Log.Debug("Launch request received: {0}", request); var paramsDto = _jsonSerializer.Deserialize <NativeAppLauncherParamsDto>( new JTokenReader(JToken.Parse(request.LaunchParamsJson))); var cmd = Path.Combine(_cmdBasePath, paramsDto.Cmd); var id = _subProcessLauncher.Launch(cmd, paramsDto.Args); Log.Trace("Launched app instance {0} by request: {1}", id, request); return(Task.FromResult(new AppLaunchResponse { AppInstanceId = new UniqueId { Lo = id.Lo, Hi = id.Hi } })); }
public Task Subscribe( IWritableChannel <T> responseStream, MethodCallContext context) { lock (_subscribers) { _subscribers.Add(responseStream); } Log.Info("Lifecycle events subscriber added: {{{0}}}", context); using (context.CancellationToken.Register(() => { lock (_subscribers) { _subscribers.Remove(responseStream); } Log.Info("Lifecycle events subscriber removed: {{{0}}}", context); })) { } return(_completion.Task); }
private MethodeCall HandleMethodeCall(MethodCallContext inMethodeCallContext) { var tmpMethodeCall = new MethodeCall() { Name = (inMethodeCallContext.SUPER() ?? inMethodeCallContext.THIS() ?? inMethodeCallContext.IDENTIFIER()).GetText() }; if (inMethodeCallContext.expressionList() != null) { foreach (ExpressionContext tmpExpression in inMethodeCallContext.expressionList().expression()) { //Handle expression Context for Methode Call Parameter var tmpCodeParam = new CodeBlock(); HandleExpressionContext(tmpCodeParam, tmpExpression, null); tmpMethodeCall.Parameter.Add(tmpCodeParam); } } return(tmpMethodeCall); }
public async Task <ResolveAppResponse> ResolveApp(ResolveAppRequest request, MethodCallContext context) { Log.Info("Resolving app by request {{{0}}} from {{{1}}}", request, context); var referrerConnectionInfo = new AppConnectionDescriptor( context.ConsumerConnectionId, context.ConsumerApplicationId, context.ConsumerApplicationInstanceId, context.ConsumerTransportType); var resolveMode = Convert(request.AppResolveMode); if (resolveMode == ResolveMode.SingleInstance) { var connection = _appLifecycleManager.GetOnlineConnections().FirstOrDefault(c => c.Info.ApplicationId.Equals(request.AppId)); Log.Debug("Resolved connection for app {0} with mode {1} to online instance {{{2}}}", connection, resolveMode, connection); if (connection != null) { return(new ResolveAppResponse { AppInstanceId = connection.Info.ApplicationInstanceId.ToProto(), AppConnectionId = connection.Info.ConnectionId.ToProto(), IsNewInstanceLaunched = false, }); } } var resolvedConnection = await _appLifecycleManager.LaunchAndConnectAsync( request.AppId, resolveMode, referrerConnectionInfo).ConfigureAwait(false); var info = resolvedConnection.AppConnection.Info; Log.Info("App connection {{{0}}} resolved by request from {{{1}}}", resolvedConnection, context); var response = new ResolveAppResponse { AppConnectionId = info.ConnectionId.ToProto(), AppInstanceId = info.ApplicationInstanceId.ToProto(), IsNewInstanceLaunched = resolvedConnection.IsNewInstance }; return(response); }
public MethodCallContext methodCall() { MethodCallContext _localctx = new MethodCallContext(Context, State); EnterRule(_localctx, 4, RULE_methodCall); try { int _alt; EnterOuterAlt(_localctx, 1); { State = 34; Match(METHOD_CALL_SYMBOL); State = 35; _localctx.MethodCallName = Match(ID); State = 39; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream, 3, Context); while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.InvalidAltNumber) { if (_alt == 1) { { { State = 36; _localctx.MethodCallParameter = methodCallParameter(); } } } State = 41; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream, 3, Context); } } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return(_localctx); }
protected override void PostProcess(MethodCallContext ctx) { try { if (_txParticipant) { if (ctx.ReturnMessage.Exception == null) { _log.Info("No Exception, TransactionScope.Complete() before Dispose() with Transaction[{0}].", Transaction.Current.TransactionInformation); _txScope.Complete(); } _txScope.Dispose(); } } catch (Exception ex) { _log.Error("Transaction management error with Transaction[{0}]. {1}", Transaction.Current, ex.ToString()); throw; } base.PostProcess(ctx); }
private static async Task GreetingDuplexStreaming( IReadableChannel <GreetingRequest> requestStream, IWritableChannel <GreetingResponse> responseStream, MethodCallContext context) { Console.WriteLine("Received duplex streaming request from {{{0}}}", context); var greeting = "Hello!"; await responseStream.WriteAsync(new GreetingResponse { Greeting = greeting }).ConfigureAwait(false); Console.WriteLine("Sent: {0}", greeting); while (await requestStream.WaitReadAvailableAsync().ConfigureAwait(false)) { while (requestStream.TryRead(out var request)) { Console.WriteLine("Received: {0}", request.Name); greeting = $"Hello, {request.Name}!"; await responseStream .WriteAsync(new GreetingResponse { Greeting = greeting }) .ConfigureAwait(false); Console.WriteLine("Sent: {0}", greeting); } } Console.WriteLine("Request stream completed"); greeting = "Good Bye!"; await responseStream .WriteAsync(new GreetingResponse { Greeting = greeting }) .ConfigureAwait(false); Console.WriteLine("Sent: {0}", greeting); greeting = "See you again!"; await responseStream .WriteAsync(new GreetingResponse { Greeting = greeting }) .ConfigureAwait(false); Console.WriteLine("Sent: {0}", greeting); Console.WriteLine("Completed"); }
// Implementation of server streaming method GetRateStream public async Task GetRateStream( CcyPair request, IWritableChannel <CcyPairRate> responseStream, MethodCallContext context) { Console.WriteLine("Received subscription: {0}", request); try { do { var response = GetCcyPairRate(request); Console.WriteLine("Sending response: {0}", response); await responseStream.TryWriteAsync(response, context.CancellationToken); await Task.Delay(_random.Next(1000, 3000), context.CancellationToken); } while (!context.CancellationToken.IsCancellationRequested); } catch (OperationCanceledException) when(context.CancellationToken.IsCancellationRequested) { // Ignoring cancellation exception } Console.WriteLine("Subscription completed"); }
private static async Task GreetingServerStreaming( GreetingRequest request, IWritableChannel <GreetingResponse> responseStream, MethodCallContext context) { Console.WriteLine("Received server streaming request from {{{0}}}", context); Console.WriteLine("Received: {0}", request.Name); var greeting = $"Hello, {request.Name}!"; await responseStream .WriteAsync(new GreetingResponse { Greeting = greeting }) .ConfigureAwait(false); Console.WriteLine("Sent: {0}", greeting); await Task.Delay(500).ConfigureAwait(false); greeting = $"Hello again, {request.Name}!"; await responseStream .WriteAsync(new GreetingResponse { Greeting = greeting }) .ConfigureAwait(false); Console.WriteLine("Sent: {0}", greeting); Console.WriteLine("Completed"); }
private static async Task <GreetingResponse> GreetingClientStreaming( IReadableChannel <GreetingRequest> requeststream, MethodCallContext context) { Console.WriteLine("Received client streaming request from {{{0}}}", context); var names = new List <string>(); while (await requeststream.WaitReadAvailableAsync().ConfigureAwait(false)) { while (requeststream.TryRead(out var request)) { Console.WriteLine("Received: {0}", request.Name); names.Add(request.Name); } } Console.WriteLine("Request stream completed"); var greeting = $"Hello, {string.Join(", ", names)}!"; Console.WriteLine("Sending response: {0}", greeting); return(new GreetingResponse { Greeting = greeting }); }
protected override async Task HandleCoreAsync(IIncomingInvocation <TRequest, TResponse> invocation, MethodCallContext context) { var response = await _handler(invocation.In, context).ConfigureAwait(false); await invocation.Out.WriteAsync(response).ConfigureAwait(false); }
private static IEnumerable<ConnectionStringSettings> ReturnEmptyConnectionStringList(MethodCallContext arg) { return new List<ConnectionStringSettings>(); }