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);
}
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>();
}
