Example #1
0
        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;
        }
Example #2
0
        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);
        }