def OnEvent_exited(self, message):
utils.UserMessage('The debugee exited with status code: {}'.format(
message['body']['exitCode']))
def failure_handler(reason, message):
utils.UserMessage(f'Cannot set value: { reason }', error=True)
def Start(self, launch_variables={}):
self._logger.info("User requested start debug session with %s",
launch_variables)
self._configuration = None
self._adapter = None
current_file = utils.GetBufferFilepath(vim.current.buffer)
launch_config_file = utils.PathToConfigFile(
'.vimspector.json', os.path.dirname(current_file))
if not launch_config_file:
utils.UserMessage(
'Unable to find .vimspector.json. You need to tell '
'vimspector how to launch your application.')
return
with open(launch_config_file, 'r') as f:
database = json.load(f)
configurations = database.get('configurations')
adapters = {}
glob.glob(install.GetGadgetDir(VIMSPECTOR_HOME, install.GetOS()))
for gadget_config_file in PathsToAllGadgetConfigs(
VIMSPECTOR_HOME, current_file):
self._logger.debug(f'Reading gadget config: {gadget_config_file}')
if gadget_config_file and os.path.exists(gadget_config_file):
with open(gadget_config_file, 'r') as f:
adapters.update(json.load(f).get('adapters') or {})
adapters.update(database.get('adapters') or {})
if 'configuration' in launch_variables:
configuration_name = launch_variables.pop('configuration')
elif len(configurations) == 1:
configuration_name = next(iter(configurations.keys()))
else:
configuration_name = utils.SelectFromList(
'Which launch configuration?',
sorted(list(configurations.keys())))
if not configuration_name or configuration_name not in configurations:
return
self._workspace_root = os.path.dirname(launch_config_file)
configuration = configurations[configuration_name]
adapter = configuration.get('adapter')
if isinstance(adapter, str):
adapter = adapters.get(adapter)
# TODO: Do we want some form of persistence ? e.g. self._staticVariables,
# set from an api call like SetLaunchParam( 'var', 'value' ), perhaps also a
# way to load .vimspector.local.json which just sets variables
#
# Additional vars as defined by VSCode:
#
# ${workspaceFolder} - the path of the folder opened in VS Code
# ${workspaceFolderBasename} - the name of the folder opened in VS Code
# without any slashes (/)
# ${file} - the current opened file
# ${relativeFile} - the current opened file relative to workspaceFolder
# ${fileBasename} - the current opened file's basename
# ${fileBasenameNoExtension} - the current opened file's basename with no
# file extension
# ${fileDirname} - the current opened file's dirname
# ${fileExtname} - the current opened file's extension
# ${cwd} - the task runner's current working directory on startup
# ${lineNumber} - the current selected line number in the active file
# ${selectedText} - the current selected text in the active file
# ${execPath} - the path to the running VS Code executable
def relpath(p, relative_to):
if not p:
return ''
return os.path.relpath(p, relative_to)
def splitext(p):
if not p:
return ['', '']
return os.path.splitext(p)
self._variables = {
'dollar': '$', # HACK. Hote '$$' also works.
'workspaceRoot': self._workspace_root,
'workspaceFolder': self._workspace_root,
'gadgetDir': install.GetGadgetDir(VIMSPECTOR_HOME,
install.GetOS()),
'file': current_file,
'relativeFile': relpath(current_file, self._workspace_root),
'fileBasename': os.path.basename(current_file),
'fileBasenameNoExtension':
splitext(os.path.basename(current_file))[0],
'fileDirname': os.path.dirname(current_file),
'fileExtname': splitext(os.path.basename(current_file))[1],
# NOTE: this is the window-local cwd for the current window, *not* Vim's
# working directory.
'cwd': os.getcwd(),
}
self._variables.update(
utils.ParseVariables(adapter.get('variables', {}), self._variables,
USER_CHOICES))
self._variables.update(
utils.ParseVariables(configuration.get('variables', {}),
self._variables, USER_CHOICES))
# Pretend that vars passed to the launch command were typed in by the user
# (they may have been in theory)
# TODO: Is it right that we do this _after_ ParseVariables, rather than
# before ?
USER_CHOICES.update(launch_variables)
self._variables.update(launch_variables)
utils.ExpandReferencesInDict(configuration, self._variables,
USER_CHOICES)
utils.ExpandReferencesInDict(adapter, self._variables, USER_CHOICES)
if not adapter:
utils.UserMessage(
'No adapter configured for {}'.format(configuration_name),
persist=True)
return
self._StartWithConfiguration(configuration, adapter)
def Start(self, launch_variables=None):
# We mutate launch_variables, so don't mutate the default argument.
# https://docs.python-guide.org/writing/gotchas/#mutable-default-arguments
if launch_variables is None:
launch_variables = {}
self._logger.info("User requested start debug session with %s",
launch_variables)
self._configuration = None
self._adapter = None
current_file = utils.GetBufferFilepath(vim.current.buffer)
filetypes = utils.GetBufferFiletypes(vim.current.buffer)
configurations = {}
adapters = {}
glob.glob(install.GetGadgetDir(VIMSPECTOR_HOME))
for gadget_config_file in PathsToAllGadgetConfigs(
VIMSPECTOR_HOME, current_file):
self._logger.debug(f'Reading gadget config: {gadget_config_file}')
if not gadget_config_file or not os.path.exists(
gadget_config_file):
continue
with open(gadget_config_file, 'r') as f:
a = json.loads(minify(f.read())).get('adapters') or {}
adapters.update(a)
for launch_config_file in PathsToAllConfigFiles(
VIMSPECTOR_HOME, current_file, filetypes):
self._logger.debug(
f'Reading configurations from: {launch_config_file}')
if not launch_config_file or not os.path.exists(
launch_config_file):
continue
with open(launch_config_file, 'r') as f:
database = json.loads(minify(f.read()))
adapters.update(database.get('adapters') or {})
configurations.update(database.get('configurations' or {}))
if not configurations:
utils.UserMessage('Unable to find any debug configurations. '
'You need to tell vimspector how to launch your '
'application.')
return
if 'configuration' in launch_variables:
configuration_name = launch_variables.pop('configuration')
elif (len(configurations) == 1
and next(iter(configurations.values())).get("autoselect", True)):
configuration_name = next(iter(configurations.keys()))
else:
# Find a single configuration with 'default' True and autoselect not False
defaults = {
n: c
for n, c in configurations.items()
if c.get('default', False) is True
and c.get('autoselect', True) is not False
}
if len(defaults) == 1:
configuration_name = next(iter(defaults.keys()))
else:
configuration_name = utils.SelectFromList(
'Which launch configuration?',
sorted(configurations.keys()))
if not configuration_name or configuration_name not in configurations:
return
if launch_config_file:
self._workspace_root = os.path.dirname(launch_config_file)
else:
self._workspace_root = os.path.dirname(current_file)
configuration = configurations[configuration_name]
adapter = configuration.get('adapter')
if isinstance(adapter, str):
adapter_dict = adapters.get(adapter)
if adapter_dict is None:
suggested_gadgets = installer.FindGadgetForAdapter(adapter)
if suggested_gadgets:
response = utils.AskForInput(
f"The specified adapter '{adapter}' is not "
"installed. Would you like to install the following gadgets? ",
' '.join(suggested_gadgets))
if response:
new_launch_variables = dict(launch_variables)
new_launch_variables[
'configuration'] = configuration_name
installer.RunInstaller(
self._api_prefix,
False, # Don't leave open
*shlex.split(response),
then=lambda: self.Start(new_launch_variables))
return
elif response is None:
return
utils.UserMessage(
f"The specified adapter '{adapter}' is not "
"available. Did you forget to run "
"'install_gadget.py'?",
persist=True,
error=True)
return
adapter = adapter_dict
# Additional vars as defined by VSCode:
#
# ${workspaceFolder} - the path of the folder opened in VS Code
# ${workspaceFolderBasename} - the name of the folder opened in VS Code
# without any slashes (/)
# ${file} - the current opened file
# ${relativeFile} - the current opened file relative to workspaceFolder
# ${fileBasename} - the current opened file's basename
# ${fileBasenameNoExtension} - the current opened file's basename with no
# file extension
# ${fileDirname} - the current opened file's dirname
# ${fileExtname} - the current opened file's extension
# ${cwd} - the task runner's current working directory on startup
# ${lineNumber} - the current selected line number in the active file
# ${selectedText} - the current selected text in the active file
# ${execPath} - the path to the running VS Code executable
def relpath(p, relative_to):
if not p:
return ''
return os.path.relpath(p, relative_to)
def splitext(p):
if not p:
return ['', '']
return os.path.splitext(p)
variables = {
'dollar': '$', # HACK. Hote '$$' also works.
'workspaceRoot': self._workspace_root,
'workspaceFolder': self._workspace_root,
'gadgetDir': install.GetGadgetDir(VIMSPECTOR_HOME),
'file': current_file,
}
calculus = {
'relativeFile':
lambda: relpath(current_file, self._workspace_root),
'fileBasename':
lambda: os.path.basename(current_file),
'fileBasenameNoExtension':
lambda: splitext(os.path.basename(current_file))[0],
'fileDirname':
lambda: os.path.dirname(current_file),
'fileExtname':
lambda: splitext(os.path.basename(current_file))[1],
# NOTE: this is the window-local cwd for the current window, *not* Vim's
# working directory.
'cwd':
os.getcwd,
'unusedLocalPort':
utils.GetUnusedLocalPort,
}
# Pretend that vars passed to the launch command were typed in by the user
# (they may have been in theory)
USER_CHOICES.update(launch_variables)
variables.update(launch_variables)
try:
variables.update(
utils.ParseVariables(adapter.get('variables', {}), variables,
calculus, USER_CHOICES))
variables.update(
utils.ParseVariables(configuration.get('variables', {}),
variables, calculus, USER_CHOICES))
utils.ExpandReferencesInDict(configuration, variables, calculus,
USER_CHOICES)
utils.ExpandReferencesInDict(adapter, variables, calculus,
USER_CHOICES)
except KeyboardInterrupt:
self._Reset()
return
if not adapter:
utils.UserMessage(
'No adapter configured for {}'.format(configuration_name),
persist=True)
return
self._StartWithConfiguration(configuration, adapter)
def _PrepareAttach(self, adapter_config, launch_config):
atttach_config = adapter_config.get('attach')
if not atttach_config:
return
if 'remote' in atttach_config:
# FIXME: We almost want this to feed-back variables to be expanded later,
# e.g. expand variables when we use them, not all at once. This would
# remove the whole %PID% hack.
remote = atttach_config['remote']
remote_exec_cmd = self._GetRemoteExecCommand(remote)
# FIXME: Why does this not use self._GetCommands ?
pid_cmd = remote_exec_cmd + remote['pidCommand']
self._logger.debug('Getting PID: %s', pid_cmd)
pid = subprocess.check_output(pid_cmd).decode('utf-8').strip()
self._logger.debug('Got PID: %s', pid)
if not pid:
# FIXME: We should raise an exception here or something
utils.UserMessage('Unable to get PID', persist=True)
return
if 'initCompleteCommand' in remote:
initcmd = remote_exec_cmd + remote['initCompleteCommand'][:]
for index, item in enumerate(initcmd):
initcmd[index] = item.replace('%PID%', pid)
self._on_init_complete_handlers.append(
lambda: subprocess.check_call(initcmd))
commands = self._GetCommands(remote, 'attach')
for command in commands:
cmd = remote_exec_cmd + command
for index, item in enumerate(cmd):
cmd[index] = item.replace('%PID%', pid)
self._logger.debug('Running remote app: %s', cmd)
self._remote_term = terminal.LaunchTerminal(
self._api_prefix, {
'args': cmd,
'cwd': os.getcwd()
}, self._codeView._window, self._remote_term)
else:
if atttach_config['pidSelect'] == 'ask':
prop = atttach_config['pidProperty']
if prop not in launch_config:
pid = utils.AskForInput('Enter PID to attach to: ')
if pid is None:
return
launch_config[prop] = pid
return
elif atttach_config['pidSelect'] == 'none':
return
raise ValueError('Unrecognised pidSelect {0}'.format(
atttach_config['pidSelect']))
def OnEvent_process(self, message):
utils.UserMessage('The debugee was started: {}'.format(
message['body']['name']))
def OnEvent_terminated(self, message):
# We will handle this when the server actually exists
utils.UserMessage("Debugging was terminated by the server.")
def DownFrame(self):
frame = self._GetFrameOffset(-1)
if not frame:
utils.UserMessage('Bottom of stack')
else:
self._JumpToFrame(frame, 'down')
def Start(self, launch_variables={}):
self._configuration = None
self._adapter = None
launch_config_file = utils.PathToConfigFile('.vimspector.json')
if not launch_config_file:
utils.UserMessage(
'Unable to find .vimspector.json. You need to tell '
'vimspector how to launch your application')
return
with open(launch_config_file, 'r') as f:
database = json.load(f)
configurations = database.get('configurations')
adapters = {}
for gadget_config_file in [
install.GetGadgetConfigFile(VIMSPECTOR_HOME),
utils.PathToConfigFile('.gadgets.json')
]:
if gadget_config_file and os.path.exists(gadget_config_file):
with open(gadget_config_file, 'r') as f:
adapters.update(json.load(f).get('adapters') or {})
adapters.update(database.get('adapters') or {})
if len(configurations) == 1:
configuration_name = next(iter(configurations.keys()))
else:
configuration_name = utils.SelectFromList(
'Which launch configuration?',
sorted(list(configurations.keys())))
if not configuration_name or configuration_name not in configurations:
return
self._workspace_root = os.path.dirname(launch_config_file)
configuration = configurations[configuration_name]
adapter = configuration.get('adapter')
if isinstance(adapter, str):
adapter = adapters.get(adapter)
# TODO: Do we want some form of persistence ? e.g. self._staticVariables,
# set from an api call like SetLaunchParam( 'var', 'value' ), perhaps also a
# way to load .vimspector.local.json which just sets variables
self._variables = {
'dollar': '$', # HACK. Hote '$$' also works.
'workspaceRoot': self._workspace_root,
'gadgetDir': install.GetGadgetDir(VIMSPECTOR_HOME, install.GetOS())
}
self._variables.update(
utils.ParseVariables(adapter.get('variables', {})))
self._variables.update(
utils.ParseVariables(configuration.get('variables', {})))
self._variables.update(launch_variables)
utils.ExpandReferencesInDict(configuration, self._variables)
utils.ExpandReferencesInDict(adapter, self._variables)
if not adapter:
utils.UserMessage(
'No adapter configured for {}'.format(configuration_name),
persist=True)
return
self._StartWithConfiguration(configuration, adapter)
def consume_threads(message):
requesting = False
if self._requesting_threads == StackTraceView.ThreadRequestState.PENDING:
# We may have hit a thread event, so try again.
self._requesting_threads = StackTraceView.ThreadRequestState.NO
self.LoadThreads(*self._pending_thread_request)
requesting = True
self._requesting_threads = StackTraceView.ThreadRequestState.NO
self._pending_thread_request = None
if not (message.get('body') or {}).get('threads'):
# This is a protocol error. It is required to return at least one!
utils.UserMessage('Protocol error: Server returned no threads',
persist=False,
error=True)
return
existing_threads = self._threads[:]
self._threads.clear()
if stopEvent is not None:
stoppedThreadId = stopEvent.get('threadId')
allThreadsStopped = stopEvent.get('allThreadsStopped', False)
# FIXME: This is horribly inefficient
for t in message['body']['threads']:
thread = None
for existing_thread in existing_threads:
if existing_thread.id == t['id']:
thread = existing_thread
thread.Update(t)
break
if not thread:
thread = Thread(t)
self._threads.append(thread)
# If the threads were requested due to a stopped event, update any
# stopped thread state. Note we have to do this here (rather than in the
# stopped event handler) because we must apply this event to any new
# threads that are received here.
if stopEvent:
if allThreadsStopped:
thread.Paused(stopEvent)
elif stoppedThreadId is not None and thread.id == stoppedThreadId:
thread.Paused(stopEvent)
# If this is a stopped event, load the stack trace for the "current"
# thread. Don't do this on other thrads requests because some servers
# just break when that happens.
#
# Don't do this if we're also satisfying a cached request already (we'll
# do it then)
if infer_current_frame and not requesting:
if thread.id == self._current_thread:
if thread.CanExpand():
self._LoadStackTrace(thread, True, reason)
requesting = True
elif self._current_thread is None:
self._current_thread = thread.id
if thread.CanExpand():
self._LoadStackTrace(thread, True, reason)
requesting = True
if not requesting:
self._DrawThreads()
def UpFrame(self):
frame = self._GetFrameOffset(1)
if not frame:
utils.UserMessage('Top of stack')
else:
self._JumpToFrame(frame, 'up')
def Abort():
_ResetInstaller()
from vimspector import utils
utils.UserMessage( 'Vimspector installation aborted',
persist = True,
error = True )
def OnEvent_exited(self, message):
utils.UserMessage('The debuggee exited with status code: {}'.format(
message['body']['exitCode']))
self._stackTraceView.OnExited(message)
self._codeView.SetCurrentFrame(None)
def _StartDebugAdapter(self):
self._splash_screen = utils.DisplaySplash(self._api_prefix,
self._splash_screen,
"Starting debug adapter...")
if self._connection:
utils.UserMessage(
'The connection is already created. Please try again',
persist=True)
return
# There is the problem with the current flow when we try to use a debugger
# which is located fully on the remote server e.g container or SSH Server.
# The problem is in the order: it tries to connect to debugger before it is even started
# To solve that problem, I offer adding an optional boolean key "bootstrap" to a configuration.
# If we have that key, we should perform launch or attach commands to first bootstrap a remote debugger.
# Then we can skip that step in the _Launch() function
if self._adapter.get('bootstrap'):
self._BootstrapRemoteDebugger()
self._logger.info('Starting debug adapter with: %s',
json.dumps(self._adapter))
self._init_complete = False
self._on_init_complete_handlers = []
self._launch_complete = False
self._run_on_server_exit = None
self._connection_type = 'job'
if 'port' in self._adapter:
self._connection_type = 'channel'
if self._adapter['port'] == 'ask':
port = utils.AskForInput('Enter port to connect to: ')
if port is None:
self._Reset()
return
self._adapter['port'] = port
self._connection_type = self._api_prefix + self._connection_type
# TODO: Do we actually need to copy and update or does Vim do that?
env = os.environ.copy()
if 'env' in self._adapter:
env.update(self._adapter['env'])
self._adapter['env'] = env
if 'cwd' not in self._adapter:
self._adapter['cwd'] = os.getcwd()
vim.vars['_vimspector_adapter_spec'] = self._adapter
if not vim.eval("vimspector#internal#{}#StartDebugSession( "
" g:_vimspector_adapter_spec "
")".format(self._connection_type)):
self._logger.error("Unable to start debug server")
self._splash_screen = utils.DisplaySplash(
self._api_prefix, self._splash_screen,
"Unable to start adapter")
else:
self._connection = debug_adapter_connection.DebugAdapterConnection(
self, lambda msg: utils.Call(
"vimspector#internal#{}#Send".format(self._connection_type
), msg))
self._logger.info('Debug Adapter Started')
def _StartDebugAdapter( self ):
self._splash_screen = utils.DisplaySplash(
self._api_prefix,
self._splash_screen,
"Starting debug adapter..." )
if self._connection:
utils.UserMessage( 'The connection is already created. Please try again',
persist = True )
return
self._logger.info( 'Starting debug adapter with: %s',
json.dumps( self._adapter ) )
self._init_complete = False
self._launch_complete = False
self._run_on_server_exit = None
self._connection_type = 'job'
if 'port' in self._adapter:
self._connection_type = 'channel'
if self._adapter[ 'port' ] == 'ask':
port = utils.AskForInput( 'Enter port to connect to: ' )
if port is None:
self._Reset()
return
self._adapter[ 'port' ] = port
self._connection_type = self._api_prefix + self._connection_type
self._logger.debug( f"Connection Type: { self._connection_type }" )
self._adapter[ 'env' ] = self._adapter.get( 'env', {} )
if 'cwd' not in self._adapter:
self._adapter[ 'cwd' ] = os.getcwd()
vim.vars[ '_vimspector_adapter_spec' ] = self._adapter
if not vim.eval( "vimspector#internal#{}#StartDebugSession( "
" g:_vimspector_adapter_spec "
")".format( self._connection_type ) ):
self._logger.error( "Unable to start debug server" )
self._splash_screen = utils.DisplaySplash( self._api_prefix,
self._splash_screen,
"Unable to start adapter" )
else:
if 'custom_handler' in self._adapter:
spec = self._adapter[ 'custom_handler' ]
if isinstance( spec, dict ):
module = spec[ 'module' ]
cls = spec[ 'class' ]
else:
module, cls = spec.rsplit( '.', 1 )
CustomHandler = getattr( importlib.import_module( module ), cls )
handlers = [ CustomHandler( self ), self ]
else:
handlers = [ self ]
self._connection = debug_adapter_connection.DebugAdapterConnection(
handlers,
lambda msg: utils.Call(
"vimspector#internal#{}#Send".format( self._connection_type ),
msg ) )
self._logger.info( 'Debug Adapter Started' )
def Start( self, launch_variables = {} ):
self._logger.info( "User requested start debug session with %s",
launch_variables )
self._configuration = None
self._adapter = None
launch_config_file = utils.PathToConfigFile( '.vimspector.json' )
if not launch_config_file:
utils.UserMessage( 'Unable to find .vimspector.json. You need to tell '
'vimspector how to launch your application' )
return
with open( launch_config_file, 'r' ) as f:
database = json.load( f )
configurations = database.get( 'configurations' )
adapters = {}
for gadget_config_file in [ install.GetGadgetConfigFile( VIMSPECTOR_HOME ),
utils.PathToConfigFile( '.gadgets.json' ) ]:
if gadget_config_file and os.path.exists( gadget_config_file ):
with open( gadget_config_file, 'r' ) as f:
adapters.update( json.load( f ).get( 'adapters' ) or {} )
adapters.update( database.get( 'adapters' ) or {} )
if len( configurations ) == 1:
configuration_name = next( iter( configurations.keys() ) )
else:
configuration_name = utils.SelectFromList(
'Which launch configuration?',
sorted( list( configurations.keys() ) ) )
if not configuration_name or configuration_name not in configurations:
return
self._workspace_root = os.path.dirname( launch_config_file )
configuration = configurations[ configuration_name ]
adapter = configuration.get( 'adapter' )
if isinstance( adapter, str ):
adapter = adapters.get( adapter )
# TODO: Do we want some form of persistence ? e.g. self._staticVariables,
# set from an api call like SetLaunchParam( 'var', 'value' ), perhaps also a
# way to load .vimspector.local.json which just sets variables
#
# Additional vars as defined by VSCode:
#
# ${workspaceFolder} - the path of the folder opened in VS Code
# ${workspaceFolderBasename} - the name of the folder opened in VS Code
# without any slashes (/)
# ${file} - the current opened file
# ${relativeFile} - the current opened file relative to workspaceFolder
# ${fileBasename} - the current opened file's basename
# ${fileBasenameNoExtension} - the current opened file's basename with no
# file extension
# ${fileDirname} - the current opened file's dirname
# ${fileExtname} - the current opened file's extension
# ${cwd} - the task runner's current working directory on startup
# ${lineNumber} - the current selected line number in the active file
# ${selectedText} - the current selected text in the active file
# ${execPath} - the path to the running VS Code executable
current_file = utils.GetBufferFilepath( vim.current.buffer )
self._variables = {
'dollar': '$', # HACK. Hote '$$' also works.
'workspaceRoot': self._workspace_root,
'workspaceFolder': self._workspace_root,
'gadgetDir': install.GetGadgetDir( VIMSPECTOR_HOME, install.GetOS() ),
'file': current_file,
'relativeFile': os.path.relpath( current_file, self._workspace_root ),
'fileBasename': os.path.basename( current_file ),
'fileBasenameNoExtension':
os.path.splitext( os.path.basename( current_file ) )[ 0 ],
'fileDirname': os.path.dirname( current_file ),
'fileExtname':
os.path.splitext( os.path.basename( current_file ) )[ 1 ],
'cwd': os.getcwd(),
}
self._variables.update(
utils.ParseVariables( adapter.get( 'variables', {} ),
self._variables ) )
self._variables.update(
utils.ParseVariables( configuration.get( 'variables', {} ),
self._variables ) )
self._variables.update( launch_variables )
utils.ExpandReferencesInDict( configuration, self._variables )
utils.ExpandReferencesInDict( adapter, self._variables )
if not adapter:
utils.UserMessage( 'No adapter configured for {}'.format(
configuration_name ), persist=True )
return
self._StartWithConfiguration( configuration, adapter )