def __init__(self, rx, tx):
self._jsonrpc_stream_reader = JsonRpcStreamReader(rx)
self._jsonrpc_stream_writer = JsonRpcStreamWriter(tx)
self._endpoint = Endpoint(self,
self._jsonrpc_stream_writer.write,
max_workers=MAX_WORKERS)
self._shutdown = False
def __init__(self, rx, tx):
self.root_path = None
self._jsonrpc_stream_reader = JsonRpcStreamReader(rx)
self._jsonrpc_stream_writer = JsonRpcStreamWriter(tx)
self._endpoint = Endpoint(self, self._jsonrpc_stream_writer.write)
self._dispatchers = []
self._shutdown = False
def __enter__(self):
"""Context manager entrypoint.
shell=True needed for pytest-cov to work in subprocess.
"""
# pylint: disable=consider-using-with
self._sub = subprocess.Popen(
[
sys.executable,
os.path.join(os.path.dirname(__file__), "lsp_run.py"),
],
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
bufsize=0,
cwd=self.cwd,
env=os.environ,
shell="WITH_COVERAGE" in os.environ,
)
self._writer = JsonRpcStreamWriter(
os.fdopen(self._sub.stdin.fileno(), "wb"))
self._reader = JsonRpcStreamReader(
os.fdopen(self._sub.stdout.fileno(), "rb"))
dispatcher = {
PUBLISH_DIAGNOSTICS: self._publish_diagnostics,
WINDOW_SHOW_MESSAGE: self._window_show_message,
WINDOW_LOG_MESSAGE: self._window_log_message,
}
self._endpoint = Endpoint(dispatcher, self._writer.write)
self._thread_pool.submit(self._reader.listen, self._endpoint.consume)
return self
def send(line):
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
sock.connect((host, port))
print(f"send: {line}")
writer = JsonRpcStreamWriter(sock.makefile("wb"))
writer.write(line)
print(f"recv: {sock.recv(4096)}")
def __init__(self, reader, writer):
self._jsonrpcstreamReader = JsonRpcStreamReader(reader)
self._jsonrpcstreamWriter = JsonRpcStreamWriter(writer)
self._endpoint = Endpoint(self, self._jsonrpcstreamWriter.write)
self.isrunning = True
self.workspace = None
self.config = None
def __init__(self, rx, tx):
self.workspace = None
self.config = None
self.rpc_reader = JsonRpcStreamReader(rx)
self.rpc_writer = JsonRpcStreamWriter(tx)
self.endpoint = Endpoint(self, self.rpc_writer.write, max_workers=64)
self.shutdown = False
def __init__(self, rx, tx):
self.log = logging.getLogger("{0}.{1}".format(self.__class__.__module__,self.__class__.__name__))
self._jsonrpc_stream_reader = JsonRpcStreamReader(rx)
self._jsonrpc_stream_writer = JsonRpcStreamWriter(tx)
self._endpoint = Endpoint(
self, self._jsonrpc_stream_writer.write, max_workers=MAX_WORKERS
)
self._shutdown = False
def __init__(self, rx, tx, check_parent_process=False):
self.workspace = None
self.config = None
self._jsonrpc_stream_reader = JsonRpcStreamReader(rx)
self._jsonrpc_stream_writer = JsonRpcStreamWriter(tx)
self._check_parent_process = check_parent_process
self._endpoint = Endpoint(self, self._jsonrpc_stream_writer.write, max_workers=MAX_WORKERS)
self._dispatchers = []
self._shutdown = False
async def tcp_echo_client(message):
reader, writer = await asyncio.open_connection("127.0.0.1", 44444)
w = JsonRpcStreamWriter(WriterAdapter(writer), indent=2)
w.write(message)
data = await reader.read(4096)
print(f"Received: {data.decode()!r}")
print("Close the connection")
writer.close()
def __init__(self, rx, tx, check_parent_process=False, sync_kind=0):
self._jsonrpc_stream_reader = JsonRpcStreamReader(rx)
self._jsonrpc_stream_writer = JsonRpcStreamWriter(tx)
self._check_parent_process = check_parent_process
self._endpoint = Endpoint(self,
self._jsonrpc_stream_writer.write,
max_workers=self.MAX_WORKERS)
# the synchronisation kind between the language server and client
self._sync_kind = sync_kind if sync_kind else self.SYNC_INCREMENTAL
# the actual MRO analyser
self._analyser = None
def _communicate_lang_server(write_to, read_from):
from robotframework_ls_tests.language_server_client import _LanguageServerClient
from pyls_jsonrpc.streams import JsonRpcStreamReader, JsonRpcStreamWriter
w = JsonRpcStreamWriter(write_to, sort_keys=True)
r = JsonRpcStreamReader(read_from)
language_server = _LanguageServerClient(w, r)
yield language_server
if language_server.require_exit_messages:
language_server.shutdown()
language_server.exit()
def __init__(self, rx, tx):
self.workspace = None
self.config = None
self.root_uri = None
self.watching_thread = None
self.workspaces = {}
self.uri_workspace_mapper = {}
self._jsonrpc_stream_reader = JsonRpcStreamReader(rx)
self._jsonrpc_stream_writer = JsonRpcStreamWriter(tx)
self._endpoint = Endpoint(self,
self._jsonrpc_stream_writer.write,
max_workers=MAX_WORKERS)
self._shutdown = False
def __init__(self, rx, tx, check_parent_process=False):
"""Initialise the server."""
self.root_uri = None
self.config = None # type: Optional[Config]
self.workspaces = {} # type: Dict[str, Workspace]
self.watching_thread = None
self._jsonrpc_stream_reader = JsonRpcStreamReader(rx)
self._jsonrpc_stream_writer = JsonRpcStreamWriter(tx)
self._check_parent_process = check_parent_process
self._endpoint = Endpoint(self,
self._jsonrpc_stream_writer.write,
max_workers=MAX_WORKERS)
self._dispatchers = []
self._shutdown = False
def __init__(self, rx, tx, check_parent_process=False):
self.workspace = None
self.config = None
self.root_uri = None
self.watching_thread = None
self.workspaces = {}
self.uri_workspace_mapper = {}
self._jsonrpc_stream_reader = JsonRpcStreamReader(rx)
self._jsonrpc_stream_writer = JsonRpcStreamWriter(tx)
self._check_parent_process = check_parent_process
self._endpoint = Endpoint(self,
self._jsonrpc_stream_writer.write,
max_workers=MAX_WORKERS)
self._dispatchers = []
self._shutdown = False
validator = ConfigValidator(None, True, False)
self.config_spec = validator.get_config_spec()
import sys
from pyls_jsonrpc.streams import JsonRpcStreamWriter
w = JsonRpcStreamWriter(sys.stdout.buffer)
w.write({"key": "value"})
w.close()
# Content-Length: 16
# Content-Type: application/vscode-jsonrpc; charset=utf8
# {"key": "value"}
def writer(wfile):
return JsonRpcStreamWriter(wfile, sort_keys=True)
import threading
from pprint import pprint
from pyls_jsonrpc.streams import JsonRpcStreamWriter, JsonRpcStreamReader
host = "localhost"
port = 44444
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
sock.connect((host, port))
def consume():
JsonRpcStreamReader(sock.makefile("rb")).listen(pprint)
th = threading.Thread(target=consume, daemon=True)
th.start()
w = JsonRpcStreamWriter(sock.makefile("wb"), indent=2)
d = {
"jsonrpc": "2.0",
"id": str(uuid.uuid4()),
"method": "initialize",
"params": {
"rootUri": pathlib.Path(__file__).parent.absolute().as_uri(),
"initializationOptions": {}, # xxx:
},
}
w.write(d)
d = {
"jsonrpc": "2.0",
"id": str(uuid.uuid4()),
def send(self, d):
w = JsonRpcStreamWriter(self.p.stdin, indent=2)
w.write(make_request(d))
d.update(params)
return d
logging.basicConfig(level=logging.DEBUG)
args = ["pyls"]
with subprocess.Popen(args, stdout=subprocess.PIPE,
stdin=subprocess.PIPE) as p:
def consume():
JsonRpcStreamReader(p.stdout).listen(pprint)
th = threading.Thread(target=consume, daemon=True)
th.start()
w = JsonRpcStreamWriter(p.stdin, indent=2)
d = make_request(
"initialize",
{
"params": {
"rootPath": os.path.dirname(__file__) or os.getcwd(), # hmm
"initializationOptions": {}, # xxx:
"trace": "verbose", # off | messages | verbose
}
},
)
w.write(d)
d = make_request(
"textDocument/definition",
{