protected async Task HandleEvaluateRequest(
EvaluateRequestArguments evaluateParams,
RequestContext <EvaluateResponseBody> requestContext)
{
// TODO: This needs to respect debug mode!
var evaluateResponse =
new EvaluateResponseBody
{
Result = "",
VariablesReference = 0
};
if (this.commandLineInputTask != null)
{
this.commandLineInputTask.SetResult(evaluateParams.Expression);
await requestContext.SendResult(evaluateResponse);
}
else
{
// Check for special commands
if (string.Equals("!ctrlc", evaluateParams.Expression, StringComparison.CurrentCultureIgnoreCase))
{
this.powerShellContext.AbortExecution();
await requestContext.SendResult(evaluateResponse);
}
else if (string.Equals("!break", evaluateParams.Expression, StringComparison.CurrentCultureIgnoreCase))
{
// TODO: Need debugger commands interface
//editorSession.DebugService.Break();
await requestContext.SendResult(evaluateResponse);
}
else
{
// We don't await the result of the execution here because we want
// to be able to receive further messages while the current script
// is executing. This important in cases where the pipeline thread
// gets blocked by something in the script like a prompt to the user.
var executeTask =
this.powerShellContext.ExecuteScriptString(
evaluateParams.Expression,
writeInputToHost: true,
writeOutputToHost: true,
addToHistory: true);
// Return the execution result after the task completes so that the
// caller knows when command execution completed.
Task unusedTask =
executeTask.ContinueWith(
(task) =>
{
// Return an empty result since the result value is irrelevant
// for this request in the LanguageServer
return
(requestContext.SendResult(
evaluateResponse));
});
}
}
}
public async Task CanSendEvaluateRequest()
{
EvaluateResponseBody evaluateResponseBody =
await LanguageClient.SendRequest <EvaluateResponseBody>(
"evaluate",
new EvaluateRequestArguments
{
Expression = "Get-ChildItem"
});
// These always gets returned so this test really just makes sure we get _any_ response.
Assert.Equal("", evaluateResponseBody.Result);
Assert.Equal(0, evaluateResponseBody.VariablesReference);
}
public override void Evaluate(Response response, dynamic arguments)
{
// expression, frameId, context
int frameId = getInt(arguments, "frameId");
var frame = _framesHandles.Get(frameId, null);
if (frame == null)
{
SendErrorResponse(response, 10001, "No active stackframe");
return;
}
var expression = (string)arguments.expression;
var context = (string)arguments.context;
int id = -1;
OneScript.DebugProtocol.Variable evalResult;
try
{
evalResult = _process.Evaluate(frame, expression);
if (evalResult.IsStructured)
{
var loc = new EvaluatedVariableLocator(expression, frame.ThreadId, frameId);
id = _variableHandles.Create(loc);
}
}
catch (Exception e)
{
evalResult = new OneScript.DebugProtocol.Variable()
{
Presentation = e.Message, Name = "$evalFault"
};
}
if (evalResult.Name.Equals("$evalFault") && context.Equals("hover"))
{
evalResult.Presentation = $"err: {expression}";
}
var protResult = new EvaluateResponseBody(evalResult.Presentation, id)
{
type = evalResult.TypeName
};
SendResponse(response, protResult);
}
public async Task CanSendEvaluateRequestAsync()
{
EvaluateResponseBody evaluateResponseBody =
await PsesLanguageClient
.SendRequest <EvaluateRequestArguments>(
"evaluate",
new EvaluateRequestArguments
{
Expression = "Get-ChildItem"
})
.Returning <EvaluateResponseBody>(CancellationToken.None).ConfigureAwait(false);
// These always gets returned so this test really just makes sure we get _any_ response.
Assert.Equal("", evaluateResponseBody.Result);
Assert.Equal(0, evaluateResponseBody.VariablesReference);
}
public async Task CanSendEvaluateRequestAsync()
{
using CancellationTokenSource cancellationSource = new(millisecondsDelay : 5000);
EvaluateResponseBody evaluateResponseBody =
await PsesLanguageClient
.SendRequest(
"evaluate",
new EvaluateRequestArguments
{
Expression = "Get-ChildItem"
})
.Returning <EvaluateResponseBody>(cancellationSource.Token).ConfigureAwait(true);
// These always gets returned so this test really just makes sure we get _any_ response.
Assert.Equal("", evaluateResponseBody.Result);
Assert.Equal(0, evaluateResponseBody.VariablesReference);
}
public override void Evaluate(Response response, dynamic arguments)
{
// expression, frameId, context
int frameId = getInt(arguments, "frameId");
var frame = _framesHandles.Get(frameId, null);
if (frame == null)
{
SendErrorResponse(response, 10001, "No active stackframe");
return;
}
var expression = (string)arguments.expression;
var context = (string)arguments.context;
if (context != "watch")
{
SendResponse(response);
return;
}
OneScript.DebugProtocol.Variable evalResult;
try
{
evalResult = _process.Evaluate(frame, expression);
}
catch (Exception e)
{
evalResult = new OneScript.DebugProtocol.Variable()
{
Presentation = e.Message
};
}
var protResult = new EvaluateResponseBody(evalResult.Presentation)
{
type = evalResult.TypeName
};
SendResponse(response, protResult);
}
public EvaluateResponse(EvaluateRequest request, bool success, EvaluateResponseBody body, string message = null)
: base(request, success, body, message)
{
}
internal EvaluateResponse(long req_seq, bool success, EvaluateResponseBody body, string message)
: base(req_seq, "evaluate", success, body, message)
{
}
