skypilot-nightly 1.0.0.dev20250303__py3-none-any.whl → 1.0.0.dev20250305__py3-none-any.whl

sky/jobs/client/sdk.py

@@ -184,7 +184,7 @@ def tail_logs(name: Optional[str] = None,
               follow: bool = True,
               controller: bool = False,
               refresh: bool = False,
-              output_stream: Optional['io.TextIOBase'] = None) -> None:
+              output_stream: Optional['io.TextIOBase'] = None) -> int:
     """Tails logs of managed jobs.
 
     You can provide either a job name or a job ID to tail logs. If both are not
@@ -199,6 +199,11 @@ def tail_logs(name: Optional[str] = None,
         output_stream: The stream to write the logs to. If None, print to the
             console.
 
+    Returns:
+        Exit code based on success or failure of the job. 0 if success,
+        100 if the job failed. See exceptions.JobExitCode for possible exit
+        codes.
+
     Request Raises:
         ValueError: invalid arguments.
         sky.exceptions.ClusterNotUpError: the jobs controller is not up.
@@ -217,7 +222,7 @@ def tail_logs(name: Optional[str] = None,
         timeout=(5, None),
     )
     request_id = server_common.get_request_id(response)
-    sdk.stream_response(request_id, response, output_stream)
+    return sdk.stream_response(request_id, response, output_stream)
 
 
 @usage_lib.entrypoint

sky/jobs/constants.py

@@ -40,7 +40,7 @@ JOBS_CLUSTER_NAME_PREFIX_LENGTH = 25
 # The version of the lib files that jobs/utils use. Whenever there is an API
 # change for the jobs/utils, we need to bump this version and update
 # job.utils.ManagedJobCodeGen to handle the version update.
-MANAGED_JOBS_VERSION = 2
+MANAGED_JOBS_VERSION = 3
 
 # The command for setting up the jobs dashboard on the controller. It firstly
 # checks if the systemd services are available, and if not (e.g., Kubernetes

sky/jobs/dashboard/dashboard.py

@@ -62,6 +62,7 @@ class JobTableColumns(enum.IntEnum):
     - FAILOVER (13): Job failover history
     - DETAILS (14): Job details
     - ACTIONS (15): Available actions column
+    - LOG_CONTENT (16): Log content column
     """
     DROPDOWN = 0
     ID = 1
@@ -79,13 +80,14 @@ class JobTableColumns(enum.IntEnum):
     DETAILS = 13
     FAILOVER = 14
     ACTIONS = 15
+    LOG_CONTENT = 16
 
 
 # Column headers matching the indices above
 JOB_TABLE_COLUMNS = [
     '', 'ID', 'Task', 'Name', 'Resources', 'Submitted', 'Total Duration',
     'Job Duration', 'Status', 'Started', 'Cluster', 'Region', 'Failover',
-    'Recoveries', 'Details', 'Actions'
+    'Recoveries', 'Details', 'Actions', 'Log Content'
 ]
 
 # This column is given by format_job_table but should be ignored.
@@ -153,14 +155,14 @@ def home():
             status_counts[task['status'].value] += 1
 
     # Add an empty column for the dropdown button and actions column
-    # Exclude SCHED. STATE column
+    # Exclude SCHED. STATE and LOG_CONTENT columns
     rows = [
         [''] + row[:SCHED_STATE_COLUMN] + row[SCHED_STATE_COLUMN + 1:] +
         # Add empty cell for failover and actions column
-        [''] + [''] for row in rows
+        [''] + [''] + [''] for row in rows
     ]
 
-    # Add log content as failover history for each job
+    # Add log content as a regular column for each job
     for row in rows:
         job_id = str(row[JobTableColumns.ID]).strip().replace(' ⤳', '')
         if job_id and job_id != '-':
@@ -174,17 +176,21 @@ def home():
                         log_content = f.read()
                         row[JobTableColumns.FAILOVER] = _extract_launch_history(
                             log_content)
+                        row[JobTableColumns.LOG_CONTENT] = log_content
                 else:
                     row[JobTableColumns.FAILOVER] = 'Log file not found'
+                    row[JobTableColumns.LOG_CONTENT] = 'Log file not found'
             except (IOError, OSError) as e:
-                row[JobTableColumns.FAILOVER] = f'Error reading log: {str(e)}'
-    app.logger.error('All managed jobs:')
+                error_msg = f'Error reading log: {str(e)}'
+                row[JobTableColumns.FAILOVER] = error_msg
+                row[JobTableColumns.LOG_CONTENT] = error_msg
+        else:
+            row[JobTableColumns.LOG_CONTENT] = ''
 
-    # Validate column count
     if rows and len(rows[0]) != len(JOB_TABLE_COLUMNS):
         raise RuntimeError(
             f'Dashboard code and managed job queue code are out of sync. '
-            f'Expected {(JOB_TABLE_COLUMNS)} columns, got {(rows[0])}')
+            f'Expected {JOB_TABLE_COLUMNS} columns, got {rows[0]}')
 
     # Fix STATUS color codes: '\x1b[33mCANCELLED\x1b[0m' -> 'CANCELLED'
     for row in rows:
@@ -208,26 +214,10 @@ def home():
         last_updated_timestamp=timestamp,
         status_values=status_values,
         status_counts=status_counts,
+        request=flask.request,
     )
     return rendered_html
 
 
-@app.route('/download_log/<job_id>')
-def download_log(job_id):
-    try:
-        log_path = os.path.join(
-            os.path.expanduser(managed_job_constants.JOBS_CONTROLLER_LOGS_DIR),
-            f'{job_id}.log')
-        if not os.path.exists(log_path):
-            flask.abort(404)
-        return flask.send_file(log_path,
-                               mimetype='text/plain',
-                               as_attachment=True,
-                               download_name=f'job_{job_id}.log')
-    except (IOError, OSError) as e:
-        app.logger.error(f'Error downloading log for job {job_id}: {str(e)}')
-        flask.abort(500)
-
-
 if __name__ == '__main__':
     app.run()

sky/jobs/dashboard/templates/index.html

@@ -498,10 +498,10 @@
                     <td data-full-text="{{ row[13] }}">{{ row[13] }}</td>  {# Details #}
                     <td>
                         {% if row[1]|string|replace(' \u21B3', '') and row[1]|string|replace(' \u21B3', '') != '-' %}
-                        <a href="{{ url_for('download_log', job_id=row[1]|string|replace(' \u21B3', '')) }}"
-                           class="btn btn-sm btn-outline-secondary">
+                        <button class="btn btn-sm btn-outline-secondary log-btn" 
+                                data-job-id="{{ row[1]|string|replace(' \u21B3', '') }}">
                             controller log
-                        </a>
+                        </button>
                         {% endif %}
                     </td>
                 </tr>
@@ -509,6 +509,41 @@
             </tbody>
         </table>
     </div>
+    
+    <!-- Hidden container for log content -->
+    <div style="display: none;">
+        {% for row in rows %}
+            {% if row[1]|string|replace(' \u21B3', '') and row[1]|string|replace(' \u21B3', '') != '-' %}
+            <pre id="log-content-{{ row[1]|string|replace(' \u21B3', '') }}">{{ row[-1]|e }}</pre>
+            {% endif %}
+        {% endfor %}
+    </div>
+    
+    <!-- Log Modal -->
+    <div class="modal fade" id="logModal" tabindex="-1" aria-labelledby="logModalLabel" aria-hidden="true">
+        <div class="modal-dialog modal-dialog-centered modal-lg">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title" id="logModalLabel">Controller Log</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+                </div>
+                <div class="modal-body">
+                    <div id="logContent" style="white-space: pre-wrap; font-family: monospace; max-height: 70vh; overflow-y: auto; font-size: 0.85rem;"></div>
+                    <div id="logError" class="alert alert-danger d-none">
+                        Error loading log content. Please try again.
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
+                    <a id="downloadLogBtn" href="#" class="btn btn-primary" download>Download</a>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.3/dist/js/bootstrap.bundle.min.js" 
+        integrity="sha384-kenU1KFdBIe4zVF0s0G1M5b4hcpxyD9F7jL+jjXkk+Q2h455rYXK/7HAuoJl+0I4" 
+        crossorigin="anonymous"></script>
     <script>
         // Folder toggle for pipelines, this will fold/unfold the rows for
         // a pipeline and its tasks.
@@ -729,6 +764,68 @@
         });
     });
 </script>
+<script>
+    // Function to show log modal and display pre-loaded log content
+    function showLogModal(jobId, logContent) {
+        try {
+            // Initialize modal
+            const logModal = new bootstrap.Modal(document.getElementById('logModal'));
+            const logContentEl = document.getElementById('logContent');
+            const logError = document.getElementById('logError');
+            const downloadBtn = document.getElementById('downloadLogBtn');
+            
+            // Create a Blob for download functionality
+            const blob = new Blob([logContent], { type: 'text/plain' });
+            const url = URL.createObjectURL(blob);
+            
+            // Set download button href
+            downloadBtn.href = url;
+            downloadBtn.setAttribute('download', `job_${jobId}.log`);
+            
+            // Clear previous content and show new content directly
+            logContentEl.textContent = logContent || 'No log content available';
+            logError.classList.add('d-none');
+            
+            // Set modal title
+            document.getElementById('logModalLabel').textContent = `Controller Log - Job ${jobId}`;
+            
+            // Show modal
+            logModal.show();
+            
+            // Cleanup the URL object when the modal is hidden
+            document.getElementById('logModal').addEventListener('hidden.bs.modal', function() {
+                URL.revokeObjectURL(url);
+            }, { once: true });
+        } catch (error) {
+            console.error('Error showing log modal:', error);
+            document.getElementById('logError').classList.remove('d-none');
+            document.getElementById('logError').textContent = `Error showing log: ${error.message}`;
+        }
+    }
+
+    // Add event listeners for log buttons
+    document.addEventListener('DOMContentLoaded', function() {
+        document.addEventListener('click', function(event) {
+            if (event.target.closest('.log-btn')) {
+                try {
+                    const button = event.target.closest('.log-btn');
+                    const jobId = button.dataset.jobId;
+                    const logContentEl = document.getElementById(`log-content-${jobId}`);
+                    
+                    if (!logContentEl) {
+                        throw new Error(`Log content element not found for job ${jobId}`);
+                    }
+                    
+                    const logContent = logContentEl.textContent;
+                    showLogModal(jobId, logContent);
+                } catch (error) {
+                    console.error('Error getting log content:', error);
+                    showLogModal(jobId, `Error loading log: ${error.message}`);
+                }
+            }
+        });
+    });
+</script>
 </body>
 
 </html>

sky/jobs/server/core.py

@@ -460,12 +460,17 @@ def cancel(name: Optional[str] = None,
 
 @usage_lib.entrypoint
 def tail_logs(name: Optional[str], job_id: Optional[int], follow: bool,
-              controller: bool, refresh: bool) -> None:
+              controller: bool, refresh: bool) -> int:
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Tail logs of managed jobs.
 
     Please refer to sky.cli.job_logs for documentation.
 
+    Returns:
+        Exit code based on success or failure of the job. 0 if success,
+        100 if the job failed. See exceptions.JobExitCode for possible exit
+        codes.
+
     Raises:
         ValueError: invalid arguments.
         sky.exceptions.ClusterNotUpError: the jobs controller is not up.
@@ -494,11 +499,11 @@ def tail_logs(name: Optional[str], job_id: Optional[int], follow: bool,
     backend = backend_utils.get_backend_from_handle(handle)
     assert isinstance(backend, backends.CloudVmRayBackend), backend
 
-    backend.tail_managed_job_logs(handle,
-                                  job_id=job_id,
-                                  job_name=name,
-                                  follow=follow,
-                                  controller=controller)
+    return backend.tail_managed_job_logs(handle,
+                                         job_id=job_id,
+                                         job_name=name,
+                                         follow=follow,
+                                         controller=controller)
 
 
 def start_dashboard_forwarding(refresh: bool = False) -> Tuple[int, int]:

sky/jobs/utils.py

@@ -511,8 +511,14 @@ def cancel_job_by_name(job_name: str) -> str:
     return f'Job {job_name!r} is scheduled to be cancelled.'
 
 
-def stream_logs_by_id(job_id: int, follow: bool = True) -> str:
-    """Stream logs by job id."""
+def stream_logs_by_id(job_id: int, follow: bool = True) -> Tuple[str, int]:
+    """Stream logs by job id.
+
+    Returns:
+        A tuple containing the log message and an exit code based on success or
+        failure of the job. 0 if success, 100 if the job failed.
+        See exceptions.JobExitCode for possible exit codes.
+    """
 
     def should_keep_logging(status: managed_job_state.ManagedJobStatus) -> bool:
         # If we see CANCELLING, just exit - we could miss some job logs but the
@@ -547,13 +553,16 @@ def stream_logs_by_id(job_id: int, follow: bool = True) -> str:
                             start_streaming = True
                         if start_streaming:
                             print(line, end='', flush=True)
-                return ''
+                return '', exceptions.JobExitCode.from_managed_job_status(
+                    managed_job_status)
             return (f'{colorama.Fore.YELLOW}'
                     f'Job {job_id} is already in terminal state '
                     f'{managed_job_status.value}. For more details, run: '
                     f'sky jobs logs --controller {job_id}'
                     f'{colorama.Style.RESET_ALL}'
-                    f'{job_msg}')
+                    f'{job_msg}',
+                    exceptions.JobExitCode.from_managed_job_status(
+                        managed_job_status))
         backend = backends.CloudVmRayBackend()
         task_id, managed_job_status = (
             managed_job_state.get_latest_task_id_status(job_id))
@@ -604,11 +613,12 @@ def stream_logs_by_id(job_id: int, follow: bool = True) -> str:
                                            job_id=None,
                                            managed_job_id=job_id,
                                            follow=follow)
-            if returncode == 0:
-                # If the log tailing exit successfully (the real job can be
-                # SUCCEEDED or FAILED), we can safely break the loop. We use the
-                # status in job queue to show the information, as the
-                # ManagedJobStatus is not updated yet.
+            if returncode in [rc.value for rc in exceptions.JobExitCode]:
+                # If the log tailing exits with a known exit code we can safely
+                # break the loop because it indicates the tailing process
+                # succeeded (even though the real job can be SUCCEEDED or
+                # FAILED). We use the status in job queue to show the
+                # information, as the ManagedJobStatus is not updated yet.
                 job_statuses = backend.get_job_status(handle, stream_logs=False)
                 job_status = list(job_statuses.values())[0]
                 assert job_status is not None, 'No job found.'
@@ -728,18 +738,25 @@ def stream_logs_by_id(job_id: int, follow: bool = True) -> str:
     logger.info(
         ux_utils.finishing_message(f'Managed job finished: {job_id} '
                                    f'(status: {managed_job_status.value}).'))
-    return ''
+    return '', exceptions.JobExitCode.from_managed_job_status(
+        managed_job_status)
 
 
 def stream_logs(job_id: Optional[int],
                 job_name: Optional[str],
                 controller: bool = False,
-                follow: bool = True) -> str:
-    """Stream logs by job id or job name."""
+                follow: bool = True) -> Tuple[str, int]:
+    """Stream logs by job id or job name.
+
+    Returns:
+        A tuple containing the log message and the exit code based on success
+        or failure of the job. 0 if success, 100 if the job failed.
+        See exceptions.JobExitCode for possible exit codes.
+    """
     if job_id is None and job_name is None:
         job_id = managed_job_state.get_latest_job_id()
         if job_id is None:
-            return 'No managed job found.'
+            return 'No managed job found.', exceptions.JobExitCode.NOT_FOUND
 
     if controller:
         if job_id is None:
@@ -754,7 +771,8 @@ def stream_logs(job_id: Optional[int],
                 if job['job_name'] == job_name
             }
             if not managed_job_ids:
-                return f'No managed job found with name {job_name!r}.'
+                return (f'No managed job found with name {job_name!r}.',
+                        exceptions.JobExitCode.NOT_FOUND)
             if len(managed_job_ids) > 1:
                 job_ids_str = ', '.join(
                     str(job_id) for job_id in managed_job_ids)
@@ -776,7 +794,7 @@ def stream_logs(job_id: Optional[int],
             if not follow:
                 # Assume that the log file hasn't been written yet. Since we
                 # aren't following, just return.
-                return ''
+                return '', exceptions.JobExitCode.SUCCEEDED
 
             job_status = managed_job_state.get_status(job_id)
             if job_status is None:
@@ -787,7 +805,8 @@ def stream_logs(job_id: Optional[int],
                 # point, it never will be. This job may have been submitted
                 # using an old version that did not create the log file, so this
                 # is not considered an exceptional case.
-                return ''
+                return '', exceptions.JobExitCode.from_managed_job_status(
+                    job_status)
 
             time.sleep(log_lib.SKY_LOG_WAITING_GAP_SECONDS)
 
@@ -833,15 +852,17 @@ def stream_logs(job_id: Optional[int],
 
         if follow:
             return ux_utils.finishing_message(
-                f'Job finished (status: {job_status}).')
+                f'Job finished (status: {job_status}).'
+            ), exceptions.JobExitCode.from_managed_job_status(job_status)
 
-        return ''
+        return '', exceptions.JobExitCode.SUCCEEDED
 
     if job_id is None:
         assert job_name is not None
         job_ids = managed_job_state.get_nonterminal_job_ids_by_name(job_name)
         if not job_ids:
-            return f'No running managed job found with name {job_name!r}.'
+            return (f'No running managed job found with name {job_name!r}.',
+                    exceptions.JobExitCode.NOT_FOUND)
         if len(job_ids) > 1:
             raise ValueError(
                 f'Multiple running jobs found with name {job_name!r}.')
@@ -1167,6 +1188,7 @@ class ManagedJobCodeGen:
       >> codegen = ManagedJobCodeGen.show_jobs(...)
     """
     _PREFIX = textwrap.dedent("""\
+        import sys
         from sky.jobs import utils
         from sky.jobs import state as managed_job_state
         from sky.jobs import constants as managed_job_constants
@@ -1222,9 +1244,17 @@ class ManagedJobCodeGen:
                     follow: bool = True,
                     controller: bool = False) -> str:
         code = textwrap.dedent(f"""\
-        msg = utils.stream_logs({job_id!r}, {job_name!r},
+        result = utils.stream_logs(job_id={job_id!r}, job_name={job_name!r},
                                 follow={follow}, controller={controller})
-        print(msg, flush=True)
+        if managed_job_version < 3:
+            # Versions 2 and older did not return a retcode, so we just print
+            # the result.
+            # TODO: Remove compatibility before 0.12.0
+            print(result, flush=True)
+        else:
+            msg, retcode = result
+            print(msg, flush=True)
+            sys.exit(retcode)
         """)
         return cls._build(code)
 

sky/server/constants.py

@@ -3,7 +3,7 @@
 # API server version, whenever there is a change in API server that requires a
 # restart of the local API server or error out when the client does not match
 # the server version.
-API_VERSION = '2'
+API_VERSION = '3'
 
 # Prefix for API request names.
 REQUEST_NAME_PREFIX = 'sky.'

sky/server/requests/payloads.py

@@ -12,6 +12,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 import pydantic
 
+from sky import admin_policy
 from sky import serve
 from sky import sky_logging
 from sky import skypilot_config
@@ -113,15 +114,9 @@ class CheckBody(RequestBody):
     verbose: bool
 
 
-class ValidateBody(RequestBody):
-    """The request body for the validate endpoint."""
-    dag: str
-
-
-class OptimizeBody(RequestBody):
-    """The request body for the optimize endpoint."""
+class DagRequestBody(RequestBody):
+    """Request body base class for endpoints with a dag."""
     dag: str
-    minimize: common_lib.OptimizeTarget = common_lib.OptimizeTarget.COST
 
     def to_kwargs(self) -> Dict[str, Any]:
         # Import here to avoid requirement of the whole SkyPilot dependency on
@@ -139,6 +134,19 @@ class OptimizeBody(RequestBody):
         return kwargs
 
 
+class ValidateBody(DagRequestBody):
+    """The request body for the validate endpoint."""
+    dag: str
+    request_options: Optional[admin_policy.RequestOptions]
+
+
+class OptimizeBody(DagRequestBody):
+    """The request body for the optimize endpoint."""
+    dag: str
+    minimize: common_lib.OptimizeTarget = common_lib.OptimizeTarget.COST
+    request_options: Optional[admin_policy.RequestOptions]
+
+
 class LaunchBody(RequestBody):
     """The request body for the launch endpoint."""
     task: str

sky/server/server.py

@@ -27,7 +27,6 @@ from sky import core
 from sky import exceptions
 from sky import execution
 from sky import global_user_state
-from sky import optimizer
 from sky import sky_logging
 from sky.clouds import service_catalog
 from sky.data import storage_utils
@@ -42,6 +41,7 @@ from sky.server.requests import payloads
 from sky.server.requests import requests as requests_lib
 from sky.skylet import constants
 from sky.usage import usage_lib
+from sky.utils import admin_policy_utils
 from sky.utils import common as common_lib
 from sky.utils import common_utils
 from sky.utils import dag_utils
@@ -258,9 +258,22 @@ async def validate(validate_body: payloads.ValidateBody) -> None:
     """Validates the user's DAG."""
     # TODO(SKY-1035): validate if existing cluster satisfies the requested
     # resources, e.g. sky exec --gpus V100:8 existing-cluster-with-no-gpus
+
+    # TODO: Our current launch process is split into three calls:
+    # validate, optimize, and launch. This requires us to apply the admin policy
+    # in each step, which may be an expensive operation. We should consolidate
+    # these into a single call or have a TTL cache for (task, admin_policy)
+    # pairs.
     logger.debug(f'Validating tasks: {validate_body.dag}')
     try:
         dag = dag_utils.load_chain_dag_from_yaml_str(validate_body.dag)
+        # TODO: Admin policy may contain arbitrary code, which may be expensive
+        # to run and may block the server thread. However, moving it into the
+        # executor adds a ~150ms penalty on the local API server because of
+        # added RTTs. For now, we stick to doing the validation inline in the
+        # server thread.
+        dag, _ = admin_policy_utils.apply(
+            dag, request_options=validate_body.request_options)
         for task in dag.tasks:
             # Will validate workdir and file_mounts in the backend, as those
             # need to be validated after the files are uploaded to the SkyPilot
@@ -283,7 +296,7 @@ async def optimize(optimize_body: payloads.OptimizeBody,
         request_name='optimize',
         request_body=optimize_body,
         ignore_return_value=True,
-        func=optimizer.Optimizer.optimize,
+        func=core.optimize,
         schedule_type=requests_lib.ScheduleType.SHORT,
     )
 

sky/skylet/constants.py

@@ -93,7 +93,7 @@ SKYLET_VERSION = '12'
 # The version of the lib files that skylet/jobs use. Whenever there is an API
 # change for the job_lib or log_lib, we need to bump this version, so that the
 # user can be notified to update their SkyPilot version on the remote cluster.
-SKYLET_LIB_VERSION = 2
+SKYLET_LIB_VERSION = 3
 SKYLET_VERSION_FILE = '~/.sky/skylet_version'
 
 # `sky jobs dashboard`-related

sky/skylet/job_lib.py

@@ -938,7 +938,9 @@ class JobLibCodeGen:
     _PREFIX = [
         'import os',
         'import getpass',
-        'from sky.skylet import job_lib, log_lib, constants',
+        'import sys',
+        'from sky import exceptions',
+        'from sky.skylet import log_lib, job_lib, constants',
     ]
 
     @classmethod
@@ -1033,6 +1035,13 @@ class JobLibCodeGen:
             f'tail_log_kwargs = {{"job_id": job_id, "log_dir": log_dir, "managed_job_id": {managed_job_id!r}, "follow": {follow}}}',
             f'{_LINUX_NEW_LINE}if getattr(constants, "SKYLET_LIB_VERSION", 1) > 1: tail_log_kwargs["tail"] = {tail}',
             f'{_LINUX_NEW_LINE}log_lib.tail_logs(**tail_log_kwargs)',
+            # After tailing, check the job status and exit with appropriate code
+            'job_status = job_lib.get_status(job_id)',
+            # Backward compatibility for returning exit code: Skylet versions 2
+            # and older did not have JobExitCode, so we use 0 for those versions
+            # TODO: Remove this special handling after 0.10.0.
+            'exit_code = exceptions.JobExitCode.from_job_status(job_status) if getattr(constants, "SKYLET_LIB_VERSION", 1) > 2 else 0',
+            'sys.exit(exit_code)',
         ]
         return cls._build(code)