async Task SetBreakpoint(SessionId sessionId, DebugStore store, BreakpointRequest req, bool sendResolvedEvent, CancellationToken token)
{
var context = GetContext(sessionId);
if (req.Locations.Any())
{
Log("debug", $"locations already loaded for {req.Id}");
return;
}
var comparer = new SourceLocation.LocationComparer();
// if column is specified the frontend wants the exact matches
// and will clear the bp if it isn't close enoug
var locations = store.FindBreakpointLocations(req)
.Distinct(comparer)
.Where(l => l.Line == req.Line && (req.Column == 0 || l.Column == req.Column))
.OrderBy(l => l.Column)
.GroupBy(l => l.Id);
logger.LogDebug("BP request for '{req}' runtime ready {context.RuntimeReady}", req, GetContext(sessionId).IsRuntimeReady);
var breakpoints = new List <Breakpoint>();
foreach (var sourceId in locations)
{
var loc = sourceId.First();
var bp = await SetMonoBreakpoint(sessionId, req.Id, loc, token);
// If we didn't successfully enable the breakpoint
// don't add it to the list of locations for this id
if (bp.State != BreakpointState.Active)
{
continue;
}
breakpoints.Add(bp);
var resolvedLocation = new
{
breakpointId = req.Id,
location = loc.AsLocation()
};
if (sendResolvedEvent)
{
SendEvent(sessionId, "Debugger.breakpointResolved", JObject.FromObject(resolvedLocation), token);
}
}
req.Locations.AddRange(breakpoints);
return;
}
protected override async Task <bool> AcceptCommand(MessageId id, string method, JObject args, CancellationToken token)
{
// Inspector doesn't use the Target domain or sessions
// so we try to init immediately
if (hideWebDriver && id == SessionId.Null)
{
await DeleteWebDriver(id, token);
}
if (!contexts.TryGetValue(id, out var context))
{
return(false);
}
switch (method)
{
case "Target.attachToTarget":
{
var resp = await SendCommand(id, method, args, token);
await DeleteWebDriver(new SessionId(resp.Value["sessionId"]?.ToString()), token);
break;
}
case "Debugger.enable":
{
var resp = await SendCommand(id, method, args, token);
context.DebuggerId = resp.Value["debuggerId"]?.ToString();
if (await IsRuntimeAlreadyReadyAlready(id, token))
{
await RuntimeReady(id, token);
}
SendResponse(id, resp, token);
return(true);
}
case "Debugger.getScriptSource":
{
var script = args?["scriptId"]?.Value <string>();
return(await OnGetScriptSource(id, script, token));
}
case "Runtime.compileScript":
{
var exp = args?["expression"]?.Value <string>();
if (exp.StartsWith("//dotnet:", StringComparison.Ordinal))
{
OnCompileDotnetScript(id, token);
return(true);
}
break;
}
case "Debugger.getPossibleBreakpoints":
{
var resp = await SendCommand(id, method, args, token);
if (resp.IsOk && resp.Value["locations"].HasValues)
{
SendResponse(id, resp, token);
return(true);
}
var start = SourceLocation.Parse(args?["start"] as JObject);
//FIXME support variant where restrictToFunction=true and end is omitted
var end = SourceLocation.Parse(args?["end"] as JObject);
if (start != null && end != null && await GetPossibleBreakpoints(id, start, end, token))
{
return(true);
}
SendResponse(id, resp, token);
return(true);
}
case "Debugger.setBreakpoint":
{
break;
}
case "Debugger.setBreakpointByUrl":
{
var resp = await SendCommand(id, method, args, token);
if (!resp.IsOk)
{
SendResponse(id, resp, token);
return(true);
}
var bpid = resp.Value["breakpointId"]?.ToString();
var locations = resp.Value["locations"]?.Values <object>();
var request = BreakpointRequest.Parse(bpid, args);
// is the store done loading?
var loaded = context.Source.Task.IsCompleted;
if (!loaded)
{
// Send and empty response immediately if not
// and register the breakpoint for resolution
context.BreakpointRequests[bpid] = request;
SendResponse(id, resp, token);
}
if (await IsRuntimeAlreadyReadyAlready(id, token))
{
var store = await RuntimeReady(id, token);
Log("verbose", $"BP req {args}");
await SetBreakpoint(id, store, request, !loaded, token);
}
if (loaded)
{
// we were already loaded so we should send a response
// with the locations included and register the request
context.BreakpointRequests[bpid] = request;
var result = Result.OkFromObject(request.AsSetBreakpointByUrlResponse(locations));
SendResponse(id, result, token);
}
return(true);
}
case "Debugger.removeBreakpoint":
{
await RemoveBreakpoint(id, args, token);
break;
}
case "Debugger.resume":
{
await OnResume(id, token);
break;
}
case "Debugger.stepInto":
{
return(await Step(id, StepKind.Into, token));
}
case "Debugger.stepOut":
{
return(await Step(id, StepKind.Out, token));
}
case "Debugger.stepOver":
{
return(await Step(id, StepKind.Over, token));
}
case "Debugger.evaluateOnCallFrame":
{
if (!DotnetObjectId.TryParse(args?["callFrameId"], out var objectId))
{
return(false);
}
switch (objectId.Scheme)
{
case "scope":
return(await OnEvaluateOnCallFrame(id,
int.Parse(objectId.Value),
args?["expression"]?.Value <string>(), token));
default:
return(false);
}
}
case "Runtime.getProperties":
{
if (!DotnetObjectId.TryParse(args?["objectId"], out var objectId))
{
break;
}
var result = await RuntimeGetProperties(id, objectId, args, token);
SendResponse(id, result, token);
return(true);
}
case "Runtime.releaseObject":
{
if (!(DotnetObjectId.TryParse(args["objectId"], out var objectId) && objectId.Scheme == "cfo_res"))
{
break;
}
await SendMonoCommand(id, MonoCommands.ReleaseObject(objectId), token);
SendResponse(id, Result.OkFromObject(new { }), token);
return(true);
}
case "Debugger.setPauseOnExceptions":
{
string state = args["state"].Value <string>();
await SendMonoCommand(id, MonoCommands.SetPauseOnExceptions(state), token);
// Pass this on to JS too
return(false);
}
// Protocol extensions
case "DotnetDebugger.addSymbolServerUrl":
{
string url = args["url"]?.Value <string>();
if (!String.IsNullOrEmpty(url) && !urlSymbolServerList.Contains(url))
{
urlSymbolServerList.Add(url);
}
SendResponse(id, Result.OkFromObject(new { }), token);
return(true);
}
case "DotnetDebugger.getMethodLocation":
{
Console.WriteLine("set-breakpoint-by-method: " + id + " " + args);
var store = await RuntimeReady(id, token);
string aname = args["assemblyName"]?.Value <string>();
string typeName = args["typeName"]?.Value <string>();
string methodName = args["methodName"]?.Value <string>();
if (aname == null || typeName == null || methodName == null)
{
SendResponse(id, Result.Err("Invalid protocol message '" + args + "'."), token);
return(true);
}
// GetAssemblyByName seems to work on file names
var assembly = store.GetAssemblyByName(aname);
if (assembly == null)
{
assembly = store.GetAssemblyByName(aname + ".exe");
}
if (assembly == null)
{
assembly = store.GetAssemblyByName(aname + ".dll");
}
if (assembly == null)
{
SendResponse(id, Result.Err("Assembly '" + aname + "' not found."), token);
return(true);
}
var type = assembly.GetTypeByName(typeName);
if (type == null)
{
SendResponse(id, Result.Err($"Type '{typeName}' not found."), token);
return(true);
}
var methodInfo = type.Methods.FirstOrDefault(m => m.Name == methodName);
if (methodInfo == null)
{
// Maybe this is an async method, in which case the debug info is attached
// to the async method implementation, in class named:
// `{type_name}/<method_name>::MoveNext`
methodInfo = assembly.TypesByName.Values.SingleOrDefault(t => t.FullName.StartsWith($"{typeName}/<{methodName}>"))?
.Methods.FirstOrDefault(mi => mi.Name == "MoveNext");
}
if (methodInfo == null)
{
SendResponse(id, Result.Err($"Method '{typeName}:{methodName}' not found."), token);
return(true);
}
var src_url = methodInfo.Assembly.Sources.Single(sf => sf.SourceId == methodInfo.SourceId).Url;
SendResponse(id, Result.OkFromObject(new
{
result = new { line = methodInfo.StartLocation.Line, column = methodInfo.StartLocation.Column, url = src_url }
}), token);
return(true);
}
case "Runtime.callFunctionOn":
{
if (!DotnetObjectId.TryParse(args["objectId"], out var objectId))
{
return(false);
}
if (objectId.Scheme == "scope")
{
SendResponse(id,
Result.Exception(new ArgumentException(
$"Runtime.callFunctionOn not supported with scope ({objectId}).")),
token);
return(true);
}
var res = await SendMonoCommand(id, MonoCommands.CallFunctionOn(args), token);
var res_value_type = res.Value?["result"]?["value"]?.Type;
if (res.IsOk && res_value_type == JTokenType.Object || res_value_type == JTokenType.Object)
{
res = Result.OkFromObject(new { result = res.Value["result"]["value"] });
}
SendResponse(id, res, token);
return(true);
}
}
return(false);
}
