[core worker] Submit Python actor tasks through core worker (#5750)

* Submit actor tasks through core worker

* Fix java

* add comment

* Remove task builder

* Check negative

* Increase -> Increment

* pass by reference

* fix signal

* Clean up c++ actor handle

* more cleanup

* Clean up headers

* Fix unique_ptr construction

* Fix java

* Move profiling to c++

* dedup

* fix error

* comments

* fix java

* Fix tests

* wait for actor to exit

* Start after constructor

* ignore java build

* fix comment

* always init logging

* Fix logging

* fix logging issue

* shared_ptr for profiler

* DEBUG -> WARNING

* fix killed_ init

* Fix flaky checkpointing tests

* -v flag for tune tests

* Fix checkpoint test logic

* Fix exception matching

* timeout exception

* Fix test exception info

* Fix import

* fix build

* Fix test

* shared_ptr

python/ray/includes/common.pxi

@@ -1,23 +1,72 @@
 from libcpp cimport bool as c_bool
 from libcpp.string cimport string as c_string
+from libcpp.vector cimport vector as c_vector
 
-from ray.includes.common cimport CGcsClientOptions
+from ray.includes.common cimport (
+    CActorHandle,
+    CGcsClientOptions,
+)
 
 
 cdef class GcsClientOptions:
     """Cython wrapper class of C++ `ray::gcs::GcsClientOptions`."""
     cdef:
-        unique_ptr[CGcsClientOptions] gcs_client_options
+        unique_ptr[CGcsClientOptions] inner
 
     def __init__(self, redis_ip, int redis_port,
                  redis_password, c_bool is_test_client=False):
         if not redis_password:
             redis_password = ""
-        self.gcs_client_options.reset(
+        self.inner.reset(
             new CGcsClientOptions(redis_ip.encode("ascii"),
                                   redis_port,
                                   redis_password.encode("ascii"),
                                   is_test_client))
 
     cdef CGcsClientOptions* native(self):
-        return <CGcsClientOptions*>(self.gcs_client_options.get())
+        return <CGcsClientOptions*>(self.inner.get())
+
+cdef class ActorHandle:
+    """Cython wrapper class of C++ `ray::ActorHandle`."""
+    cdef:
+        unique_ptr[CActorHandle] inner
+
+    def __init__(self, ActorID actor_id, ActorHandleID actor_handle_id,
+                 JobID job_id, list creation_function_descriptor):
+        cdef:
+            c_vector[c_string] c_descriptor
+            ObjectID cursor = ObjectID.from_random()
+
+        c_descriptor = string_vector_from_list(creation_function_descriptor)
+        self.inner.reset(new CActorHandle(
+            actor_id.native(), actor_handle_id.native(), job_id.native(),
+            cursor.native(), LANGUAGE_PYTHON, False, c_descriptor))
+
+    def fork(self, c_bool ray_forking):
+        cdef:
+            ActorHandle other = ActorHandle.__new__(ActorHandle)
+        if ray_forking:
+            other.inner = self.inner.get().Fork()
+        else:
+            other.inner = self.inner.get().ForkForSerialization()
+        return other
+
+    @staticmethod
+    def from_bytes(c_string bytes, TaskID current_task_id):
+        cdef:
+            ActorHandle self = ActorHandle.__new__(ActorHandle)
+        self.inner.reset(new CActorHandle(bytes, current_task_id.native()))
+        return self
+
+    def to_bytes(self):
+        cdef:
+            c_string output
+
+        self.inner.get().Serialize(&output)
+        return output
+
+    def actor_id(self):
+        return ActorID(self.inner.get().GetActorID().Binary())
+
+    def actor_handle_id(self):
+        return ActorHandleID(self.inner.get().GetActorHandleID().Binary())