class_docstr: Shared interface of all model server runners.
  
  Model server runner is responsible for managing the model server job and
  relevant resources in the serving platform. For example, model server runner
  for kubernetes will launch a Pod of model server with required resources
  allocated, and tear down all the kubernetes resources once infra validation
  is done. Note that model server runner does *not* interact with model server
  app.
  
  Model server job have 5 states: Initial, Scheduled, Running, Aborted, and End.
  Each state transition is depicted in the diagram below.
  
  ```
             +-----------+
             |  Initial  |
             +-----+-----+
                   | Start()
             +-----v-----+
          +--+ Scheduled |
          |  +-----+-----+
          |        | WaitUntilRunning()
          |  +-----v-----+
          +--+  Running  |
          |  +-----+-----+
          |        |
    +-----v-----+  |
    |  Aborted  +--+ Stop()
    +-----------+  |
                   |
             +-----v-----+
             |    End    |
             +-----------+
  ```
  
  At any step, the job can be aborted in the serving platform. Model server
  runner will NOT recover a job from failure (even if it can) and regard the
  abortion as a validation failure.
  
  All the infra validation logic (waiting for model loaded, sending requests,
  measuring metrics, etc.) will happen when model server job has reached Running
  state. This is not a scope of model server runner work.
  
  Depending on the serving platform, some of the states might be the same. For
  example, in a GCP cloud AI prediction service we have a global model server
  instance running, which makes Scheduled state and Running state
  indistinguishable. In such case, `WaitUntilRunning()` action will be a no-op.
docstr: Wait until model server job is running.
  
  When this method is returned without error, the model server job is in the
  Running state where you can perform all the infra validation logic. It does
  not guarantee that model server job would remain in the Running state
  forever, (e.g. preemption could happen in some serving platform) and any
  kind of infra validation logic failure can be caused from model server job
  not being in the Running state. Still, it is a validation failure and we
  blame model for this.
  
  Args:
    deadline: A deadline time in UTC timestamp (in seconds).
  Returns:
    Whether the model is available or not.
code: def WaitUntilRunning(self, deadline: float) -> None:
      """Wait until model server job is running.
  
      When this method is returned without error, the model server job is in the
      Running state where you can perform all the infra validation logic. It does
      not guarantee that model server job would remain in the Running state
      forever, (e.g. preemption could happen in some serving platform) and any
      kind of infra validation logic failure can be caused from model server job
      not being in the Running state. Still, it is a validation failure and we
      blame model for this.
  
      Args:
        deadline: A deadline time in UTC timestamp (in seconds).
      Returns:
        Whether the model is available or not.
      """
  
file_path: tfx/tfx/components/infra_validator/model_server_runners/base_runner.py
imports: import abc
  from typing import Optional
label_desc: Use image node_id 4 for calling the BaseModelServerRunner obj's underlying member method code with example usage: obj.WaitUntilRunning(deadline) without return types