Switch to tslab

Author: jakubno

Makefile

@@ -1,5 +1,5 @@
 start-template-server:
-	docker run --rm -e E2B_LOCAL=true -p 49999:49999 -it $$(docker build . -q -f ./template/test.Dockerfile)
+	docker run --platform linux/amd64 --rm -e E2B_LOCAL=true -p 49999:49999 -it $$(docker build . --platform linux/amd64 -q -f ./template/test.Dockerfile)
 
 kill-template-server:
 	docker kill $(shell docker ps --filter expose=49999 --format {{.ID}})

python/tests/sync/test_default_kernels.py

@@ -4,3 +4,13 @@
 def test_js_kernel(sandbox: Sandbox):
     execution = sandbox.run_code("console.log('Hello, World!')", language="js")
     assert execution.logs.stdout == ["Hello, World!\n"]
+
+
+def test_r_kernel(sandbox: Sandbox):
+    execution = sandbox.run_code('print("Hello, World!")', language="r")
+    assert execution.logs.stdout == ['[1] "Hello, World!"\n']
+
+
+def test_java_kernel(sandbox: Sandbox):
+    execution = sandbox.run_code('System.out.println("Hello, World!")', language="java")
+    assert execution.logs.stdout[0] == "Hello, World!"

template/server/contexts.py

@@ -25,6 +25,11 @@ def normalize_language(language: Optional[str]) -> str:
 
 
 async def create_context(client, websockets: dict, language: str, cwd: str) -> Context:
+    if language == "typescript":
+        language = "tslab"
+    if language == "javascript":
+        language = "jslab"
+
     data = {
         "path": str(uuid.uuid4()),
         "kernel": {"name": language},
@@ -53,7 +58,7 @@ async def create_context(client, websockets: dict, language: str, cwd: str) -> C
 
     logger.info(f"Setting working directory to {cwd}")
     try:
-        await ws.change_current_directory(cwd)
+        await ws.change_current_directory(cwd, language)
     except ExecutionError as e:
         return PlainTextResponse(
             "Failed to set working directory",

template/server/main.py

@@ -104,7 +104,11 @@ async def post_execute(request: ExecutionRequest):
         )
 
     return StreamingListJsonResponse(
-        ws.execute(request.code, env_vars=request.env_vars)
+        ws.execute(
+            request.code,
+            env_vars=request.env_vars,
+            sends_input_accepted="lab" not in ws.language,
+        )
     )
 
 

template/server/messaging.py

@@ -108,8 +108,12 @@ def _get_execute_request(
             }
         )
 
-    async def _wait_for_result(self, message_id: str):
+    async def _wait_for_result(
+        self, message_id: str, sends_input_accepted: bool = False
+    ):
         queue = self._executions[message_id].queue
+        if not sends_input_accepted:
+            self._executions[message_id].input_accepted = True
 
         while True:
             output = await queue.get()
@@ -127,21 +131,37 @@ async def _wait_for_result(self, message_id: str):
 
             yield output.model_dump(exclude_none=True)
 
-    async def change_current_directory(self, path: Union[str, StrictStr]):
+    async def change_current_directory(
+        self, path: Union[str, StrictStr], language: str
+    ):
         message_id = str(uuid.uuid4())
         self._executions[message_id] = Execution(in_background=True)
-        request = self._get_execute_request(message_id, f"%cd {path}", True)
+        if language == "python":
+            request = self._get_execute_request(message_id, f"%cd {path}", True)
+        elif language == "jslab" or language == "tslab":
+            request = self._get_execute_request(
+                message_id, f"process.chdir('{path}')", True
+            )
+        elif language == "r":
+            request = self._get_execute_request(message_id, f"setwd('{path}')", True)
+        elif language == "java":
+            request = self._get_execute_request(
+                message_id, f"System.setProperty('user.dir', '{path}')", True
+            )
+        else:
+            return
 
         await self._ws.send(request)
 
-        async for item in self._wait_for_result(message_id):
+        async for item in self._wait_for_result(message_id, False):
             if item["type"] == "error":
                 raise ExecutionError(f"Error during execution: {item}")
 
     async def execute(
         self,
         code: Union[str, StrictStr],
         env_vars: Dict[StrictStr, str] = None,
+        sends_input_accepted: bool = False,
     ):
         message_id = str(uuid.uuid4())
         logger.debug(f"Sending code for the execution ({message_id}): {code}")
@@ -165,11 +185,12 @@ async def execute(
                         indent = len(line) - len(line.lstrip())
                         break
 
-                code = (
-                    indent * " "
-                    + f"os.environ.set_envs_for_execution({vars_to_set})\n"
-                    + code
-                )
+                if self.language == "python":
+                    code = (
+                        indent * " "
+                        + f"os.environ.set_envs_for_execution({vars_to_set})\n"
+                        + code
+                    )
 
             logger.info(code)
             request = self._get_execute_request(message_id, code, False)
@@ -178,7 +199,7 @@ async def execute(
             await self._ws.send(request)
 
             # Stream the results
-            async for item in self._wait_for_result(message_id):
+            async for item in self._wait_for_result(message_id, sends_input_accepted):
                 yield item
 
             del self._executions[message_id]
@@ -192,7 +213,9 @@ async def _receive_message(self):
             async for message in self._ws:
                 await self._process_message(json.loads(message))
         except Exception as e:
-            logger.error(f"WebSocket received error while receiving messages: {e}")
+            logger.error(
+                f"WebSocket received error while receiving messages: {type(e)}: {str(e)}"
+            )
 
     async def _process_message(self, data: dict):
         """
@@ -308,11 +331,21 @@ async def _process_message(self, data: dict):
                 execution.errored = True
                 await queue.put(
                     Error(
-                        name=data["content"]["ename"],
-                        value=data["content"]["evalue"],
-                        traceback="".join(data["content"]["traceback"]),
+                        name=data["content"].get("ename", ""),
+                        value=data["content"].get("evalue", ""),
+                        traceback="".join(data["content"].get("traceback", [])),
                     )
                 )
+            elif data["content"]["status"] == "abort":
+                logger.debug(f"Execution {parent_msg_ig} was aborted")
+                await queue.put(
+                    Error(
+                        name="ExecutionAborted",
+                        value="Execution was aborted",
+                        traceback="",
+                    )
+                )
+                await queue.put(EndOfExecution())
             elif data["content"]["status"] == "ok":
                 pass
 

template/test.Dockerfile

@@ -19,9 +19,9 @@ COPY ./template/requirements.txt requirements.txt
 RUN pip install --no-cache-dir -r requirements.txt && ipython kernel install --name "python3" --user
 
 # Javascript Kernel
-RUN npm install -g node-gyp
-RUN npm install -g --unsafe-perm ijavascript
-RUN ijsinstall --install=global
+RUN apt install -y cmake ninja-build curl zip unzip tar
+RUN npm install -g tslab --unsafe-perm=true
+RUN tslab install
 
 # Create separate virtual environment for server
 RUN python -m venv $SERVER_PATH/.venv