code: def test_was_current_actor_reconstructed(shutdown_only):
      ray.init()
  
      @ray.remote(max_restarts=10)
      class A(object):
          def __init__(self):
              self._was_reconstructed = (
                  ray.get_runtime_context().was_current_actor_reconstructed
              )
  
          def get_was_reconstructed(self):
              return self._was_reconstructed
  
          def update_was_reconstructed(self):
              return (
                  ray.get_runtime_context().was_current_actor_reconstructed
              )
  
          def get_pid(self):
              return os.getpid()
  
      a = A.remote()
      # `was_reconstructed` should be False when it's called in actor.
      assert ray.get(a.get_was_reconstructed.remote()) is False
      # `was_reconstructed` should be False when it's called in a remote method
      # and the actor never fails.
      assert ray.get(a.update_was_reconstructed.remote()) is False
  
      pid = ray.get(a.get_pid.remote())
      os.kill(pid, signal.SIGKILL)
      time.sleep(2)
      # These 2 methods should be return True because
      # this actor failed and restored.
      assert ray.get(a.get_was_reconstructed.remote()) is True
      assert ray.get(a.update_was_reconstructed.remote()) is True
  
      @ray.remote(max_restarts=10)
      class A(object):
          def current_job_id(self):
              return ray.get_runtime_context().job_id
  
          def current_actor_id(self):
              return ray.get_runtime_context().actor_id
  
      @ray.remote
      def f():
          assert ray.get_runtime_context().actor_id is None
          assert ray.get_runtime_context().task_id is not None
          assert ray.get_runtime_context().node_id is not None
          assert ray.get_runtime_context().job_id is not None
          context = ray.get_runtime_context().get()
          assert "actor_id" not in context
          assert context["task_id"] == ray.get_runtime_context().task_id
          assert context["node_id"] == ray.get_runtime_context().node_id
          assert context["job_id"] == ray.get_runtime_context().job_id
  
      a = A.remote()
      assert ray.get(a.current_job_id.remote()) is not None
      assert ray.get(a.current_actor_id.remote()) is not None
      ray.get(f.remote())
  
imports: import ray
  import os
  import signal
  import time
  import sys
  import pytest
  import warnings
  from ray._private.test_utils import SignalActor
  from ray.util.scheduling_strategies import PlacementGroupSchedulingStrategy
  from ray.util.state import list_tasks
  from ray._private.test_utils import wait_for_condition
label_desc: Use image node_id 1 for calling a global function with example usage: test_was_current_actor_reconstructed(shutdown_only) and returns: self, ray, os, ray, ray