private InProcRemoteHostClient(Workspace workspace, InProcRemoteServices inprocServices, Stream stream) :
base(workspace)
{
_inprocServices = inprocServices;
_rpc = new JsonRpc(stream, stream, target: this);
_rpc.JsonSerializer.Converters.Add(AggregateJsonConverter.Instance);
// handle disconnected situation
_rpc.Disconnected += OnRpcDisconnected;
_rpc.StartListening();
}
private async Task <(JsonRpc JsonRpc, WebSocket WebSocket)> EstablishWebSocket()
{
IWebHostBuilder webHostBuilder = WebHost.CreateDefaultBuilder(Array.Empty <string>())
.UseStartup <AspNetStartup>();
var testServer = new TestServer(webHostBuilder);
var testClient = testServer.CreateWebSocketClient();
var webSocket = await testClient.ConnectAsync(testServer.BaseAddress, this.TimeoutToken);
var rpc = new JsonRpc(new WebSocketMessageHandler(webSocket));
rpc.StartListening();
return(rpc, webSocket);
}
public Server(Stream?sender, Stream?receiver)
{
waitForInit = new ManualResetEvent(false);
rpc = new JsonRpc(sender, receiver, this);
rpc.StartListening();
disconnectEvent = new ManualResetEvent(false);
rpc.Disconnected += (s, e) => disconnectEvent.Set();
sourceFiles = new Dictionary <Uri, SourceFile>();
waitForInit.Set();
}
/// <summary> Connects an asynchronous. </summary>
/// <remarks> 19.09.2020. </remarks>
/// <param name="token"> A token that allows processing to be cancelled. </param>
/// <returns> An asynchronous result. </returns>
public async Task ConnectAsync(CancellationToken token)
{
if (_socket != null && _socket.State == WebSocketState.Open)
{
return;
}
if (_socket == null || _socket.State != WebSocketState.None)
{
_jsonRpc?.Dispose();
_socket?.Dispose();
_socket = new ClientWebSocket();
}
_connectTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, _connectTokenSource.Token);
await _socket.ConnectAsync(_uri, linkedTokenSource.Token);
linkedTokenSource.Dispose();
_connectTokenSource.Dispose();
_connectTokenSource = null;
Logger.Debug("Connected to Websocket.");
var formatter = new JsonMessageFormatter();
formatter.JsonSerializer.Converters.Add(_hashTypeConverter);
formatter.JsonSerializer.Converters.Add(_extrinsicJsonConverter);
formatter.JsonSerializer.Converters.Add(_extrinsicStatusJsonConverter);
_jsonRpc = new JsonRpc(new WebSocketMessageHandler(_socket, formatter));
_jsonRpc.TraceSource.Listeners.Add(new NLogTraceListener());
_jsonRpc.TraceSource.Switch.Level = SourceLevels.All;
_jsonRpc.AddLocalRpcTarget(Listener, new JsonRpcTargetOptions()
{
AllowNonPublicInvocation = false
});
_jsonRpc.StartListening();
Logger.Debug("Listening to websocket.");
var result = await State.GetMetaDataAsync(token);
var metaDataParser = new MetaDataParser(_uri.OriginalString, result);
MetaData = metaDataParser.MetaData;
Logger.Debug("MetaData parsed.");
GenesisHash = await Chain.GetBlockHashAsync(0, token);
Logger.Debug("Genesis hash parsed.");
}
private ServiceHubRemoteHostClient(
Workspace workspace, HubClient hubClient, HostGroup hostGroup, Stream stream) :
base(workspace)
{
_hubClient = hubClient;
_hostGroup = hostGroup;
_rpc = new JsonRpc(stream, stream, target: this);
// handle disconnected situation
_rpc.Disconnected += OnRpcDisconnected;
_rpc.StartListening();
}
public InProcLanguageServer(Stream inputStream, Stream outputStream, LanguageServerProtocol protocol,
Workspace workspace, IDiagnosticService diagnosticService, string?clientName, bool supportsHover)
{
_protocol = protocol;
_workspace = workspace;
_supportsHover = supportsHover;
_jsonRpc = new JsonRpc(outputStream, inputStream, this);
_jsonRpc.StartListening();
_diagnosticService = diagnosticService;
_clientName = clientName;
_diagnosticService.DiagnosticsUpdated += DiagnosticService_DiagnosticsUpdated;
}
async Task ExecuteServerAsync(ServerOptions opts)
{
m_requesters = new ConcurrentDictionary <int, IRequest>();
m_listener = new TcpListener(IPAddress.Parse(opts.Host), opts.Port);
m_listener.Start();
while (true)
{
try
{
var conn = await m_listener.AcceptTcpClientAsync();
_ = Task.Run(async() =>
{
int id = Interlocked.Increment(ref s_counter);
try
{
var rpc = new JsonRpc(conn.GetStream());
m_requesters[id] = rpc.Attach <IRequest>();
rpc.AddLocalRpcTarget(new Responser(id, this));
// Initiate JSON-RPC message processing.
rpc.StartListening();
await rpc.Completion;
}
catch (Exception) { }
finally
{
m_requesters.TryRemove(id, out IRequest requester);
conn.Close();
if (m_requesters.IsEmpty)
{
m_listener.Stop();
}
((IDisposable)requester)?.Dispose();
}
});
}
catch (ObjectDisposedException)
{
// This happens when Stop is called and we're waiting for connection.
break;
}
}
}
public async Task AttachSecondProxy()
{
var streams = FullDuplexStream.CreateStreams();
var server = new Server();
var serverRpc = JsonRpc.Attach(streams.Item2, server);
var clientRpc = new JsonRpc(streams.Item1, streams.Item1);
var client1 = clientRpc.Attach <IServer>();
var client2 = clientRpc.Attach <IServer2>();
clientRpc.StartListening();
Assert.Equal(3, await client1.AddAsync(1, 2));
Assert.Equal(6, await client2.MultiplyAsync(2, 3));
}
private async Task HandleClientAsync(Stream serverStream, CancellationToken cancellationToken = default)
{
using JsonRpc server = GetRpcServer(serverStream, _resolveAssemblyReferenceTaskHandler);
server.StartListening();
try
{
await server.Completion.WithCancellation(cancellationToken).ConfigureAwait(false);
}
catch (ConnectionLostException)
{
// Some problem with connection, let's ignore it.
// All other exceptions are issue though
}
}
public async Task Dispatch()
{
using (Rpc){
Rpc.CancelLocallyInvokedMethodsWhenConnectionIsClosed = true;
Rpc.StartListening();
// Attach api
var otherSide = Rpc.Attach <Api.IHandlers>();
while (true)
{
try{
// Call and response
Console.WriteLine(await otherSide.Ping());
await otherSide.Hello(new Api.Models.Hello {
name = "C#"
});
var result = await otherSide.SubscribeTick();
await Task.Delay(5000);
var result2 = await otherSide.UnsubscribeTick(result);
Console.WriteLine(JsonConvert.SerializeObject(result2));
await Rpc.Completion; // throws exceptions - closed connection,etc.
if (Rpc.Completion.Exception == null)
{
break;
}
}catch (Exception e) {
if (e is WebSocketException || e is ConnectionLostException)
{
Console.WriteLine(e.Message.ToString());
Console.WriteLine("================================================");
break;
}
if (e is RemoteRpcException)
{
Console.WriteLine(e.Message.ToString());
Console.WriteLine("================================================");
break;
}
}
}
// Missing: WS close
this.Manager.Connections.TryRemove(this.Id, out OpenSocket value);
}
}
public async Task RPCMethodNameSubstitutionByOptions()
{
var streams = FullDuplexStream.CreateStreams();
this.serverStream = streams.Item1;
this.clientStream = streams.Item2;
var camelCaseOptions = new JsonRpcProxyOptions {
MethodNameTransform = CommonMethodNameTransforms.CamelCase
};
var prefixOptions = new JsonRpcProxyOptions {
MethodNameTransform = CommonMethodNameTransforms.Prepend("ns.")
};
// Construct two client proxies with conflicting method transforms to prove that each instance returned retains its unique options.
var clientRpc = new JsonRpc(this.clientStream, this.clientStream);
var clientRpcWithCamelCase = clientRpc.Attach <IServer3>(camelCaseOptions);
var clientRpcWithPrefix = clientRpc.Attach <IServer3>(prefixOptions);
clientRpc.StartListening();
// Construct the server to only respond to one set of method names for now to confirm that the client is sending the right one.
this.serverRpc = new JsonRpc(this.serverStream, this.serverStream);
this.serverRpc.AddLocalRpcTarget(this.server, new JsonRpcTargetOptions {
MethodNameTransform = camelCaseOptions.MethodNameTransform
});
this.serverRpc.StartListening();
Assert.Equal("Hi!", await clientRpcWithCamelCase.SayHiAsync()); // "sayHiAsync"
await Assert.ThrowsAsync <RemoteMethodNotFoundException>(() => clientRpcWithPrefix.SayHiAsync()); // "ns.SayHiAsync"
#if !NETCOREAPP1_0 // skip attribute-based renames where not supported
Assert.Equal("ANDREW", await clientRpcWithCamelCase.ARoseByAsync("andrew")); // "anotherName"
await Assert.ThrowsAsync <RemoteMethodNotFoundException>(() => clientRpcWithPrefix.ARoseByAsync("andrew")); // "ns.AnotherName"
#endif
// Prepare the server to *ALSO* accept method names with a prefix.
this.serverRpc.AllowModificationWhileListening = true;
this.serverRpc.AddLocalRpcTarget(this.server, new JsonRpcTargetOptions {
MethodNameTransform = prefixOptions.MethodNameTransform
});
// Retry with our second client proxy to send messages which the server should now accept.
Assert.Equal("Hi!", await clientRpcWithPrefix.SayHiAsync()); // "ns.SayHiAsync"
#if !NETCOREAPP1_0 // skip attribute-based renames where not supported
Assert.Equal("ANDREW", await clientRpcWithPrefix.ARoseByAsync("andrew")); // "ns.AnotherName"
#endif
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.Use(async(context, next) =>
{
if (context.WebSockets.IsWebSocketRequest)
{
var webSocket = await context.WebSockets.AcceptWebSocketAsync();
using (var rpc = new JsonRpc(new WebSocketMessageHandler(webSocket), new EchoServer(webSocket)))
{
rpc.StartListening();
await rpc.Completion;
}
}
await next();
});
}
private ServiceHubRemoteHostClient(
Workspace workspace, HubClient hubClient, HostGroup hostGroup, Stream stream) :
base(workspace)
{
_hubClient = hubClient;
_hostGroup = hostGroup;
_timeout = TimeSpan.FromMilliseconds(workspace.Options.GetOption(RemoteHostOptions.RequestServiceTimeoutInMS));
_rpc = new JsonRpc(stream, stream, target: this);
_rpc.JsonSerializer.Converters.Add(AggregateJsonConverter.Instance);
// handle disconnected situation
_rpc.Disconnected += OnRpcDisconnected;
_rpc.StartListening();
}
private static JsonRpc CreateRpc(string name, Stream duplexStream)
{
// Create a JsonRpcMessagePackFormatter as an IJsonRpcMessageFormatter.
var formatter = new JsonRpcMessagePackFormatter(MyCompositeResolver.Instance);
// Create a JsonRpc that uses the IJsonRpcMessageFormatter.
var handler = new LengthHeaderMessageHandler(duplexStream, duplexStream, formatter);
var rpc = new JsonRpc(handler)
{
TraceSource = new TraceSource(name, SourceLevels.Verbose),
};
rpc.AddLocalRpcTarget(new ServerObject());
rpc.StartListening();
return(rpc);
}
public async Task <IActionResult> Socket()
{
if (this.HttpContext.WebSockets.IsWebSocketRequest)
{
var socket = await this.HttpContext.WebSockets.AcceptWebSocketAsync();
var jsonRpc = new JsonRpc(new WebSocketMessageHandler(socket), new JsonRpcServer());
jsonRpc.StartListening();
await jsonRpc.Completion;
return(new EmptyResult());
}
else
{
return(new BadRequestResult());
}
}
private RazorHtmlCSharpLanguageServer(
Stream inputStream,
Stream outputStream,
IEnumerable <Lazy <IRequestHandler, IRequestHandlerMetadata> > requestHandlers,
HTMLCSharpLanguageServerLogHubLoggerProvider loggerProvider) : this(requestHandlers)
{
_jsonRpc = CreateJsonRpc(outputStream, inputStream, target: this);
// Facilitates activity based tracing for structured logging within LogHub
_jsonRpc.ActivityTracingStrategy = new CorrelationManagerTracingStrategy
{
TraceSource = loggerProvider.GetTraceSource()
};
_jsonRpc.StartListening();
}
private ServiceHubRemoteHostClient(
Workspace workspace,
ConnectionManager connectionManager,
Stream stream)
: base(workspace)
{
_connectionManager = connectionManager;
_rpc = new JsonRpc(new JsonRpcMessageHandler(stream, stream), target: this);
_rpc.JsonSerializer.Converters.Add(AggregateJsonConverter.Instance);
// handle disconnected situation
_rpc.Disconnected += OnRpcDisconnected;
_rpc.StartListening();
}
public async Task Connect()
{
this.stream = GetStream();
await this.stream.ConnectAsync();
rpc = new JsonRpc(this.stream);
this.Instance = this.rpc.Attach <T>();
rpc.StartListening();
rpc.Disconnected += (_, _) =>
{
this.stream.Dispose();
Disconnected?.Invoke(this, null);
rpc.Dispose();
};
}
public async Task NamingTransformsAreAppliedToEvents()
{
var streams = FullDuplexStream.CreateStreams();
this.serverStream = streams.Item1;
this.clientStream = streams.Item2;
var camelCaseOptions = new JsonRpcProxyOptions {
EventNameTransform = CommonMethodNameTransforms.CamelCase
};
var prefixOptions = new JsonRpcProxyOptions {
EventNameTransform = CommonMethodNameTransforms.Prepend("ns.")
};
// Construct two client proxies with conflicting method transforms to prove that each instance returned retains its unique options.
var clientRpc = new JsonRpc(this.clientStream, this.clientStream);
var clientRpcWithCamelCase = clientRpc.Attach <IServer>(camelCaseOptions);
var clientRpcWithPrefix = clientRpc.Attach <IServer>(prefixOptions);
clientRpc.StartListening();
// Construct the server to only respond to one set of method names for now to confirm that the client is sending the right one.
this.serverRpc = new JsonRpc(this.serverStream, this.serverStream);
this.serverRpc.AddLocalRpcTarget(this.server, new JsonRpcTargetOptions {
EventNameTransform = camelCaseOptions.EventNameTransform
});
this.serverRpc.StartListening();
var tcs = new TaskCompletionSource <EventArgs>();
EventHandler handler = (sender, args) => tcs.SetResult(args);
clientRpcWithCamelCase.ItHappened += handler;
this.server.OnItHappened(EventArgs.Empty);
var actualArgs = await tcs.Task.WithCancellation(this.TimeoutToken);
Assert.NotNull(actualArgs);
clientRpcWithCamelCase.ItHappened -= handler;
clientRpcWithPrefix.ItHappened += handler;
tcs = new TaskCompletionSource <EventArgs>();
this.server.OnItHappened(EventArgs.Empty);
await Assert.ThrowsAsync <TimeoutException>(() => tcs.Task.WithTimeout(ExpectedTimeout));
Assert.False(tcs.Task.IsCompleted);
clientRpcWithPrefix.ItHappened -= handler;
}
public async Task TraceListenerThrows_CausesDisconnect()
{
var pair = FullDuplexStream.CreatePair();
var serverRpc = new JsonRpc(pair.Item1)
{
TraceSource = new TraceSource(nameof(JsonRpc))
{
Switch = { Level = SourceLevels.All },
Listeners = { new ThrowingTraceListener() },
},
};
serverRpc.StartListening();
int bytesRead = await pair.Item2.ReadAsync(new byte[1], 0, 1, this.TimeoutToken);
Assert.Equal(0, bytesRead);
}
public async Task InitializeCodeSearchServiceAsync()
{
if (_jsonRpc != null)
{
return;
}
string clientPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "AzDevOpsInteractiveClient.exe");
string pipeName = $"AzDevOpsClientPipe-{Process.GetCurrentProcess().Id}";
_clientProcess = new Process();
_clientProcess.StartInfo = new ProcessStartInfo(clientPath)
{
Arguments =
$@"--RootDir ""{_repoInfo.RootDir}"" " +
$@"--ProjectUri {_repoInfo.ProjectUri} " +
$@"--ProjectName ""{_repoInfo.ProjectName}"" " +
$@"--RepoName ""{_repoInfo.RepoName}"" " +
$@"--RpcPipeName ""{pipeName}"" ",
UseShellExecute = false,
CreateNoWindow = true,
};
_logger.LogDebug($"FastCodeNav: Launching {clientPath} with arguments '{_clientProcess.StartInfo.Arguments}'");
if (!_clientProcess.Start())
{
_logger.LogError($"FastCodeNav: Failed to launch {clientPath}");
return;
}
_logger.LogDebug($"FastCodeNav: Connecting to search service client with PID {_clientProcess.Id}");
var stream = new NamedPipeClientStream(".", pipeName, PipeDirection.InOut, PipeOptions.Asynchronous);
await stream.ConnectAsync();
_logger.LogDebug($"FastCodeNav: Connected to search service client.");
var jsonRpc = new JsonRpc(stream);
var jsonRpcProxy = jsonRpc.Attach <ICodeSearchService>();
jsonRpc.StartListening();
_jsonRpc = jsonRpc;
_logger.LogDebug($"FastCodeNav: Issuing a warmup RPC request");
_jsonRpc.InvokeAsync("WarmUpAsync").FireAndForget(_logger);
}
public async Task CallServerWithParameterObject()
{
var streams = FullDuplexStream.CreateStreams();
var server = new Server();
var serverRpc = JsonRpc.Attach(streams.Item2, server);
var client = new JsonRpc(streams.Item1, streams.Item1);
var clientRpc = client.Attach <IServerWithParamsObject>(new JsonRpcProxyOptions {
ServerRequiresNamedArguments = true
});
client.StartListening();
int result = await clientRpc.SumOfParameterObject(1, 2);
Assert.Equal(3, result);
}
public NeoRpcClient(Uri uri, HttpClient?httpClient = null)
{
var formatter = new JsonMessageFormatter();
formatter.JsonSerializer.Converters.Add(new AccountConverter());
formatter.JsonSerializer.Converters.Add(new BlockConverter());
formatter.JsonSerializer.Converters.Add(new BlockHeaderConverter());
formatter.JsonSerializer.Converters.Add(new PeersConverter());
formatter.JsonSerializer.Converters.Add(new TransactionConverter());
formatter.JsonSerializer.Converters.Add(new UInt256Converter());
formatter.JsonSerializer.Converters.Add(new ValidatorConverter());
var messageHandler = new HttpClientMessageHandler(httpClient ?? new HttpClient(), uri, formatter);
jsonRpc = new JsonRpc(messageHandler);
jsonRpc.StartListening();
}
async Task OnStartAsync()
{
Log("Call ActivateAsync.");
connection = await client.ActivateAsync(CancellationToken.None);
if (connection == null)
{
throw new ApplicationException("No connection returned from ActivateAsync.");
}
Log("JsonRpc.StartListening.");
var target = new LanguageClientTarget(this);
jsonRpc = new JsonRpc(connection.Writer, connection.Reader, target);
jsonRpc.Disconnected += JsonRpcDisconnected;
InitializeCustomClientProviders();
var customClient = client as ILanguageClientCustomMessage;
if (customClient != null)
{
Log("Adding LanguageClientCustomMessage.");
if (customClient.CustomMessageTarget != null)
{
jsonRpc.AddLocalRpcTarget(customClient.CustomMessageTarget);
}
await customClient.AttachForCustomMessageAsync(jsonRpc);
}
jsonRpc.StartListening();
jsonRpc.JsonSerializer.NullValueHandling = NullValueHandling.Ignore;
InitializeResult result = await Initialize();
ServerCapabilities = result.Capabilities;
OnServerCapabilitiesChanged();
await SendConfigurationSettings();
}
public RazorHtmlCSharpLanguageServer(
Stream inputStream,
Stream outputStream,
IEnumerable <Lazy <IRequestHandler, IRequestHandlerMetadata> > requestHandlers) : this(requestHandlers)
{
if (inputStream is null)
{
throw new ArgumentNullException(nameof(inputStream));
}
if (outputStream is null)
{
throw new ArgumentNullException(nameof(outputStream));
}
_jsonRpc = CreateJsonRpc(outputStream, inputStream, target: this);
_jsonRpc.StartListening();
}
public DataPoint(
ReferenceCodeLensProvider owner,
ICodeLensCallbackService callbackService,
CodeLensDescriptor descriptor,
Stream stream)
{
_owner = owner;
_callbackService = callbackService;
Descriptor = descriptor;
_roslynRpc = stream.CreateStreamJsonRpc(
target: new RoslynCallbackTarget(Invalidate),
owner._client.Logger,
SpecializedCollections.SingletonEnumerable(AggregateJsonConverter.Instance));
_roslynRpc.StartListening();
}
private ServiceHubRemoteHostClient(
Workspace workspace,
TraceSource logger,
ConnectionManager connectionManager,
Stream stream)
: base(workspace)
{
_shutdownCancellationTokenSource = new CancellationTokenSource();
_connectionManager = connectionManager;
_rpc = stream.CreateStreamJsonRpc(target: this, logger);
// handle disconnected situation
_rpc.Disconnected += OnRpcDisconnected;
_rpc.StartListening();
}
public async Task RunAsync(CancellationToken cancellationToken)
{
using var semaphore = new SemaphoreSlim(_maxConnection, _maxConnection);
while (!cancellationToken.IsCancellationRequested)
{
await semaphore.WaitAsync(cancellationToken);
try
{
_logger.LogInformation("create pipe.");
var stream = new NamedPipeServerStream(_pipeName, PipeDirection.InOut, _maxConnection, PipeTransmissionMode.Byte, PipeOptions.Asynchronous);
_logger.LogInformation("wait for connection.");
await stream.WaitForConnectionAsync(cancellationToken);
_logger.LogInformation("create target.");
var rpc = new JsonRpc(stream);
try
{
var target = OnConnect(rpc);
rpc.AddLocalRpcTarget <T>(target, null);
rpc.StartListening();
rpc.Disconnected += (o, e) =>
{
_logger.LogInformation("disconnected. {reason} - {description}", e.Reason, e.Description);
semaphore.Release();
};
}
catch (Exception e)
{
_logger.LogError(e, "create target fail.");
semaphore.Release();
}
}
catch (Exception e)
{
if (!cancellationToken.IsCancellationRequested)
{
_logger.LogError(e, "create connection fail.");
}
semaphore.Release();
}
}
}
public InProcLanguageServer(
AbstractInProcLanguageClient languageClient,
Stream inputStream,
Stream outputStream,
AbstractRequestHandlerProvider requestHandlerProvider,
Workspace workspace,
IDiagnosticService?diagnosticService,
IAsynchronousOperationListenerProvider listenerProvider,
ILspSolutionProvider solutionProvider,
string?clientName)
{
_languageClient = languageClient;
_requestHandlerProvider = requestHandlerProvider;
_workspace = workspace;
var jsonMessageFormatter = new JsonMessageFormatter();
jsonMessageFormatter.JsonSerializer.Converters.Add(new VSExtensionConverter <TextDocumentIdentifier, VSTextDocumentIdentifier>());
jsonMessageFormatter.JsonSerializer.Converters.Add(new VSExtensionConverter <ClientCapabilities, VSClientCapabilities>());
_jsonRpc = new JsonRpc(new HeaderDelimitedMessageHandler(outputStream, inputStream, jsonMessageFormatter));
_jsonRpc.AddLocalRpcTarget(this);
_jsonRpc.StartListening();
_diagnosticService = diagnosticService;
_listener = listenerProvider.GetListener(FeatureAttribute.LanguageServer);
_clientName = clientName;
_queue = new RequestExecutionQueue(solutionProvider);
_queue.RequestServerShutdown += RequestExecutionQueue_Errored;
// Dedupe on DocumentId. If we hear about the same document multiple times, we only need to process that id once.
_diagnosticsWorkQueue = new AsyncBatchingWorkQueue <DocumentId>(
TimeSpan.FromMilliseconds(250),
ProcessDiagnosticUpdatedBatchAsync,
EqualityComparer <DocumentId> .Default,
_listener,
_queue.CancellationToken);
if (_diagnosticService != null)
{
_diagnosticService.DiagnosticsUpdated += DiagnosticService_DiagnosticsUpdated;
}
}
internal async Task <int> RunAsync()
{
Logger.LogInformation($"AzDevOpsInteractiveClient is running");
if (_opts.WaitDebug)
{
while (!Debugger.IsAttached)
{
Logger.LogInformation("Awaiting for an attached debugger");
await Task.Delay(TimeSpan.FromMilliseconds(500));
}
}
try
{
// Create and asyncronously initialize Azure DevOps client
var service = new AzureDevOpsCodeSearchService(LoggerFactoryInstance, _opts);
service.InitializeAsync().FireAndForget(Logger);
Logger.LogInformation($"Waiting for client to make a connection to pipe {_opts.RpcPipeName} for repo {_opts.ProjectUri}");
using (var stream = new NamedPipeServerStream(_opts.RpcPipeName,
PipeDirection.InOut, NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte, PipeOptions.Asynchronous))
{
await stream.WaitForConnectionAsync();
using (var jsonRpc = new JsonRpc(stream))
{
jsonRpc.AddLocalRpcTarget(service);
jsonRpc.StartListening();
await jsonRpc.Completion;
}
}
Logger.LogInformation($"AzDevOpsInteractiveClient is existing");
}
catch (Exception e)
{
Logger.LogError(e, $"Failure while processing RPC requests");
return(1);
}
return(0);
}
