hunk.code_window: RAY_CONFIG(int64_t, handler_warning_timeout_ms, 1000)
   /// The duration between heartbeats sent by the raylets.
   RAY_CONFIG(uint64_t, raylet_heartbeat_period_milliseconds, 100)
   /// If a component has not sent a heartbeat in the last num_heartbeats_timeout
   /// heartbeat intervals, the raylet monitor process will report
   /// it as dead to the db_client table.
  
hunk.labels: keep keep keep replace keep keep keep
hunk.after_edit: RAY_CONFIG(uint64_t, raylet_heartbeat_period_milliseconds, 1000)
  
hunk.file_path: src/ray/common/ray_config_def.h
hunk.type: replace
file: # A unique identifier for the head node and workers of this cluster.
  cluster_name: defaults
  
  # The maximum number of workers nodes to launch in addition to the head
  # node.
  max_workers: 2
  
  # The autoscaler will scale up the cluster faster with higher upscaling speed.
  # E.g., if the task requires adding more nodes then autoscaler will gradually
  # scale up the cluster in chunks of upscaling_speed*currently_running_nodes.
  # This number should be > 0.
  upscaling_speed: 1.0
  
  # If a node is idle for this many minutes, it will be removed.
  idle_timeout_minutes: 5
  
  # Kubernetes resources that need to be configured for the autoscaler to be
  # able to manage the Ray cluster. If any of the provided resources don't
  # exist, the autoscaler will attempt to create them. If this fails, you may
  # not have the required permissions and will have to request them to be
  # created by your cluster administrator.
  provider:
      type: kubernetes
  
      # Exposing external IP addresses for ray pods isn't currently supported.
      use_internal_ips: true
  
      # Namespace to use for all resources created.
      namespace: ray
  
      # ServiceAccount created by the autoscaler for the head node pod that it
      # runs in. If this field isn't provided, the head pod config below must
      # contain a user-created service account with the proper permissions.
      autoscaler_service_account:
          apiVersion: v1
          kind: ServiceAccount
          metadata:
              name: autoscaler
  
      # Role created by the autoscaler for the head node pod that it runs in.
      # If this field isn't provided, the role referenced in
      # autoscaler_role_binding must exist and have at least these permissions.
      autoscaler_role:
          kind: Role
          apiVersion: rbac.authorization.k8s.io/v1
          metadata:
              name: autoscaler
          rules:
          - apiGroups: [""]
            resources: ["pods", "pods/status", "pods/exec"]
            verbs: ["get", "watch", "list", "create", "delete", "patch"]
  
      # RoleBinding created by the autoscaler for the head node pod that it runs
      # in. If this field isn't provided, the head pod config below must contain
      # a user-created service account with the proper permissions.
      autoscaler_role_binding:
          apiVersion: rbac.authorization.k8s.io/v1
          kind: RoleBinding
          metadata:
              name: autoscaler
          subjects:
          - kind: ServiceAccount
            name: autoscaler
          roleRef:
              kind: Role
              name: autoscaler
              apiGroup: rbac.authorization.k8s.io
  
      services:
        # Service that maps to the head node of the Ray cluster.
        - apiVersion: v1
          kind: Service
          metadata:
              # NOTE: If you're running multiple Ray clusters with services
              # on one Kubernetes cluster, they must have unique service
              # names.
              name: example-cluster-ray-head
          spec:
              # This selector must match the head node pod's selector below.
              selector:
                  component: example-cluster-ray-head
              ports:
                  - name: client
                    protocol: TCP
                    port: 10001
                    targetPort: 10001
                  - name: dashboard
                    protocol: TCP
                    port: 8265
                    targetPort: 8265
                  - name: ray-serve
                    protocol: TCP
                    port: 8000
                    targetPort: 8000
  
  # Specify the pod type for the ray head node (as configured below).
  head_node_type: head_node
  # Specify the allowed pod types for this ray cluster and the resources they provide.
  available_node_types:
    worker_node:
      # Minimum number of Ray workers of this Pod type.
      min_workers: 0
      node_config:
        apiVersion: v1
        kind: Pod
        metadata:
          # Automatically generates a name for the pod with this prefix.
          generateName: example-cluster-ray-worker-
        spec:
          restartPolicy: Never
          volumes:
          - name: dshm
            emptyDir:
              medium: Memory
          containers:
          - name: ray-node
            imagePullPolicy: Always
            image: rayproject/ray:nightly
            command: ["/bin/bash", "-c", "--"]
            args: ["trap : TERM INT; sleep infinity & wait;"]
            # This volume allocates shared memory for Ray to use for its plasma
            # object store. If you do not provide this, Ray will fall back to
            # /tmp which cause slowdowns if is not a shared memory volume.
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
            resources:
              requests:
                cpu: 1000m
                memory: 512Mi
              limits:
                # The maximum memory that this pod is allowed to use. The
                # limit will be detected by ray and split to use 10% for
                # redis, 30% for the shared memory object store, and the
                # rest for application memory. If this limit is not set and
                # the object store size is not set manually, ray will
                # allocate a very large object store in each pod that may
                # cause problems for other pods.
                memory: 512Mi
    head_node:
      # The minimum number of worker nodes of this type to launch.
      # This number should be >= 0.
      min_workers: 0
      # The maximum number of worker nodes of this type to launch.
      # This takes precedence over min_workers.
      max_workers: 0
      node_config:
        apiVersion: v1
        kind: Pod
        metadata:
          # Automatically generates a name for the pod with this prefix.
          generateName: example-cluster-ray-head-
          # Must match the head node service selector above if a head node
          # service is required.
          labels:
              component: example-cluster-ray-head
        spec:
          # Change this if you altered the autoscaler_service_account above
          # or want to provide your own.
          serviceAccountName: autoscaler
  
          restartPolicy: Never
  
          # This volume allocates shared memory for Ray to use for its plasma
          # object store. If you do not provide this, Ray will fall back to
          # /tmp which cause slowdowns if is not a shared memory volume.
          volumes:
          - name: dshm
            emptyDir:
              medium: Memory
          containers:
          - name: ray-node
            imagePullPolicy: Always
            image: rayproject/ray:nightly
            # Do not change this command - it keeps the pod alive until it is
            # explicitly killed.
            command: ["/bin/bash", "-c", "--"]
            args: ['trap : TERM INT; sleep infinity & wait;']
            ports:
            - containerPort: 6379  # Redis port
            - containerPort: 10001  # Used by Ray Client
            - containerPort: 8265  # Used by Ray Dashboard
  
            # This volume allocates shared memory for Ray to use for its plasma
            # object store. If you do not provide this, Ray will fall back to
            # /tmp which cause slowdowns if is not a shared memory volume.
            volumeMounts:
            - mountPath: /dev/shm
              name: dshm
            resources:
              requests:
                cpu: 1000m
                memory: 512Mi
              limits:
                # The maximum memory that this pod is allowed to use. The
                # limit will be detected by ray and split to use 10% for
                # redis, 30% for the shared memory object store, and the
                # rest for application memory. If this limit is not set and
                # the object store size is not set manually, ray will
                # allocate a very large object store in each pod that may
                # cause problems for other pods.
                memory: 512Mi
  
  
  # Command to start ray on the head node. You don't need to change this.
  # Note dashboard-host is set to 0.0.0.0 so that kubernetes can port forward.
  head_start_ray_commands:
      - ray stop
      - ulimit -n 65536; ray start --head --autoscaling-config=~/ray_bootstrap_config.yaml --dashboard-host 0.0.0.0
  
  # Command to start ray on worker nodes. You don't need to change this.
  worker_start_ray_commands:
      - ray stop
      - ulimit -n 65536; ray start --address=$RAY_HEAD_IP:6379
  
  # Files or directories to copy to the head and worker nodes. The format is a
  # dictionary from REMOTE_PATH: LOCAL_PATH, e.g.
  file_mounts: {
  #    "~/path1/on/remote/machine": "/path1/on/local/machine",
  #    "~/path2/on/remote/machine": "/path2/on/local/machine",
  }
  # Note that the container images in this example have a non-root user.
  # To avoid permissions issues, we recommend mounting into a subdirectory of home (~).
  
  # Files or directories to copy from the head node to the worker nodes. The format is a
  # list of paths. The same path on the head node will be copied to the worker node.
  # This behavior is a subset of the file_mounts behavior. In the vast majority of cases
  # you should just use file_mounts. Only use this if you know what you're doing!
  cluster_synced_files: []
  
  # Whether changes to directories in file_mounts or cluster_synced_files in the head node
  # should sync to the worker node continuously
  file_mounts_sync_continuously: False
  
  
  # List of commands that will be run before `setup_commands`. If docker is
  # enabled, these commands will run outside the container and before docker
  # is setup.
  initialization_commands: []
  
  # List of shell commands to run to set up nodes.
  setup_commands: []
  
  # Custom commands that will be run on the head node after common setup.
  head_setup_commands: []
  
  # Custom commands that will be run on worker nodes after common setup.
  worker_setup_commands: []
  
  head_node: {}
  
  worker_nodes: {}
  