skypilot-nightly 1.0.0.dev20250628__py3-none-any.whl → 1.0.0.dev20250701__py3-none-any.whl

sky/jobs/utils.py

@@ -180,12 +180,6 @@ def is_consolidation_mode() -> bool:
     return consolidation_mode
 
 
-def get_ha_dump_script_path(job_id: int) -> pathlib.Path:
-    """Get the path to the HA dump script for a job."""
-    return pathlib.Path(constants.PERSISTENT_RUN_SCRIPT_DIR).expanduser(
-    ).resolve() / f'sky_job_{job_id}'
-
-
 def ha_recovery_for_consolidation_mode():
     """Recovery logic for HA mode."""
     # No setup recovery is needed in consolidation mode, as the API server
@@ -221,17 +215,15 @@ def ha_recovery_for_consolidation_mode():
                     managed_job_state.ManagedJobScheduleState.DONE,
                     managed_job_state.ManagedJobScheduleState.WAITING
             ]:
-                dump_script_path = get_ha_dump_script_path(job_id)
-                if not dump_script_path.exists():
-                    f.write(f'Job {job_id}\'s recovery file ({dump_script_path}'
-                            ') does not exist. Skipping recovery. Job '
-                            f'schedule state: {job["schedule_state"]}\n')
+                script = managed_job_state.get_ha_recovery_script(job_id)
+                if script is None:
+                    f.write(f'Job {job_id}\'s recovery script does not exist. '
+                            'Skipping recovery. Job schedule state: '
+                            f'{job["schedule_state"]}\n')
                     continue
-                with open(dump_script_path, 'r', encoding='utf-8') as script_f:
-                    script = script_f.read()
                 runner.run(script)
-                f.write(f'Job {job_id} (file: {dump_script_path}) completed '
-                        f'recovery at {datetime.datetime.now()}\n')
+                f.write(f'Job {job_id} completed recovery at '
+                        f'{datetime.datetime.now()}\n')
         f.write(f'HA recovery completed at {datetime.datetime.now()}\n')
         f.write(f'Total recovery time: {time.time() - start} seconds\n')
 

sky/optimizer.py

@@ -1252,6 +1252,52 @@ def _check_specified_clouds(dag: 'dag_lib.Dag') -> None:
             logger.warning(
                 f'{colorama.Fore.YELLOW}{msg}{colorama.Style.RESET_ALL}')
 
+        _check_specified_regions(task)
+
+
+def _check_specified_regions(task: task_lib.Task) -> None:
+    """Check if specified regions (Kubernetes contexts) are enabled.
+
+    Args:
+        task: The task to check.
+    """
+    # Only check for Kubernetes now
+    if not all(
+            isinstance(resources.cloud, clouds.Kubernetes)
+            for resources in task.resources):
+        return
+    # Kubernetes region is a context if set
+    for resources in task.resources:
+        if resources.region is None:
+            continue
+        existing_contexts = clouds.Kubernetes.existing_allowed_contexts()
+        region = resources.region
+        task_name = f' {task.name!r}' if task.name is not None else ''
+        msg = f'Task{task_name} requires '
+        if region not in existing_contexts:
+            infra_str = f'Kubernetes/{region}'
+            logger.warning(f'{infra_str} is not enabled.')
+            volume_mounts_str = ''
+            if task.volume_mounts:
+                if len(task.volume_mounts) > 1:
+                    volume_mounts_str += 'volumes '
+                else:
+                    volume_mounts_str += 'volume '
+                volume_mounts_str += ', '.join(
+                    [f'{v.volume_name}' for v in task.volume_mounts])
+                volume_mounts_str += f' with infra {infra_str}'
+            if volume_mounts_str:
+                msg += volume_mounts_str
+            else:
+                msg += f'infra {infra_str}'
+            msg += (
+                f' which is not enabled. To enable access, change '
+                f'the task infra requirement or run: {colorama.Style.BRIGHT}'
+                f'sky check {colorama.Style.RESET_ALL}'
+                f'to ensure the infra is enabled.')
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.ResourcesUnavailableError(msg)
+
 
 def _fill_in_launchable_resources(
     task: task_lib.Task,

sky/provision/__init__.py

@@ -6,7 +6,7 @@ providers supported by SkyPilot need to follow.
 import functools
 import inspect
 import typing
-from typing import Any, Dict, List, Optional, Type
+from typing import Any, Dict, List, Optional, Tuple, Type
 
 from sky import models
 from sky import sky_logging
@@ -106,7 +106,7 @@ def bootstrap_instances(
 
 @_route_to_cloud_impl
 def apply_volume(provider_name: str,
-                 config: models.VolumeConfig) -> models.VolumeConfig:
+                 volume_config: models.VolumeConfig) -> models.VolumeConfig:
     """Create or register a volume.
 
     This function creates or registers a volume with the provided configuration,
@@ -117,15 +117,23 @@ def apply_volume(provider_name: str,
 
 @_route_to_cloud_impl
 def delete_volume(provider_name: str,
-                  config: models.VolumeConfig) -> models.VolumeConfig:
+                  volume_config: models.VolumeConfig) -> models.VolumeConfig:
     """Delete a volume."""
     raise NotImplementedError
 
 
 @_route_to_cloud_impl
-def get_volume_usedby(provider_name: str,
-                      config: models.VolumeConfig) -> List[str]:
-    """Get the usedby of a volume."""
+def get_volume_usedby(
+    provider_name: str,
+    volume_config: models.VolumeConfig,
+) -> Tuple[List[str], List[str]]:
+    """Get the usedby of a volume.
+
+    Returns:
+        usedby_pods: List of pods using the volume. These may include pods
+                     not created by SkyPilot.
+        usedby_clusters: List of clusters using the volume.
+    """
     raise NotImplementedError
 
 

sky/provision/kubernetes/constants.py

@@ -15,3 +15,12 @@ SKY_K8S_EXEC_AUTH_PATH = '$HOME/skypilot-runtime/bin:$HOME/google-cloud-sdk/bin:
 
 # cache directory for kubeconfig with modified exec auth
 SKY_K8S_EXEC_AUTH_KUBECONFIG_CACHE = '~/.sky/generated/kubeconfigs'
+
+# Labels for the Pods created by SkyPilot
+TAG_RAY_CLUSTER_NAME = 'ray-cluster-name'
+TAG_SKYPILOT_CLUSTER_NAME = 'skypilot-cluster-name'
+TAG_POD_INITIALIZED = 'skypilot-initialized'
+TAG_SKYPILOT_DEPLOYMENT_NAME = 'skypilot-deployment-name'
+
+# Pod phases that are not holding PVCs
+PVC_NOT_HOLD_POD_PHASES = ['Succeeded', 'Failed']

sky/provision/kubernetes/instance.py

@@ -12,6 +12,7 @@ from sky.provision import common
 from sky.provision import constants
 from sky.provision import docker_utils
 from sky.provision.kubernetes import config as config_lib
+from sky.provision.kubernetes import constants as k8s_constants
 from sky.provision.kubernetes import network_utils
 from sky.provision.kubernetes import utils as kubernetes_utils
 from sky.provision.kubernetes import volume
@@ -30,14 +31,10 @@ _MAX_RETRIES = 3
 _NUM_THREADS = subprocess_utils.get_parallel_threads('kubernetes')
 
 logger = sky_logging.init_logger(__name__)
-TAG_RAY_CLUSTER_NAME = 'ray-cluster-name'
-TAG_SKYPILOT_CLUSTER_NAME = 'skypilot-cluster-name'
-TAG_POD_INITIALIZED = 'skypilot-initialized'
-TAG_SKYPILOT_DEPLOYMENT_NAME = 'skypilot-deployment-name'
 
 
 def ray_tag_filter(cluster_name: str) -> Dict[str, str]:
-    return {TAG_RAY_CLUSTER_NAME: cluster_name}
+    return {k8s_constants.TAG_RAY_CLUSTER_NAME: cluster_name}
 
 
 def _is_head(pod) -> bool:
@@ -75,7 +72,8 @@ def is_high_availability_cluster_by_kubectl(
         deployment_list = kubernetes.apps_api(
             context).list_namespaced_deployment(
                 namespace,
-                label_selector=f'{TAG_SKYPILOT_CLUSTER_NAME}={cluster_name}')
+                label_selector=
+                f'{k8s_constants.TAG_SKYPILOT_CLUSTER_NAME}={cluster_name}')
     except kubernetes.api_exception():
         return False
     # It is a high availability cluster if there is at least one deployment
@@ -280,10 +278,12 @@ def _wait_for_pods_to_schedule(namespace, context, new_nodes, timeout: int):
     while _evaluate_timeout():
         # Get all pods in a single API call using the cluster name label
         # which all pods in new_nodes should share
-        cluster_name = new_nodes[0].metadata.labels[TAG_SKYPILOT_CLUSTER_NAME]
+        cluster_name = new_nodes[0].metadata.labels[
+            k8s_constants.TAG_SKYPILOT_CLUSTER_NAME]
         pods = kubernetes.core_api(context).list_namespaced_pod(
             namespace,
-            label_selector=f'{TAG_SKYPILOT_CLUSTER_NAME}={cluster_name}').items
+            label_selector=
+            f'{k8s_constants.TAG_SKYPILOT_CLUSTER_NAME}={cluster_name}').items
 
         # Get the set of found pod names and check if we have all expected pods
         found_pod_names = {pod.metadata.name for pod in pods}
@@ -361,10 +361,12 @@ def _wait_for_pods_to_run(namespace, context, new_nodes):
 
     while True:
         # Get all pods in a single API call
-        cluster_name = new_nodes[0].metadata.labels[TAG_SKYPILOT_CLUSTER_NAME]
+        cluster_name = new_nodes[0].metadata.labels[
+            k8s_constants.TAG_SKYPILOT_CLUSTER_NAME]
         all_pods = kubernetes.core_api(context).list_namespaced_pod(
             namespace,
-            label_selector=f'{TAG_SKYPILOT_CLUSTER_NAME}={cluster_name}').items
+            label_selector=
+            f'{k8s_constants.TAG_SKYPILOT_CLUSTER_NAME}={cluster_name}').items
 
         # Get the set of found pod names and check if we have all expected pods
         found_pod_names = {pod.metadata.name for pod in all_pods}
@@ -732,7 +734,7 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
     else:
         pod_spec['metadata']['labels'] = tags
     pod_spec['metadata']['labels'].update(
-        {TAG_SKYPILOT_CLUSTER_NAME: cluster_name_on_cloud})
+        {k8s_constants.TAG_SKYPILOT_CLUSTER_NAME: cluster_name_on_cloud})
 
     terminating_pods = kubernetes_utils.filter_pods(namespace, context, tags,
                                                     ['Terminating'])
@@ -841,7 +843,7 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
                 'podAffinityTerm': {
                     'labelSelector': {
                         'matchExpressions': [{
-                            'key': TAG_SKYPILOT_CLUSTER_NAME,
+                            'key': k8s_constants.TAG_SKYPILOT_CLUSTER_NAME,
                             'operator': 'In',
                             'values': [cluster_name_on_cloud]
                         }]
@@ -884,7 +886,7 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
             # Add the deployment name as a label to the pod spec
             deployment_name = deployment_spec['metadata']['name']
             pod_spec_copy['metadata']['labels'][
-                TAG_SKYPILOT_DEPLOYMENT_NAME] = deployment_name
+                k8s_constants.TAG_SKYPILOT_DEPLOYMENT_NAME] = deployment_name
             template_pod_spec['metadata'] = pod_spec_copy['metadata']
             template_pod_spec['spec'].update(pod_spec_copy['spec'])
             # Propagate the labels to the deployment for identification.
@@ -1289,7 +1291,8 @@ def get_command_runners(
 
         # Try to get deployment name from label first
         head_instance_info = instances[pod_name][0]
-        deployment = head_instance_info.tags.get(TAG_SKYPILOT_DEPLOYMENT_NAME)
+        deployment = head_instance_info.tags.get(
+            k8s_constants.TAG_SKYPILOT_DEPLOYMENT_NAME)
 
         node_list = [((namespace, context), pod_name)]
         head_runner = command_runner.KubernetesCommandRunner(

sky/provision/kubernetes/volume.py

@@ -1,10 +1,12 @@
 """Kubernetes pvc provisioning."""
 from typing import Any, Dict, List, Optional, Tuple
 
+from sky import global_user_state
 from sky import models
 from sky import sky_logging
 from sky.adaptors import kubernetes
 from sky.provision.kubernetes import config as config_lib
+from sky.provision.kubernetes import constants as k8s_constants
 from sky.provision.kubernetes import utils as kubernetes_utils
 from sky.volumes import volume as volume_lib
 
@@ -45,17 +47,26 @@ def check_pvc_usage_for_pod(context: Optional[str], namespace: str,
         access_mode = pvc.spec.access_modes[0]
         if access_mode not in once_modes:
             continue
-        usedby = _get_volume_usedby(context, namespace, pvc_name)
-        if usedby:
+        usedby_pods, _ = _get_volume_usedby(context, namespace, pvc_name)
+        if usedby_pods:
             raise config_lib.KubernetesError(f'Volume {pvc_name} with access '
                                              f'mode {access_mode} is already '
-                                             f'in use by {usedby}.')
+                                             f'in use by Pods {usedby_pods}.')
 
 
 def apply_volume(config: models.VolumeConfig) -> models.VolumeConfig:
     """Creates or registers a volume."""
     context, namespace = _get_context_namespace(config)
     pvc_spec = _get_pvc_spec(namespace, config)
+    # Check if the storage class exists
+    storage_class_name = pvc_spec['spec'].get('storageClassName')
+    if storage_class_name is not None:
+        try:
+            kubernetes.storage_api(context).read_storage_class(
+                name=storage_class_name)
+        except kubernetes.api_exception() as e:
+            raise config_lib.KubernetesError(
+                f'Check storage class {storage_class_name} error: {e}')
     create_persistent_volume_claim(namespace, context, pvc_spec)
     return config
 
@@ -76,22 +87,73 @@ def delete_volume(config: models.VolumeConfig) -> models.VolumeConfig:
     return config
 
 
-def _get_volume_usedby(context: Optional[str], namespace: str,
-                       pvc_name: str) -> List[str]:
-    """Gets the usedby resources of a volume."""
-    usedby = []
+def _get_volume_usedby(
+    context: Optional[str],
+    namespace: str,
+    pvc_name: str,
+) -> Tuple[List[str], List[str]]:
+    """Gets the usedby resources of a volume.
+
+    This function returns the pods and clusters that are using the volume.
+    The usedby_pods is accurate, which also includes the Pods that are not
+    managed by SkyPilot.
+
+    Args:
+        context: Kubernetes context
+        namespace: Kubernetes namespace
+        pvc_name: PVC name
+
+    Returns:
+        usedby_pods: List of pods using the volume. These may include pods
+                     not created by SkyPilot.
+        usedby_clusters: List of clusters using the volume.
+    """
+    usedby_pods = []
+    usedby_clusters = []
+    field_selector = ','.join([
+        f'status.phase!={phase}'
+        for phase in k8s_constants.PVC_NOT_HOLD_POD_PHASES
+    ])
+    cloud_to_name_map = _get_cluster_name_on_cloud_to_cluster_name_map()
     # Get all pods in the namespace
-    pods = kubernetes.core_api(context).list_namespaced_pod(namespace=namespace)
+    pods = kubernetes.core_api(context).list_namespaced_pod(
+        namespace=namespace, field_selector=field_selector)
     for pod in pods.items:
-        if pod.spec.volumes is not None:
-            for volume in pod.spec.volumes:
-                if volume.persistent_volume_claim is not None:
-                    if volume.persistent_volume_claim.claim_name == pvc_name:
-                        usedby.append(pod.metadata.name)
-    return usedby
+        if pod.spec.volumes is None:
+            continue
+        for volume in pod.spec.volumes:
+            if volume.persistent_volume_claim is None:
+                continue
+            if volume.persistent_volume_claim.claim_name == pvc_name:
+                usedby_pods.append(pod.metadata.name)
+                # Get the real cluster name
+                cluster_name_on_cloud = pod.metadata.labels.get(
+                    k8s_constants.TAG_SKYPILOT_CLUSTER_NAME)
+                if cluster_name_on_cloud is None:
+                    continue
+                cluster_name = cloud_to_name_map.get(cluster_name_on_cloud)
+                if cluster_name is not None:
+                    usedby_clusters.append(cluster_name)
+    if usedby_pods:
+        logger.debug(f'Volume {pvc_name} is used by Pods {usedby_pods}'
+                     f' and clusters {usedby_clusters}')
+    return usedby_pods, usedby_clusters
+
+
+def _get_cluster_name_on_cloud_to_cluster_name_map() -> Dict[str, str]:
+    """Gets the map from cluster name on cloud to cluster name."""
+    clusters = global_user_state.get_clusters()
+    cloud_to_name_map = {}
+    for cluster in clusters:
+        handle = cluster['handle']
+        if handle is None:
+            continue
+        cloud_to_name_map[handle.cluster_name_on_cloud] = cluster['name']
+    return cloud_to_name_map
 
 
-def get_volume_usedby(config: models.VolumeConfig) -> List[str]:
+def get_volume_usedby(
+    config: models.VolumeConfig,) -> Tuple[List[str], List[str]]:
     """Gets the usedby resources of a volume."""
     context, namespace = _get_context_namespace(config)
     pvc_name = config.name_on_cloud

sky/server/common.py

@@ -293,6 +293,7 @@ def get_api_server_status(endpoint: Optional[str] = None) -> ApiServerInfo:
         try:
             response = make_authenticated_request('GET',
                                                   '/api/health',
+                                                  server_url=server_url,
                                                   timeout=2.5)
         except requests.exceptions.Timeout:
             if time_out_try_count == RETRY_COUNT_ON_TIMEOUT:

sky/server/server.py

@@ -277,29 +277,51 @@ class BearerTokenMiddleware(starlette.middleware.base.BaseHTTPMiddleware):
     """Middleware to handle Bearer Token Auth (Service Accounts)."""
 
     async def dispatch(self, request: fastapi.Request, call_next):
-        # Only process requests with Bearer token authorization header
+        """Make sure correct bearer token auth is present.
+
+        1. If the request has the X-Skypilot-Auth-Mode: token header, it must
+           have a valid bearer token.
+        2. For backwards compatibility, if the request has a Bearer token
+           beginning with "sky_" (even if X-Skypilot-Auth-Mode is not present),
+           it must be a valid token.
+        3. If X-Skypilot-Auth-Mode is not set to "token", and there is no Bearer
+           token beginning with "sky_", allow the request to continue.
+
+        In conjunction with an auth proxy, the idea is to make the auth proxy
+        bypass requests with bearer tokens, instead setting the
+        X-Skypilot-Auth-Mode header. The auth proxy should either validate the
+        auth or set the header X-Skypilot-Auth-Mode: token.
+        """
+        has_skypilot_auth_header = (
+            request.headers.get('X-Skypilot-Auth-Mode') == 'token')
         auth_header = request.headers.get('authorization')
-        if not auth_header or not auth_header.lower().startswith('bearer '):
+        has_bearer_token_starting_with_sky = (
+            auth_header and auth_header.lower().startswith('bearer ') and
+            auth_header.split(' ', 1)[1].startswith('sky_'))
+
+        if (not has_skypilot_auth_header and
+                not has_bearer_token_starting_with_sky):
+            # This is case #3 above. We do not need to validate the request.
             # No Bearer token, continue with normal processing (OAuth2 cookies,
             # etc.)
             return await call_next(request)
+        # After this point, all requests must be validated.
+
+        if auth_header is None:
+            return fastapi.responses.JSONResponse(
+                status_code=401, content={'detail': 'Authentication required'})
 
         # Extract token
-        sa_token = auth_header.split(' ', 1)[1]
+        split_header = auth_header.split(' ', 1)
+        if split_header[0].lower() != 'bearer':
+            return fastapi.responses.JSONResponse(
+                status_code=401,
+                content={'detail': 'Invalid authentication method'})
+        sa_token = split_header[1]
 
         # Handle SkyPilot service account tokens
-        if sa_token.startswith('sky_'):
-            return await self._handle_service_account_token(
-                request, sa_token, call_next)
-
-        # Handle other Bearer tokens (OAuth2 access tokens, etc.)
-        # These requests bypassed OAuth2 proxy, so let the application decide
-        # how to handle them
-        # For now, we'll let them continue through normal processing
-        logger.debug(
-            'Non-SkyPilot Bearer token detected, continuing with normal '
-            'processing')
-        return await call_next(request)
+        return await self._handle_service_account_token(request, sa_token,
+                                                        call_next)
 
     async def _handle_service_account_token(self, request: fastapi.Request,
                                             sa_token: str, call_next):

sky/setup_files/dependencies.py

@@ -65,12 +65,14 @@ install_requires = [
     # Required for API server metrics
     'prometheus_client>=0.8.0',
     'passlib',
+    'pyjwt',
 ]
 
 server_dependencies = [
     'casbin',
     'sqlalchemy_adapter',
     'passlib',
+    'pyjwt',
 ]
 
 local_ray = [

sky/skylet/constants.py

@@ -481,6 +481,7 @@ MEMORY_SIZE_PATTERN = (
     ')?$')
 
 LAST_USE_TRUNC_LENGTH = 25
+USED_BY_TRUNC_LENGTH = 25
 
 MIN_PRIORITY = -1000
 MAX_PRIORITY = 1000

sky/task.py

@@ -884,6 +884,18 @@ class Task:
     def volumes(self) -> Dict[str, str]:
         return self._volumes
 
+    def set_volumes(self, volumes: Dict[str, str]) -> None:
+        """Sets the volumes for this task.
+
+        Args:
+          volumes: a dict of ``{mount_path: volume_name}``.
+        """
+        self._volumes = volumes
+
+    def update_volumes(self, volumes: Dict[str, str]) -> None:
+        """Updates the volumes for this task."""
+        self._volumes.update(volumes)
+
     def update_envs(
             self, envs: Union[None, List[Tuple[str, str]],
                               Dict[str, str]]) -> 'Task':
@@ -1500,7 +1512,7 @@ class Task:
                 d[k] = v
         return d
 
-    def to_yaml_config(self, redact_secrets: bool = True) -> Dict[str, Any]:
+    def to_yaml_config(self, redact_secrets: bool = False) -> Dict[str, Any]:
         """Returns a yaml-style dict representation of the task.
 
         INTERNAL: this method is internal-facing.

sky/utils/dag_utils.py

@@ -147,11 +147,13 @@ def load_chain_dag_from_yaml_str(
     return _load_chain_dag(configs, env_overrides, secrets_overrides)
 
 
-def dump_chain_dag_to_yaml_str(dag: dag_lib.Dag) -> str:
+def dump_chain_dag_to_yaml_str(dag: dag_lib.Dag,
+                               redact_secrets: bool = False) -> str:
     """Dumps a chain DAG to a YAML string.
 
     Args:
         dag: the DAG to dump.
+        redact_secrets: whether to redact secrets in the YAML string.
 
     Returns:
         The YAML string.
@@ -159,7 +161,7 @@ def dump_chain_dag_to_yaml_str(dag: dag_lib.Dag) -> str:
     assert dag.is_chain(), dag
     configs = [{'name': dag.name}]
     for task in dag.tasks:
-        configs.append(task.to_yaml_config())
+        configs.append(task.to_yaml_config(redact_secrets=redact_secrets))
     return common_utils.dump_yaml_str(configs)
 
 

sky/utils/log_utils.py

@@ -573,6 +573,74 @@ def readable_time_duration(start: Optional[float],
     return diff
 
 
+def human_duration(start: int, end: Optional[int] = None) -> str:
+    """Calculates the time elapsed between two timestamps and returns
+       it as a human-readable string, similar to Kubernetes' duration format.
+
+    Args:
+        start: The start time as a Unix timestamp (seconds since epoch).
+        end: The end time as a Unix timestamp (seconds since epoch).
+            If None, current time is used.
+
+    Returns:
+        A string representing the duration, e.g., "2d3h", "15m", "30s".
+        Returns "0s" for zero, negative durations, or if the timestamp
+        is invalid.
+    """
+    if not start or start <= 0:
+        return '0s'
+
+    if end is None:
+        end = int(time.time())
+    duration_seconds = end - start
+
+    units = {
+        'y': 365 * 24 * 60 * 60,
+        'd': 60 * 60 * 24,
+        'h': 60 * 60,
+        'm': 60,
+        's': 1,
+    }
+
+    if duration_seconds <= 0:
+        return '0s'
+    elif duration_seconds < 60 * 2:
+        return f'{duration_seconds}s'
+
+    minutes = int(duration_seconds / units['m'])
+    if minutes < 10:
+        s = int(duration_seconds / units['s']) % 60
+        if s == 0:
+            return f'{minutes}m'
+        return f'{minutes}m{s}s'
+    elif minutes < 60 * 3:
+        return f'{minutes}m'
+
+    hours = int(duration_seconds / units['h'])
+    days = int(hours / 24)
+    years = int(hours / 24 / 365)
+    if hours < 8:
+        m = int(duration_seconds / units['m']) % 60
+        if m == 0:
+            return f'{hours}h'
+        return f'{hours}h{m}m'
+    elif hours < 48:
+        return f'{hours}h'
+    elif hours < 24 * 8:
+        h = hours % 24
+        if h == 0:
+            return f'{days}d'
+        return f'{days}d{h}h'
+    elif hours < 24 * 365 * 2:
+        return f'{days}d'
+    elif hours < 24 * 365 * 8:
+        dy = int(hours / 24) % 365
+        if dy == 0:
+            return f'{years}y'
+        return f'{years}y{dy}d'
+    return f'{years}y'
+
+
 def follow_logs(
     file: TextIO,
     *,