async Task <InitializeResult> Initialize() { Log("Sending '{0}' message.", Methods.InitializeName); var message = CreateInitializeParams(client, rootPath); InitializeResult result = null; try { result = await jsonRpc.InvokeWithParameterObjectAsync(Methods.Initialize, message); await client.OnServerInitializedAsync(); } catch (Exception ex) { await client.OnServerInitializeFailedAsync(ex); throw; } try { Log("Sending '{0}' message.", Methods.InitializedName); await jsonRpc.NotifyWithParameterObjectAsync(Methods.Initialized, new InitializedParams()); } catch (Exception ex) { LogError("Sending Initialized notification to server failed.", ex); } Log("Initialized.", Id); return(result); }
async Task <object> RequestCompletionsInternal(CompletionParams completionParams, CancellationToken token) { SumType <CompletionItem[], CompletionList>?result = await jsonRpc.InvokeWithParameterObjectAsync(Methods.TextDocumentCompletion, completionParams, token); if (result == null) { return(null); } return(result.Value.Match <object> ( completionItems => completionItems, completionList => completionList)); }
/// <summary> /// Called when we want to update a client's volume on snapserver /// </summary> /// <param name="id">client id</param> /// <param name="volume">new volume object</param> private async Task _SetClientVolumeAsync(string id, Volume volume) { Debug("Sending Client.SetVolume - id {0}, volume {1}", id, volume); ClientVolumeCommandResult result = await m_JsonRpc.InvokeWithParameterObjectAsync<ClientVolumeCommandResult>("Client.SetVolume", new ClientVolumeCommand() {id = id, volume = volume}); // update the server _ClientVolumeChanged(id, result.volume); // update our local data to reflect the new value }
/// <summary> /// RPCに接続する /// </summary> /// <param name="ws">WebSocket</param> /// <returns></returns> private async Task ConnectRpcAsync(ClientWebSocket ws) { Rpc = new JsonRpc(new WebSocketMessageHandler(ws)); Rpc.Disconnected += (s, e) => { // 切断されたときの処理 if (Logger != null) { Logger.LogWarning($"切断されました {ToString()}"); isWebSocketConnected = false; var t = RunAsync(); } }; Rpc.AddLocalRpcMethod(ChannelMessage, new Action <JToken, CancellationToken>((@params, cancellationToken) => { // 受信したときの処理 var p = @params as dynamic; // 受信したメッセージ(json)をイベントに送る OnGetMessage(new TextEventArgs(p.message.ToString())); })); Rpc.StartListening(); await Rpc.InvokeWithParameterObjectAsync <object>("subscribe", new { channel = ChannelName }); }
public async Task <bool> ConnectAsync(Uri ownerUri, string connectionStr) { var connectionOptions = new Dictionary <string, string>(); connectionOptions.Add("ConnectionString", connectionStr); var connectionDetails = new ConnectionDetails() { Options = connectionOptions }; var connectionParams = new ConnectParams() { OwnerUri = ownerUri.ToString(), Connection = connectionDetails }; return(await _rpc.InvokeWithParameterObjectAsync <bool>("connection/connect", connectionParams)); }
public static Task <TResult> InvokeWithParameterObjectAsync <TArgument, TResult> ( this JsonRpc jsonRpc, LspRequest <TArgument, TResult> request, TArgument argument, CancellationToken cancellationToken = default(CancellationToken)) { return(jsonRpc.InvokeWithParameterObjectAsync <TResult> (request.Name, argument, cancellationToken)); }
private async Task <R> InvokeWithParametersAsync <R>(string request, object parameters, CancellationToken t) where R : class { await _readyTcs.Task.ConfigureAwait(false); if (_rpc != null) { return(await _rpc.InvokeWithParameterObjectAsync <R>(request, parameters, t).ConfigureAwait(false)); } return(null); }
public Task <MessageActionItem?> ShowMessage(string message, MessageActionItem[] actions, MessageType messageType) { var parameters = new ShowMessageRequestParams { type = messageType, message = message, actions = actions }; return(_rpc.InvokeWithParameterObjectAsync <MessageActionItem?>("window/showMessageRequest", parameters)); }
//--------------------------------------------------------------------------------- /// <summary> /// Get all of the stacks available in the current location /// </summary> //--------------------------------------------------------------------------------- public StackInfo[] GetStacks() { return(DoRpcCall(() => { var requestParams = new NonStackRequestParams(Directory.GetCurrentDirectory()); var result = _server.InvokeWithParameterObjectAsync <StackInfoRequestResponse>("getStackInfoFromFilePath", requestParams).Result; return result.StackInfo.ToArray(); })); }
public async Task <string> ShowMessageAsync(string message, string[] actions, TraceEventType eventType) { var parameters = new ShowMessageRequestParams { type = eventType.ToMessageType(), message = message, actions = actions.Select(a => new MessageActionItem { title = a }).ToArray() }; var result = await _rpc.InvokeWithParameterObjectAsync <MessageActionItem?>("window/showMessageRequest", parameters); return(result?.title); }
public async Task <MessageActionItem> ShowMessageRequestAsync(string message, MessageType messageType, string[] actionItems) { ShowMessageRequestParams parameter = new ShowMessageRequestParams { Message = message, Type = (int)messageType, Actions = actionItems.Select(a => new MessageActionItem { Title = a }).ToArray() }; JToken response = await rpc.InvokeWithParameterObjectAsync <JToken>(Methods.WindowShowMessageRequestName, parameter).ConfigureAwait(false);; return(response.ToObject <MessageActionItem>()); }
public async Task <string[]> GetExpansionsAsync( string line, string lastWord, CancellationToken token) { var message = new TabExpansionParams { Line = line, LastWord = lastWord }; TabExpansionResult result = await rpc.InvokeWithParameterObjectAsync <TabExpansionResult> ( Methods.TabExpansionName, message, token); return(result.Expansions); }
/// <summary> /// Executes the asynchronous on a different thread, and waits for the result. /// </summary> /// <remarks> 19.09.2020. </remarks> /// <exception cref="ClientNotConnectedException"> Thrown when a Client Not Connected error /// condition occurs. </exception> /// <typeparam name="T"> Generic type parameter. </typeparam> /// <param name="method"> The method. </param> /// <param name="parameters"> Options for controlling the operation. </param> /// <param name="token"> A token that allows processing to be cancelled. </param> /// <returns> A T. </returns> internal async Task <T> InvokeAsync <T>(string method, object parameters, CancellationToken token) { if (_socket?.State != WebSocketState.Open) { throw new ClientNotConnectedException($"WebSocketState is not open! Currently {_socket?.State}!"); } Logger.Debug($"Invoking request[{method}, params: {parameters}] {MetaData?.Origin}"); _requestTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30)); var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token, _requestTokenSource.Token); var resultString = await _jsonRpc.InvokeWithParameterObjectAsync <T>(method, parameters, linkedTokenSource.Token); linkedTokenSource.Dispose(); _requestTokenSource.Dispose(); _requestTokenSource = null; return(resultString); }
private Task <T> SendCoreAsync <T>(string name, object arguments, CancellationToken?cancellationToken = null) { cancellationToken = cancellationToken ?? CancellationToken.None; try { // the arguments might have sensitive data in it -- don't include arguments here using (Log.CriticalOperation($"name=REQ,Method={name}")) { return(_rpc.InvokeWithParameterObjectAsync <T>(name, arguments, cancellationToken.Value)); } } catch (ObjectDisposedException ex) { Log.Fatal(ex, "SendName={Name}", name); #if DEBUG Log.Verbose($"Arguments={(arguments != null ? arguments.ToJson(true) : null)}"); #endif throw; } catch (Exception ex) { Log.Fatal(ex, "SendName={Name}", name); throw; } }
public async Task SendMessageToServer() { string text = await rpc.InvokeWithParameterObjectAsync <string>("GetText"); MessageService.ShowMessage("Text from language server:", text); }
private async static Task OfferAsync(IHttpContext context) { var offer = await context.GetRequestDataAsync <RTCSessionDescriptionInit>(); logger.LogDebug($"SDP Offer={offer.sdp}"); var jsonOptions = new JsonSerializerOptions(); jsonOptions.Converters.Add(new System.Text.Json.Serialization.JsonStringEnumConverter()); CancellationTokenSource cts = new CancellationTokenSource(); var ws = new ClientWebSocket(); await ws.ConnectAsync(new Uri(KURENTO_JSONRPC_URL), cts.Token); logger.LogDebug($"Successfully connected web socket client to {KURENTO_JSONRPC_URL}."); try { using (var jsonRpc = new JsonRpc(new WebSocketMessageHandler(ws))) { jsonRpc.AddLocalRpcMethod("ping", new Action(() => { logger.LogDebug($"Ping received"); } )); jsonRpc.AddLocalRpcMethod("onEvent", new Action <KurentoEvent>((evt) => { logger.LogDebug($"Event received type={evt.type}, source={evt.data.source}"); } )); jsonRpc.StartListening(); // Check the server is there. var pingResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.ping.ToString(), new { interval = KEEP_ALIVE_INTERVAL_MS }, cts.Token); logger.LogDebug($"Ping result={pingResult.value}."); // Create a media pipeline. var createPipelineResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.create.ToString(), new { type = "MediaPipeline" }, cts.Token); logger.LogDebug($"Create media pipeline result={createPipelineResult.value}, sessionID={createPipelineResult.sessionId}."); var sessionID = createPipelineResult.sessionId; var mediaPipeline = createPipelineResult.value; // Create a WebRTC end point. var createEndPointResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.create.ToString(), new { type = "WebRtcEndpoint", constructorParams = new { mediaPipeline = mediaPipeline }, sessionId = sessionID }, cts.Token); logger.LogDebug($"Create WebRTC endpoint result={createEndPointResult.value}."); var webRTCEndPointID = createEndPointResult.value; // Connect the WebRTC end point to itself to create a loopback connection (no result for this operation). await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.invoke.ToString(), new { @object = webRTCEndPointID, operation = "connect", operationParams = new { sink = webRTCEndPointID }, sessionId = sessionID }, cts.Token); // Subscribe for events from the WebRTC end point. var subscribeResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.subscribe.ToString(), new { @object = webRTCEndPointID, type = "IceCandidateFound", sessionId = sessionID }, cts.Token); logger.LogDebug($"Subscribe to WebRTC endpoint subscription ID={subscribeResult.value}."); var subscriptionID = subscribeResult.value; subscribeResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.subscribe.ToString(), new { @object = webRTCEndPointID, type = "OnIceCandidate", sessionId = sessionID }, cts.Token); logger.LogDebug($"Subscribe to WebRTC endpoint subscription ID={subscribeResult.value}."); // Send SDP offer. var processOfferResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.invoke.ToString(), new { @object = webRTCEndPointID, operation = "processOffer", operationParams = new { offer = offer.sdp }, sessionId = sessionID }, cts.Token); logger.LogDebug($"SDP answer={processOfferResult.value}."); RTCSessionDescriptionInit answerInit = new RTCSessionDescriptionInit { type = RTCSdpType.answer, sdp = processOfferResult.value }; context.Response.ContentType = "application/json"; using (var responseStm = context.OpenResponseStream(false, false)) { await JsonSerializer.SerializeAsync(responseStm, answerInit, jsonOptions); } // Tell Kurento to start ICE. var gatherCandidatesResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.invoke.ToString(), new { @object = webRTCEndPointID, operation = "gatherCandidates", sessionId = sessionID }, cts.Token); logger.LogDebug($"Gather candidates result={gatherCandidatesResult.value}."); } } catch (RemoteInvocationException invokeExcp) { logger.LogError($"JSON RPC invoke exception, error code={invokeExcp.ErrorCode}, msg={invokeExcp.Message}."); } }
public static async Task <EntityServiceResult> MakeCall(JsonRpc jsonRpc, int startIndex, int pageSize, int sortOption, string sortColumnName) { return(await jsonRpc.InvokeWithParameterObjectAsync <EntityServiceResult>("CallEntityService", new EntityServiceRequest("CampaignService", "GetEntities", new object[] { startIndex, pageSize, sortOption, sortColumnName }))); }
public static async Task <EntityServiceResult> MakeCall(JsonRpc jsonRpc) { return(await jsonRpc.InvokeWithParameterObjectAsync <EntityServiceResult>("CallEntityService", new EntityServiceRequest("CampaignService", "GetCount", null))); }
Task <object> ExecuteCommandInternal(ExecuteCommandParams executeCommandParams) { return(jsonRpc.InvokeWithParameterObjectAsync(Methods.WorkspaceExecuteCommand, executeCommandParams)); }
public Task <string[]> GetFileContentInMemoryAsync(string filename) => rpc.InvokeWithParameterObjectAsync <string[]>( Methods.WorkspaceExecuteCommand.Name, TestUtils.ServerCommand(CommandIds.FileContentInMemory, TestUtils.GetTextDocumentIdentifier(filename)));
public async Task <ResponseType?> ExecuteRequestAsync <RequestType, ResponseType>(string methodName, RequestType request, CancellationToken cancellationToken) where RequestType : class { var result = await _clientRpc.InvokeWithParameterObjectAsync <ResponseType>(methodName, request, cancellationToken : cancellationToken).ConfigureAwait(false); return(result); }
Task <SymbolInformation[]> RequestWorkspaceSymbolsInternal(WorkspaceSymbolParams param, CancellationToken token) { return(jsonRpc.InvokeWithParameterObjectAsync(Methods.WorkspaceSymbol, param, token)); }
static async Task Main(string[] args) { Console.WriteLine("Kurento Echo Test Client"); logger = AddConsoleLogger(); CancellationTokenSource cts = new CancellationTokenSource(); var ws = new ClientWebSocket(); await ws.ConnectAsync(new Uri(KURENTO_JSONRPC_URL), cts.Token); logger.LogDebug($"Successfully connected web socket client to {KURENTO_JSONRPC_URL}."); try { using (var jsonRpc = new JsonRpc(new WebSocketMessageHandler(ws))) { jsonRpc.AddLocalRpcMethod("ping", new Action(() => { logger.LogDebug($"Ping received"); } )); jsonRpc.AddLocalRpcMethod("onEvent", new Action <KurentoEvent>((evt) => { logger.LogDebug($"Event received type={evt.type}, source={evt.data.source}"); } )); jsonRpc.StartListening(); // Check the server is there. var pingResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.ping.ToString(), new { interval = KEEP_ALIVE_INTERVAL_MS }, cts.Token); logger.LogDebug($"Ping result={pingResult.value}."); // Create a media pipeline. var createPipelineResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.create.ToString(), new { type = "MediaPipeline" }, cts.Token); logger.LogDebug($"Create media pipeline result={createPipelineResult.value}, sessionID={createPipelineResult.sessionId}."); var sessionID = createPipelineResult.sessionId; var mediaPipeline = createPipelineResult.value; // Create a WebRTC end point. var createEndPointResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.create.ToString(), new { type = "WebRtcEndpoint", constructorParams = new { mediaPipeline = mediaPipeline }, sessionId = sessionID }, cts.Token); logger.LogDebug($"Create WebRTC endpoint result={createEndPointResult.value}."); var webRTCEndPointID = createEndPointResult.value; // Connect the WebRTC end point to itself to create a loopback connection (no result for this operation). await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.invoke.ToString(), new { @object = webRTCEndPointID, operation = "connect", operationParams = new { sink = webRTCEndPointID }, sessionId = sessionID }, cts.Token); // Subscribe for events from the WebRTC end point. var subscribeResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.subscribe.ToString(), new { @object = webRTCEndPointID, type = "IceCandidateFound", sessionId = sessionID }, cts.Token); logger.LogDebug($"Subscribe to WebRTC endpoint subscription ID={subscribeResult.value}."); var subscriptionID = subscribeResult.value; subscribeResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.subscribe.ToString(), new { @object = webRTCEndPointID, type = "OnIceCandidate", sessionId = sessionID }, cts.Token); logger.LogDebug($"Subscribe to WebRTC endpoint subscription ID={subscribeResult.value}."); var pc = CreatePeerConnection(); var offer = pc.createOffer(null); await pc.setLocalDescription(offer); // Send SDP offer. var processOfferResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.invoke.ToString(), new { @object = webRTCEndPointID, operation = "processOffer", operationParams = new { offer = offer.sdp }, sessionId = sessionID }, cts.Token); logger.LogDebug($"SDP answer={processOfferResult.value}."); var setAnswerResult = pc.setRemoteDescription(new RTCSessionDescriptionInit { type = RTCSdpType.answer, sdp = processOfferResult.value }); logger.LogDebug($"Set WebRTC peer connection answer result={setAnswerResult}."); // Tell Kurento to start ICE. var gatherCandidatesResult = await jsonRpc.InvokeWithParameterObjectAsync <KurentoResult>( KurentoMethodsEnum.invoke.ToString(), new { @object = webRTCEndPointID, operation = "gatherCandidates", sessionId = sessionID }, cts.Token); logger.LogDebug($"Gather candidates result={gatherCandidatesResult.value}."); Console.ReadLine(); } } catch (RemoteInvocationException invokeExcp) { logger.LogError($"JSON RPC invoke exception, error code={invokeExcp.ErrorCode}, msg={invokeExcp.Message}."); } }
public Task <TResult> InvokeWithParameterObjectAsync <TResult>(string targetName, object argument = null, CancellationToken cancellationToken = default) => _rpc.InvokeWithParameterObjectAsync <TResult>(targetName, argument, cancellationToken);