def _StartServer(self):
"""Start the Gocode server."""
with self._gocode_lock:
_logger.info('Starting Gocode server')
self._gocode_port = utils.GetUnusedLocalhostPort()
self._gocode_address = '127.0.0.1:{0}'.format(self._gocode_port)
command = [
self._gocode_binary_path, '-s', '-sock', 'tcp', '-addr',
self._gocode_address
]
if _logger.isEnabledFor(logging.DEBUG):
command.append('-debug')
self._gocode_stdout = LOG_FILENAME_FORMAT.format(
port=self._gocode_port, std='stdout')
self._gocode_stderr = LOG_FILENAME_FORMAT.format(
port=self._gocode_port, std='stderr')
with open(self._gocode_stdout, 'w') as stdout:
with open(self._gocode_stderr, 'w') as stderr:
self._gocode_handle = utils.SafePopen(command,
stdout=stdout,
stderr=stderr)
def __init__( self, user_options ):
super( TypeScriptCompleter, self ).__init__( user_options )
# Used to prevent threads from concurrently reading and writing to
# the tsserver process' stdout and stdin
self._lock = Lock()
binarypath = utils.PathToFirstExistingExecutable( [ 'tsserver' ] )
if not binarypath:
_logger.error( BINARY_NOT_FOUND_MESSAGE )
raise RuntimeError( BINARY_NOT_FOUND_MESSAGE )
# Each request sent to tsserver must have a sequence id.
# Responses contain the id sent in the corresponding request.
self._sequenceid = 0
# TSServer ignores the fact that newlines are two characters on Windows
# (\r\n) instead of one on other platforms (\n), so we use the
# universal_newlines option to convert those newlines to \n. See the issue
# https://github.com/Microsoft/TypeScript/issues/3403
# TODO: remove this option when the issue is fixed.
# We also need to redirect the error stream to the output one on Windows.
self._tsserver_handle = utils.SafePopen( binarypath,
stdout = subprocess.PIPE,
stdin = subprocess.PIPE,
stderr = subprocess.STDOUT,
universal_newlines = True )
_logger.info( 'Enabling typescript completion' )
def SafePopen_ReplaceStdinWindowsPIPEOnWindows_test(*args):
utils.SafePopen(['foo'], stdin_windows=subprocess.PIPE)
eq_(
subprocess.Popen.call_args,
call(['foo'],
stdin=subprocess.PIPE,
creationflags=utils.CREATE_NO_WINDOW))
def StartServer(self, request_data):
with self._server_state_mutex:
if self.ServerIsHealthy():
return
# Ensure we cleanup all states.
self._Reset()
LOGGER.info('Starting clangd: %s', self._clangd_command)
self._stderr_file = utils.CreateLogfile('clangd_stderr')
with utils.OpenForStdHandle(self._stderr_file) as stderr:
self._server_handle = utils.SafePopen(self._clangd_command,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=stderr)
self._connection = (
language_server_completer.StandardIOLanguageServerConnection(
self._server_handle.stdin, self._server_handle.stdout,
self.GetDefaultNotificationHandler()))
self._connection.Start()
try:
self._connection.AwaitServerConnection()
except language_server_completer.LanguageServerConnectionTimeout:
LOGGER.error('clangd failed to start, or did not connect '
'successfully')
self.Shutdown()
return
LOGGER.info('clangd started')
self.SendInitialize(request_data)
def _StartServerNoLock( self ):
if self._ServerIsRunning():
return
self._logfile = utils.CreateLogfile( LOGFILE_FORMAT )
tsserver_log = f'-file { self._logfile } -level {_LogLevel()}'
# TSServer gets the configuration for the log file through the
# environment variable 'TSS_LOG'. This seems to be undocumented but
# looking at the source code it seems like this is the way:
# https://github.com/Microsoft/TypeScript/blob/8a93b489454fdcbdf544edef05f73a913449be1d/src/server/server.ts#L136
environ = os.environ.copy()
environ[ 'TSS_LOG' ] = tsserver_log
LOGGER.info( 'TSServer log file: %s', self._logfile )
# We need to redirect the error stream to the output one on Windows.
self._tsserver_handle = utils.SafePopen( self._tsserver_executable,
stdin = subprocess.PIPE,
stdout = subprocess.PIPE,
stderr = subprocess.STDOUT,
env = environ )
LOGGER.info( "TSServer started with PID %s", self._tsserver_handle.pid )
self._tsserver_is_running.set()
utils.StartThread( self._SetServerVersion )
def _SetUpServer( self ):
self._available_completers = {}
self._user_notified_about_crash = False
self._filetypes_with_keywords_loaded = set()
self._server_is_ready_with_cache = False
self._message_poll_request = None
self._user_options = base.GetUserOptions()
self._omnicomp = OmniCompleter( self._user_options )
self._buffers = BufferDict( self._user_options )
self._SetLogLevel()
hmac_secret = os.urandom( HMAC_SECRET_LENGTH )
options_dict = dict( self._user_options )
options_dict[ 'hmac_secret' ] = utils.ToUnicode(
base64.b64encode( hmac_secret ) )
options_dict[ 'server_keep_logfiles' ] = self._user_options[
'keep_logfiles' ]
# The temp options file is deleted by ycmd during startup.
with NamedTemporaryFile( delete = False, mode = 'w+' ) as options_file:
json.dump( options_dict, options_file )
server_port = utils.GetUnusedLocalhostPort()
BaseRequest.server_location = 'http://127.0.0.1:' + str( server_port )
BaseRequest.hmac_secret = hmac_secret
try:
python_interpreter = paths.PathToPythonInterpreter()
except RuntimeError as error:
error_message = (
"Unable to start the ycmd server. {0}. "
"Correct the error then restart the server "
"with ':YcmRestartServer'.".format( str( error ).rstrip( '.' ) ) )
self._logger.exception( error_message )
vimsupport.PostVimMessage( error_message )
return
args = [ python_interpreter,
paths.PathToServerScript(),
'--port={0}'.format( server_port ),
'--options_file={0}'.format( options_file.name ),
'--log={0}'.format( self._user_options[ 'log_level' ] ),
'--idle_suicide_seconds={0}'.format(
SERVER_IDLE_SUICIDE_SECONDS ) ]
self._server_stdout = utils.CreateLogfile(
SERVER_LOGFILE_FORMAT.format( port = server_port, std = 'stdout' ) )
self._server_stderr = utils.CreateLogfile(
SERVER_LOGFILE_FORMAT.format( port = server_port, std = 'stderr' ) )
args.append( '--stdout={0}'.format( self._server_stdout ) )
args.append( '--stderr={0}'.format( self._server_stderr ) )
if self._user_options[ 'keep_logfiles' ]:
args.append( '--keep_logfiles' )
self._server_popen = utils.SafePopen( args, stdin_windows = PIPE,
stdout = PIPE, stderr = PIPE )
def _StartServer(self):
with self._server_lock:
if self._ServerIsRunning():
return
self._logfile = _LogFileName()
tsserver_log = '-file {path} -level {level}'.format(
path=self._logfile, level=_LogLevel())
# TSServer gets the configuration for the log file through the
# environment variable 'TSS_LOG'. This seems to be undocumented but
# looking at the source code it seems like this is the way:
# https://github.com/Microsoft/TypeScript/blob/8a93b489454fdcbdf544edef05f73a913449be1d/src/server/server.ts#L136
environ = os.environ.copy()
utils.SetEnviron(environ, 'TSS_LOG', tsserver_log)
_logger.info('TSServer log file: {0}'.format(self._logfile))
# We need to redirect the error stream to the output one on Windows.
self._tsserver_handle = utils.SafePopen(PATH_TO_TSSERVER,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=environ)
self._tsserver_is_running.set()
def _StartServer(self):
with self._server_lock:
self._logger.info('Starting JediHTTP server')
self._jedihttp_port = utils.GetUnusedLocalhostPort()
self._jedihttp_host = ToBytes('http://127.0.0.1:{0}'.format(
self._jedihttp_port))
self._logger.info('using port {0}'.format(self._jedihttp_port))
self._hmac_secret = self._GenerateHmacSecret()
# JediHTTP will delete the secret_file after it's done reading it
with NamedTemporaryFile(delete=False, mode='w+') as hmac_file:
json.dump(
{'hmac_secret': ToUnicode(b64encode(self._hmac_secret))},
hmac_file)
command = [
self._python_binary_path, PATH_TO_JEDIHTTP, '--port',
str(self._jedihttp_port), '--log',
self._GetLoggingLevel(), '--hmac-file-secret',
hmac_file.name
]
self._logfile_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._jedihttp_port, std='stdout'))
self._logfile_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._jedihttp_port, std='stderr'))
with utils.OpenForStdHandle(self._logfile_stdout) as logout:
with utils.OpenForStdHandle(self._logfile_stderr) as logerr:
self._jedihttp_phandle = utils.SafePopen(command,
stdout=logout,
stderr=logerr)
def _StartServer(self):
with self._server_lock:
self._logger.info('Starting SSVIM server')
self._http_port = utils.GetUnusedLocalhostPort()
self._http_host = ToBytes('http://{0}:{1}'.format(
SSVIM_IP, self._http_port))
self._logger.info('using port {0}'.format(self._http_port))
self._hmac_secret = self._GenerateHmacSecret()
# The server will delete the secret_file after it's done reading it
with NamedTemporaryFile(delete=False, mode='w+') as hmac_file:
json.dump(
{'hmac_secret': ToUnicode(b64encode(self._hmac_secret))},
hmac_file)
command = [
PATH_TO_SSVIMHTTP, '--ip', SSVIM_IP, '--port',
str(self._http_port), '--log',
self._GetLoggingLevel(), '--hmac-file-secret',
hmac_file.name
]
self._logfile_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._http_port, std='stdout'))
self._logfile_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._http_port, std='stderr'))
with utils.OpenForStdHandle(self._logfile_stdout) as logout:
with utils.OpenForStdHandle(
self._logfile_stderr) as logerr:
self._http_phandle = utils.SafePopen(command,
stdout=logout,
stderr=logerr)
self._WaitForInitialSwiftySwiftVimBoot()
self._logger.info('Started SSVIM server')
def StartServer(self, request_data):
with self._server_state_mutex:
LOGGER.info('Starting %s: %s', self.GetServerName(),
self.GetCommandLine())
self._stderr_file = utils.CreateLogfile('{}_stderr'.format(
utils.MakeSafeFileNameString(self.GetServerName())))
with utils.OpenForStdHandle(self._stderr_file) as stderr:
self._server_handle = utils.SafePopen(self.GetCommandLine(),
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=stderr)
self._connection = (lsc.StandardIOLanguageServerConnection(
self._server_handle.stdin, self._server_handle.stdout,
self.GetDefaultNotificationHandler()))
self._connection.Start()
try:
self._connection.AwaitServerConnection()
except lsc.LanguageServerConnectionTimeout:
LOGGER.error(
'%s failed to start, or did not connect successfully',
self.GetServerName())
self.Shutdown()
return False
LOGGER.info('%s started', self.GetServerName())
return True
def _StartServer(self):
"""Start the Gocode server."""
with self._gocode_lock:
_logger.info('Starting Gocode server')
self._gocode_port = utils.GetUnusedLocalhostPort()
self._gocode_host = '127.0.0.1:{0}'.format(self._gocode_port)
command = [
self._gocode_binary_path, '-s', '-sock', 'tcp', '-source',
'-addr', self._gocode_host
]
if _logger.isEnabledFor(logging.DEBUG):
command.append('-debug')
self._gocode_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._gocode_port, std='stdout'))
self._gocode_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._gocode_port, std='stderr'))
with utils.OpenForStdHandle(self._gocode_stdout) as stdout:
with utils.OpenForStdHandle(self._gocode_stderr) as stderr:
self._gocode_handle = utils.SafePopen(command,
stdout=stdout,
stderr=stderr)
def _StartServer( self ):
with self._server_state_mutex:
if self._ServerIsRunning():
return
_logger.info( 'Starting Tern server...' )
self._server_port = utils.GetUnusedLocalhostPort()
if _logger.isEnabledFor( logging.DEBUG ):
extra_args = [ '--verbose' ]
else:
extra_args = []
command = [ PATH_TO_NODE,
PATH_TO_TERN_BINARY,
'--port',
str( self._server_port ),
'--host',
SERVER_HOST,
'--persistent',
'--no-port-file' ] + extra_args
_logger.debug( 'Starting tern with the following command: '
+ ' '.join( command ) )
try:
self._server_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format( port = self._server_port, std = 'stdout' ) )
self._server_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format( port = self._server_port, std = 'stderr' ) )
# We need to open a pipe to stdin or the Tern server is killed.
# See https://github.com/ternjs/tern/issues/740#issuecomment-203979749
# For unknown reasons, this is only needed on Windows and for Python
# 3.4+ on other platforms.
with utils.OpenForStdHandle( self._server_stdout ) as stdout:
with utils.OpenForStdHandle( self._server_stderr ) as stderr:
self._server_handle = utils.SafePopen( command,
stdin = PIPE,
stdout = stdout,
stderr = stderr )
except Exception:
_logger.exception( 'Unable to start Tern server' )
self._CleanUp()
if self._server_port and self._ServerIsRunning():
_logger.info( 'Tern Server started with pid: ' +
str( self._server_handle.pid ) +
' listening on port ' +
str( self._server_port ) )
_logger.info( 'Tern Server log files are: ' +
self._server_stdout +
' and ' +
self._server_stderr )
self._do_tern_project_check = True
else:
_logger.warning( 'Tern server did not start successfully' )
def _StartServerNoLock(self):
"""Start the server, under the lock.
Callers must hold self._server_state_mutex"""
if self._ServerIsRunning():
return
_logger.info('Starting Tern.js server...')
self._server_port = utils.GetUnusedLocalhostPort()
if _logger.isEnabledFor(logging.DEBUG):
extra_args = ['--verbose']
else:
extra_args = []
command = [
PATH_TO_NODE, PATH_TO_TERNJS_BINARY, '--port',
str(self._server_port), '--host', SERVER_HOST, '--persistent',
'--no-port-file'
] + extra_args
_logger.debug('Starting tern with the following command: ' +
' '.join(command))
try:
logfile_format = os.path.join(utils.PathToCreatedTempDir(),
u'tern_{port}_{std}.log')
self._server_stdout = logfile_format.format(port=self._server_port,
std='stdout')
self._server_stderr = logfile_format.format(port=self._server_port,
std='stderr')
# On Windows, we need to open a pipe to stdin to prevent Tern crashing
# with following error: "Implement me. Unknown stdin file type!"
with utils.OpenForStdHandle(self._server_stdout) as stdout:
with utils.OpenForStdHandle(self._server_stderr) as stderr:
self._server_handle = utils.SafePopen(command,
stdin_windows=PIPE,
stdout=stdout,
stderr=stderr)
except Exception:
_logger.warning('Unable to start Tern.js server: ' +
traceback.format_exc())
self._Reset()
if self._server_port > 0 and self._ServerIsRunning():
_logger.info('Tern.js Server started with pid: ' +
str(self._server_handle.pid) + ' listening on port ' +
str(self._server_port))
_logger.info('Tern.js Server log files are: ' +
self._server_stdout + ' and ' + self._server_stderr)
self._do_tern_project_check = True
else:
_logger.warning('Tern.js server did not start successfully')
def _GetRustSysroot( rustc_exec ):
return ToUnicode( utils.SafePopen( [ rustc_exec,
'--print',
'sysroot' ],
stdin_windows = subprocess.PIPE,
stdout = subprocess.PIPE,
stderr = subprocess.PIPE )
.communicate()[ 0 ].rstrip() )
def test_SafePopen_ReplaceStdinWindowsPIPEOnWindows(self, *args):
utils.SafePopen(['foo'], stdin_windows=subprocess.PIPE)
assert_that(
subprocess.Popen.call_args,
equal_to(
call(['foo'],
stdin=subprocess.PIPE,
creationflags=utils.CREATE_NO_WINDOW)))
def _StartServer(self, request_data):
with self._server_state_mutex:
if self._server_started:
return
self._server_started = True
_logger.info('Starting jdt.ls Language Server...')
self._project_dir = _FindProjectDir(
os.path.dirname(request_data['filepath']))
self._workspace_path = _WorkspaceDirForProject(
self._project_dir, self._use_clean_workspace)
command = [
PATH_TO_JAVA,
'-Dfile.encoding=UTF-8',
'-Declipse.application=org.eclipse.jdt.ls.core.id1',
'-Dosgi.bundles.defaultStartLevel=4',
'-Declipse.product=org.eclipse.jdt.ls.core.product',
'-Dlog.level=ALL',
'-jar',
self._launcher_path,
'-configuration',
self._launcher_config,
'-data',
self._workspace_path,
]
_logger.debug('Starting java-server with the following command: '
'{0}'.format(' '.join(command)))
self._server_stderr = utils.CreateLogfile('jdt.ls_stderr_')
with utils.OpenForStdHandle(self._server_stderr) as stderr:
self._server_handle = utils.SafePopen(command,
stdin=PIPE,
stdout=PIPE,
stderr=stderr)
self._connection = (
language_server_completer.StandardIOLanguageServerConnection(
self._server_handle.stdin, self._server_handle.stdout,
self.GetDefaultNotificationHandler()))
self._connection.Start()
try:
self._connection.AwaitServerConnection()
except language_server_completer.LanguageServerConnectionTimeout:
_logger.error('jdt.ls failed to start, or did not connect '
'successfully')
self._StopServer()
return
_logger.info('jdt.ls Language Server started')
self.SendInitialize(request_data)
def __init__(self, user_options):
super(TypeScriptCompleter, self).__init__(user_options)
# Used to prevent threads from concurrently writing to
# the tsserver process' stdin
self._writelock = Lock()
binarypath = utils.PathToFirstExistingExecutable(['tsserver'])
if not binarypath:
_logger.error(BINARY_NOT_FOUND_MESSAGE)
raise RuntimeError(BINARY_NOT_FOUND_MESSAGE)
self._logfile = _LogFileName()
tsserver_log = '-file {path} -level {level}'.format(path=self._logfile,
level=_LogLevel())
# TSServer get the configuration for the log file through the environment
# variable 'TSS_LOG'. This seems to be undocumented but looking at the
# source code it seems like this is the way:
# https://github.com/Microsoft/TypeScript/blob/8a93b489454fdcbdf544edef05f73a913449be1d/src/server/server.ts#L136
self._environ = os.environ.copy()
utils.SetEnviron(self._environ, 'TSS_LOG', tsserver_log)
# Each request sent to tsserver must have a sequence id.
# Responses contain the id sent in the corresponding request.
self._sequenceid = itertools.count()
# Used to prevent threads from concurrently accessing the sequence counter
self._sequenceid_lock = Lock()
# TSServer ignores the fact that newlines are two characters on Windows
# (\r\n) instead of one on other platforms (\n), so we use the
# universal_newlines option to convert those newlines to \n. See the issue
# https://github.com/Microsoft/TypeScript/issues/3403
# TODO: remove this option when the issue is fixed.
# We also need to redirect the error stream to the output one on Windows.
self._tsserver_handle = utils.SafePopen(binarypath,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=self._environ,
universal_newlines=True)
# Used to map sequence id's to their corresponding DeferredResponse
# objects. The reader loop uses this to hand out responses.
self._pending = {}
# Used to prevent threads from concurrently reading and writing to
# the pending response dictionary
self._pendinglock = Lock()
# Start a thread to read response from TSServer.
self._thread = Thread(target=self._ReaderLoop, args=())
self._thread.daemon = True
self._thread.start()
_logger.info('Enabling typescript completion')
def _StartServer( self, request_data ):
with self._server_state_mutex:
if self._server_started:
return
self._server_started = True
LOGGER.info( 'Starting Tern server...' )
self._SetServerProjectFileAndWorkingDirectory( request_data )
self._server_port = utils.GetUnusedLocalhostPort()
command = [ PATH_TO_NODE,
PATH_TO_TERN_BINARY,
'--port',
str( self._server_port ),
'--host',
SERVER_HOST,
'--persistent',
'--no-port-file' ]
if LOGGER.isEnabledFor( logging.DEBUG ):
command.append( '--verbose' )
LOGGER.debug( 'Starting tern with the following command: %s', command )
self._server_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format( port = self._server_port, std = 'stdout' ) )
self._server_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format( port = self._server_port, std = 'stderr' ) )
# We need to open a pipe to stdin or the Tern server is killed.
# See https://github.com/ternjs/tern/issues/740#issuecomment-203979749
# For unknown reasons, this is only needed on Windows and for Python
# 3.4+ on other platforms.
with utils.OpenForStdHandle( self._server_stdout ) as stdout:
with utils.OpenForStdHandle( self._server_stderr ) as stderr:
self._server_handle = utils.SafePopen(
command,
stdin = PIPE,
stdout = stdout,
stderr = stderr,
cwd = self._server_working_dir )
if self._ServerIsRunning():
LOGGER.info( 'Tern Server started with pid %d listening on port %d',
self._server_handle.pid, self._server_port )
LOGGER.info( 'Tern Server log files are %s and %s',
self._server_stdout, self._server_stderr )
self._do_tern_project_check = True
else:
LOGGER.warning( 'Tern server did not start successfully' )
def SafePopen_WindowsPath_test( *args ):
tempfile = PathToTestFile( 'safe-popen-file' )
open( tempfile, 'a' ).close()
try:
utils.SafePopen( [ 'foo', tempfile ], stdin_windows = subprocess.PIPE )
eq_( subprocess.Popen.call_args,
call( [ 'foo', tempfile ],
stdin = subprocess.PIPE,
creationflags = utils.CREATE_NO_WINDOW ) )
finally:
os.remove( tempfile )
def IsPythonVersionCorrect(path):
"""Check if given path is the Python interpreter version 2.6 or 2.7."""
if not EndsWithPython(path):
return False
command = [
path, '-c', "import sys;"
"major, minor = sys.version_info[ :2 ];"
"sys.exit( major != 2 or minor < 6)"
]
return utils.SafePopen(command).wait() == 0
def _StartServer(self, request_data):
""" Start the OmniSharp server """
self._logger.info('startup')
# NOTE: detection could throw an exception if an extra_conf_store needs to
# be confirmed
path_to_solutionfile = solutiondetection.FindSolutionPath(
request_data['filepath'])
if not path_to_solutionfile:
raise RuntimeError('Autodetection of solution file failed.\n')
self._logger.info(
u'Loading solution file {0}'.format(path_to_solutionfile))
self._ChooseOmnisharpPort()
# we need to pass the command to Popen as a string since we're passing
# shell=True (as recommended by Python's doc)
command = ' '.join([
PATH_TO_OMNISHARP_BINARY, '-p',
str(self._omnisharp_port), '-s',
u'"{0}"'.format(path_to_solutionfile)
])
if not utils.OnWindows() and not utils.OnCygwin():
command = u'mono ' + command
if utils.OnCygwin():
command = command + ' --client-path-mode Cygwin'
filename_format = os.path.join(utils.PathToTempDir(),
u'omnisharp_{port}_{sln}_{std}.log')
solutionfile = os.path.basename(path_to_solutionfile)
self._filename_stdout = filename_format.format(
port=self._omnisharp_port, sln=solutionfile, std='stdout')
self._filename_stderr = filename_format.format(
port=self._omnisharp_port, sln=solutionfile, std='stderr')
with open(self._filename_stderr, 'w') as fstderr:
with open(self._filename_stdout, 'w') as fstdout:
# shell=True is needed for Windows so OmniSharp does not spawn
# in a new visible window
self._omnisharp_phandle = utils.SafePopen(command,
stdout=fstdout,
stderr=fstderr,
shell=True)
self._solution_path = path_to_solutionfile
self._logger.info('Starting OmniSharp server')
def test_SafePopen_WindowsPath(self, *args):
tempfile = PathToTestFile('safe-popen-file')
open(tempfile, 'a').close()
try:
utils.SafePopen(['foo', tempfile], stdin_windows=subprocess.PIPE)
assert_that(
subprocess.Popen.call_args,
equal_to(
call(['foo', tempfile],
stdin=subprocess.PIPE,
creationflags=utils.CREATE_NO_WINDOW)))
finally:
os.remove(tempfile)
def _StartServer(self, request_data, project_directory=None):
with self._server_state_mutex:
if self._server_started:
return
self._server_started = True
_logger.info('Starting dart Language Server...')
if project_directory:
self._project_dir = project_directory
else:
self._project_dir = _FindProjectDir(
os.path.dirname(request_data['filepath']))
self._workspace_path = self._project_dir
command = [
PATH_TO_DART,
'--force_trace_level=verbose',
]
_logger.debug('Starting dart-server with the following command: '
'{0}'.format(' '.join(command)))
self._server_stderr = utils.CreateLogfile('dart_stderr_')
with utils.OpenForStdHandle(self._server_stderr) as stderr:
self._server_handle = utils.SafePopen(command,
stdin=PIPE,
stdout=PIPE,
stderr=stderr)
self._connection = (
language_server_completer.StandardIOLanguageServerConnection(
self._server_handle.stdin, self._server_handle.stdout,
self.GetDefaultNotificationHandler()))
self._connection.Start()
try:
self._connection.AwaitServerConnection()
except language_server_completer.LanguageServerConnectionTimeout:
_logger.error('dart failed to start, or did not connect '
'successfully')
self._StopServer()
return
_logger.info('dart Language Server started')
self.SendInitialize(request_data)
def _StartServer(self):
""" Start the OmniSharp server if not already running. Use a lock to avoid
starting the server multiple times for the same solution. """
with self._server_state_lock:
if self._ServerIsRunning():
return
LOGGER.info('Starting OmniSharp server')
LOGGER.info('Loading solution file %s', self._solution_path)
self._ChooseOmnisharpPort()
# Roslyn fails unless you open it in shell in Window on Python 2
# Shell isn't preferred, but I don't see any other way to resolve
shell_required = PY2 and utils.OnWindows()
command = [
PATH_TO_ROSLYN_OMNISHARP_BINARY, '-p',
str(self._omnisharp_port), '-s',
str(self._solution_path)
]
if (not utils.OnWindows()
and PATH_TO_ROSLYN_OMNISHARP_BINARY.endswith('.exe')):
command.insert(0, 'mono')
LOGGER.info('Starting OmniSharp server with: %s', command)
solutionfile = os.path.basename(self._solution_path)
self._filename_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._omnisharp_port,
sln=solutionfile,
std='stdout'))
self._filename_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._omnisharp_port,
sln=solutionfile,
std='stderr'))
with utils.OpenForStdHandle(self._filename_stderr) as fstderr:
with utils.OpenForStdHandle(self._filename_stdout) as fstdout:
self._omnisharp_phandle = utils.SafePopen(
command,
stdout=fstdout,
stderr=fstderr,
shell=shell_required)
LOGGER.info('Started OmniSharp server')
def _SetupServer(self):
self._available_completers = {}
self._user_notified_about_crash = False
self._filetypes_with_keywords_loaded = set()
self._server_is_ready_with_cache = False
server_port = utils.GetUnusedLocalhostPort()
# The temp options file is deleted by ycmd during startup
with NamedTemporaryFile(delete=False, mode='w+') as options_file:
hmac_secret = os.urandom(HMAC_SECRET_LENGTH)
options_dict = dict(self._user_options)
options_dict['hmac_secret'] = utils.ToUnicode(
base64.b64encode(hmac_secret))
options_dict['server_keep_logfiles'] = self._user_options[
'keep_logfiles']
json.dump(options_dict, options_file)
options_file.flush()
args = [
paths.PathToPythonInterpreter(),
paths.PathToServerScript(), '--port={0}'.format(server_port),
'--options_file={0}'.format(options_file.name),
'--log={0}'.format(self._user_options['log_level']),
'--idle_suicide_seconds={0}'.format(
SERVER_IDLE_SUICIDE_SECONDS)
]
self._server_stdout = utils.CreateLogfile(
SERVER_LOGFILE_FORMAT.format(port=server_port, std='stdout'))
self._server_stderr = utils.CreateLogfile(
SERVER_LOGFILE_FORMAT.format(port=server_port, std='stderr'))
args.append('--stdout={0}'.format(self._server_stdout))
args.append('--stderr={0}'.format(self._server_stderr))
if self._user_options['keep_logfiles']:
args.append('--keep_logfiles')
self._server_popen = utils.SafePopen(args,
stdin_windows=PIPE,
stdout=PIPE,
stderr=PIPE)
BaseRequest.server_location = 'http://127.0.0.1:' + str(
server_port)
BaseRequest.hmac_secret = hmac_secret
self._NotifyUserIfServerCrashed()
def _StartServer(self):
""" Start the OmniSharp server if not already running. Use a lock to avoid
starting the server multiple times for the same solution. """
with self._server_state_lock:
if self.ServerIsRunning():
return
self._logger.info('Starting OmniSharp server')
path_to_solutionfile = self._solution_path
self._logger.info(
u'Loading solution file {0}'.format(path_to_solutionfile))
self._ChooseOmnisharpPort()
command = [
PATH_TO_OMNISHARP_BINARY, '-p',
str(self._omnisharp_port), '-s',
u'{0}'.format(path_to_solutionfile)
]
if not utils.OnWindows() and not utils.OnCygwin():
command.insert(0, 'mono')
if utils.OnCygwin():
command.extend(['--client-path-mode', 'Cygwin'])
filename_format = os.path.join(
utils.PathToCreatedTempDir(),
u'omnisharp_{port}_{sln}_{std}.log')
solutionfile = os.path.basename(path_to_solutionfile)
self._filename_stdout = filename_format.format(
port=self._omnisharp_port, sln=solutionfile, std='stdout')
self._filename_stderr = filename_format.format(
port=self._omnisharp_port, sln=solutionfile, std='stderr')
with open(self._filename_stderr, 'w') as fstderr:
with open(self._filename_stdout, 'w') as fstdout:
self._omnisharp_phandle = utils.SafePopen(command,
stdout=fstdout,
stderr=fstderr)
self._external_omnisharp = False
self._solution_path = path_to_solutionfile
def SetUpYCM():
from ycm import base, paths
from ycmd import user_options_store, utils
from ycm.youcompleteme import YouCompleteMe
base.LoadJsonDefaultsIntoVim()
user_options_store.SetAll(base.BuildServerConf())
popen_args = [
paths.PathToPythonInterpreter(),
paths.PathToCheckCoreVersion()
]
if utils.SafePopen(popen_args).wait() == 2:
raise RuntimeError('YCM support libs too old, PLEASE RECOMPILE.')
return YouCompleteMe(user_options_store.GetAll())
def _StartServer(self):
""" Start the OmniSharp server if not already running. Use a lock to avoid
starting the server multiple times for the same solution. """
with self._server_state_lock:
if self._ServerIsRunning():
return
self._logger.info('Starting OmniSharp server')
path_to_solutionfile = self._solution_path
self._logger.info(
u'Loading solution file {0}'.format(path_to_solutionfile))
self._ChooseOmnisharpPort()
command = [
PATH_TO_OMNISHARP_BINARY, '-p',
str(self._omnisharp_port), '-s',
u'{0}'.format(path_to_solutionfile)
]
if not utils.OnWindows() and not utils.OnCygwin():
command.insert(0, 'mono')
if utils.OnCygwin():
command.extend(['--client-path-mode', 'Cygwin'])
solutionfile = os.path.basename(path_to_solutionfile)
self._filename_stdout = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._omnisharp_port,
sln=solutionfile,
std='stdout'))
self._filename_stderr = utils.CreateLogfile(
LOGFILE_FORMAT.format(port=self._omnisharp_port,
sln=solutionfile,
std='stderr'))
with utils.OpenForStdHandle(self._filename_stderr) as fstderr:
with utils.OpenForStdHandle(self._filename_stdout) as fstdout:
self._omnisharp_phandle = utils.SafePopen(command,
stdout=fstdout,
stderr=fstderr)
self._solution_path = path_to_solutionfile
def _SetupServer(self):
self._available_completers = {}
server_port = utils.GetUnusedLocalhostPort()
# The temp options file is deleted by ycmd during startup
with tempfile.NamedTemporaryFile(delete=False) as options_file:
hmac_secret = os.urandom(HMAC_SECRET_LENGTH)
options_dict = dict(self._user_options)
options_dict['hmac_secret'] = base64.b64encode(hmac_secret)
json.dump(options_dict, options_file)
options_file.flush()
args = [
utils.PathToPythonInterpreter(),
_PathToServerScript(), '--port={0}'.format(server_port),
'--options_file={0}'.format(options_file.name),
'--log={0}'.format(self._user_options['server_log_level']),
'--idle_suicide_seconds={0}'.format(
SERVER_IDLE_SUICIDE_SECONDS)
]
if not self._user_options['server_use_vim_stdout']:
filename_format = os.path.join(utils.PathToTempDir(),
'server_{port}_{std}.log')
self._server_stdout = filename_format.format(port=server_port,
std='stdout')
self._server_stderr = filename_format.format(port=server_port,
std='stderr')
args.append('--stdout={0}'.format(self._server_stdout))
args.append('--stderr={0}'.format(self._server_stderr))
if self._user_options['server_keep_logfiles']:
args.append('--keep_logfiles')
self._server_popen = utils.SafePopen(args,
stdin_windows=PIPE,
stdout=PIPE,
stderr=PIPE)
BaseRequest.server_location = 'http://127.0.0.1:' + str(
server_port)
BaseRequest.hmac_secret = hmac_secret
self._NotifyUserIfServerCrashed()
def IsPythonVersionCorrect(path):
"""Check if given path is the Python interpreter version 2.6+ or 3.3+."""
from ycmd import utils
if not EndsWithPython(path):
return False
command = [
path,
'-c',
"import sys;"
"major, minor = sys.version_info[ :2 ];"
"good_python = ( major == 2 and minor >= 6 ) "
"or ( major == 3 and minor >= 3 ) or major > 3;"
# If this looks weird, remember that:
# int( True ) == 1
# int( False ) == 0
"sys.exit( not good_python )"
]
return utils.SafePopen(command).wait() == 0
