def on_pause_request(self, request): """ :param PauseRequest request: """ # : :type pause_response: PauseResponse pause_response = base_schema.build_response(request) self.write_to_client_message(pause_response)
def on_setBreakpoints_request(self, request): """ :param SetBreakpointsRequest request: """ from robotframework_debug_adapter.dap.dap_schema import SourceBreakpoint from robotframework_debug_adapter.dap.dap_schema import Breakpoint from robotframework_debug_adapter.dap.dap_schema import ( SetBreakpointsResponseBody, ) if self._launch_process is None: # Just acknowledge that no breakpoints are valid. breakpoints = [] if request.arguments.breakpoints: for bp in request.arguments.breakpoints: source_breakpoint = SourceBreakpoint(**bp) breakpoints.append( Breakpoint( verified=False, line=source_breakpoint.line, source=request.arguments.source, ).to_dict()) self.write_to_client_message( base_schema.build_response( request, kwargs=dict(body=SetBreakpointsResponseBody( breakpoints=breakpoints)), )) return self._launch_process.resend_request_to_robot(request)
def on_launch_request(self, request): """ :param LaunchRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response from robotframework_debug_adapter.launch_process import LaunchProcess # : :type launch_response: LaunchResponse launch_response = build_response(request) launch_process = None try: self._launched_process = launch_process = LaunchProcess( request, launch_response, self) if launch_process.valid: # If on debug mode the launch is only considered finished when the connection # from the other side finishes properly. launch_process.launch() except Exception as e: log.exception("Error launching.") launch_response.success = False launch_response.message = str(e) self.write_message(launch_response) # acknowledge it if launch_process is not None: launch_process.after_launch_response_sent()
def on_configurationDone_request(self, request): """ :param ConfigurationDoneRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response configuration_done_response = build_response(request) launch_process = self._launch_process if launch_process is None: configuration_done_response.success = False configuration_done_response.message = ( "Launch is not done (configurationDone uncomplete).") self.write_to_client_message(configuration_done_response) return if launch_process.send_and_wait_for_configuration_done_request(): # : :type configuration_done_response: ConfigurationDoneResponse self.write_to_client_message( configuration_done_response) # acknowledge it else: # timed out configuration_done_response.success = False configuration_done_response.message = ( "Timed out waiting for configurationDone event.") self.write_to_client_message(configuration_done_response)
def on_launch_request(self, request): """ :param LaunchRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response from robotframework_debug_adapter.launch_process import LaunchProcess from robotframework_debug_adapter.dap.dap_schema import InitializedEvent # : :type launch_response: LaunchResponse launch_response = build_response(request) launch_process = None try: self._launch_process = launch_process = LaunchProcess( request, launch_response, self) if launch_process.valid: # If on debug mode the launch is only considered finished when the connection # from the other side finishes properly. launch_process.launch() # Only write the initialized event after the process has been # launched so that we can forward breakpoints directly to the # target. self.write_to_client_message(InitializedEvent()) except Exception as e: log.exception("Error launching.") launch_response.success = False launch_response.message = str(e) self.write_to_client_message(launch_response) # acknowledge it if launch_process is not None: launch_process.after_launch_response_sent()
def _evaluate_response(self, request, result, error_message=""): from robotframework_debug_adapter.dap.dap_schema import EvaluateResponseBody from robotframework_debug_adapter.dap.dap_base_schema import build_response body = EvaluateResponseBody(result=result, variablesReference=0) if not error_message: return build_response(request, kwargs={"body": body}) else: response = build_response( request, kwargs={ "body": body, "success": False, "message": error_message }, ) return response
def on_configurationDone_request(self, request): """ :param ConfigurationDoneRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response # : :type configuration_done_response: ConfigurationDoneResponse configuration_done_response = build_response(request) self.write_message(configuration_done_response) # acknowledge it
def on_configurationDone_request(self, request): """ :param ConfigurationDoneRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response response = build_response(request) self.write_message(response) self.configuration_done.set()
def on_stepIn_request(self, request): from robotframework_debug_adapter.dap.dap_base_schema import build_response response = build_response(request) if self._debugger_impl: self._debugger_impl.step_in() else: get_log().info("Unable to step in (no debug mode).") self.write_message(response)
def on_disconnect_request(self, request): """ :param DisconnectRequest request: """ # : :type disconnect_response: DisconnectResponse disconnect_response = base_schema.build_response(request) if self._launch_process is not None: self._launch_process.disconnect(request) self.write_to_client_message(disconnect_response)
def on_threads_request(self, request): """ :param ThreadsRequest request: """ from robotframework_debug_adapter.dap.dap_schema import Thread from robotframework_debug_adapter.dap.dap_schema import ThreadsResponseBody threads = [Thread(0, "Main Thread").to_dict()] kwargs = {"body": ThreadsResponseBody(threads)} # : :type threads_response: ThreadsResponse threads_response = base_schema.build_response(request, kwargs) self.write_message(threads_response)
def on_initialize_request(self, request): """ :param InitializeRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response # : :type initialize_response: InitializeResponse # : :type body: Capabilities self._initialize_request_arguments = request.arguments initialize_response = build_response(request) self._supports_run_in_terminal = request.arguments.supportsRunInTerminalRequest body = initialize_response.body body.supportsConfigurationDoneRequest = True self.write_to_client_message(initialize_response)
def on_continue_request(self, request): from robotframework_debug_adapter.dap.dap_base_schema import build_response from robotframework_debug_adapter.dap.dap_schema import ContinueResponseBody response = build_response( request, kwargs=dict(body=ContinueResponseBody(allThreadsContinued=True)) ) if self._debugger_impl: self._debugger_impl.step_continue() else: get_log().info("Unable to continue (no debug mode).") self.write_message(response)
def on_evaluate_request(self, request): """ :param EvaluateRequest request: """ if self._launch_process is not None: if request.arguments.context == "repl": self._launch_process.send_to_stdin( request.arguments.expression) evaluate_response = base_schema.build_response( request, kwargs={"body": { "result": "", "variablesReference": 0 }}) self.write_to_client_message(evaluate_response)
def on_scopes_request(self, request): """ :param ScopesRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response from robotframework_debug_adapter.dap.dap_schema import ScopesResponseBody frame_id = request.arguments.frameId if self._debugger_impl: scopes = self._debugger_impl.get_scopes(frame_id) else: scopes = [] get_log().info("Unable to step in (no debug mode).") body = ScopesResponseBody(scopes if scopes else []) response = build_response(request, kwargs=dict(body=body)) self.write_message(response)
def on_variables_request(self, request): """ :param VariablesRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response from robotframework_debug_adapter.dap.dap_schema import VariablesResponseBody variables_reference = request.arguments.variablesReference if self._debugger_impl: variables = self._debugger_impl.get_variables(variables_reference) else: variables = [] get_log().info("Unable to step in (no debug mode).") body = VariablesResponseBody(variables if variables else []) response = build_response(request, kwargs=dict(body=body)) self.write_message(response)
def on_stackTrace_request(self, request): """ :param StackTraceRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response from robotframework_debug_adapter.dap.dap_schema import StackTraceResponseBody thread_id = request.arguments.threadId if self._debugger_impl: frames = self._debugger_impl.get_frames(thread_id) else: frames = [] get_log().info("Unable to get stack trace (no debug mode).") body = StackTraceResponseBody(stackFrames=frames if frames else []) response = build_response(request, kwargs=dict(body=body)) self.write_message(response)
def on_setBreakpoints_request(self, request): from robotframework_debug_adapter.dap.dap_schema import SourceBreakpoint from robotframework_debug_adapter.dap.dap_schema import Breakpoint from robotframework_debug_adapter.dap.dap_schema import ( SetBreakpointsResponseBody, ) from robotframework_debug_adapter.dap import dap_base_schema from robotframework_debug_adapter import file_utils from robotframework_debug_adapter.debugger_impl import RobotBreakpoint from robocode_ls_core.robotframework_log import get_logger log = get_logger("robotframework_debug_adapter.run_robot__main__.py") # Just acknowledge that no breakpoints are valid. breakpoints = [] robot_breakpoints = [] source = request.arguments.source path = source.path filename = file_utils.norm_file_to_server(path) log.info("Normalized %s to %s", path, filename) if request.arguments.breakpoints: for bp in request.arguments.breakpoints: source_breakpoint = SourceBreakpoint(**bp) breakpoints.append( Breakpoint(verified=True, line=source_breakpoint.line, source=source).to_dict()) robot_breakpoints.append( RobotBreakpoint(source_breakpoint.line)) if self._debugger_impl: self._debugger_impl.set_breakpoints(filename, robot_breakpoints) else: if robot_breakpoints: get_log().info("Unable to set breakpoints (no debug mode).") self.write_message( dap_base_schema.build_response( request, kwargs=dict(body=SetBreakpointsResponseBody( breakpoints=breakpoints)), ))
def on_setBreakpoints_request(self, request): from robotframework_debug_adapter.dap.dap_schema import SourceBreakpoint from robotframework_debug_adapter.dap.dap_schema import Breakpoint from robotframework_debug_adapter.dap.dap_schema import ( SetBreakpointsResponseBody, ) from robotframework_debug_adapter.dap import dap_base_schema from robotframework_debug_adapter import file_utils from robotframework_debug_adapter.debugger_impl import RobotBreakpoint # Just acknowledge that no breakpoints are valid. breakpoints = [] robot_breakpoints = [] source = request.arguments.source path = source.path if IS_PY2: path = path.encode(file_utils.file_system_encoding) filename = file_utils.norm_file_to_server(path) if request.arguments.breakpoints: for bp in request.arguments.breakpoints: source_breakpoint = SourceBreakpoint(**bp) breakpoints.append( Breakpoint( verified=True, line=source_breakpoint.line, source=source ).to_dict() ) robot_breakpoints.append(RobotBreakpoint(source_breakpoint.line)) if self._debugger_impl: self._debugger_impl.set_breakpoints(filename, robot_breakpoints) else: if robot_breakpoints: get_log().info("Unable to set breakpoints (no debug mode).") self.write_message( dap_base_schema.build_response( request, kwargs=dict(body=SetBreakpointsResponseBody(breakpoints=breakpoints)), ) )
def on_initialize_request(self, request): """ :param InitializeRequest request: """ from robotframework_debug_adapter.dap.dap_base_schema import build_response from robotframework_debug_adapter.dap.dap_schema import InitializedEvent from robotframework_debug_adapter.dap.dap_schema import ProcessEvent from robotframework_debug_adapter.dap.dap_schema import ProcessEventBody # : :type initialize_response: InitializeResponse # : :type capabilities: Capabilities self._initialize_request_arguments = request.arguments initialize_response = build_response(request) capabilities = initialize_response.body capabilities.supportsConfigurationDoneRequest = True self.write_message(initialize_response) self.write_message( ProcessEvent( ProcessEventBody(sys.executable, systemProcessId=os.getpid()))) self.write_message(InitializedEvent())
def test_schema(): from robotframework_debug_adapter.dap import dap_base_schema from robotframework_debug_adapter.dap.dap_schema import ( InitializeRequest, InitializeRequestArguments, InitializeResponse, Capabilities, InitializedEvent, ) json_msg = """ { "arguments": { "adapterID": "PyDev", "clientID": "vscode", "clientName": "Visual Studio Code", "columnsStartAt1": true, "linesStartAt1": true, "locale": "en-us", "pathFormat": "path", "supportsRunInTerminalRequest": true, "supportsVariablePaging": true, "supportsVariableType": true }, "command": "initialize", "seq": 1, "type": "request" }""" initialize_request = dap_base_schema.from_json(json_msg) assert initialize_request.__class__ == InitializeRequest assert initialize_request.arguments.__class__ == InitializeRequestArguments assert initialize_request.arguments.adapterID == "PyDev" assert initialize_request.command == "initialize" assert initialize_request.type == "request" assert initialize_request.seq == 1 response = dap_base_schema.build_response(initialize_request) assert response.__class__ == InitializeResponse assert response.seq == -1 # Must be set before sending assert response.command == "initialize" assert response.type == "response" assert response.body.__class__ == Capabilities assert response.to_dict() == { "seq": -1, "type": "response", "request_seq": 1, "success": True, "command": "initialize", "body": {}, } capabilities = response.body # : :type capabilities: Capabilities capabilities.supportsCompletionsRequest = True assert response.to_dict() == { "seq": -1, "type": "response", "request_seq": 1, "success": True, "command": "initialize", "body": { "supportsCompletionsRequest": True }, } initialize_event = InitializedEvent() assert initialize_event.to_dict() == { "seq": -1, "type": "event", "event": "initialized", }
def on_setExceptionBreakpoints_request(self, request): response = base_schema.build_response(request) self.write_to_client_message(response)