indexify 0.2.44__py3-none-any.whl → 0.2.45__py3-none-any.whl

indexify/executor/task_reporter.py

@@ -10,7 +10,7 @@ from indexify.function_executor.proto.function_executor_pb2 import (
     FunctionOutput,
 )
 
-from .function_worker import FunctionWorkerOutput
+from .task_runner import TaskOutput
 
 
 # https://github.com/psf/requests/issues/1081#issuecomment-428504128
@@ -48,17 +48,10 @@ class TaskReporter:
         # results in not reusing established TCP connections to server.
         self._client = get_httpx_client(config_path, make_async=False)
 
-    async def report(
-        self, task: Task, output: Optional[FunctionWorkerOutput], logger: Any
-    ):
-        """Reports result of the supplied task.
-
-        If FunctionWorkerOutput is None this means that the task didn't finish and failed with internal error.
-        """
+    async def report(self, output: TaskOutput, logger: Any):
+        """Reports result of the supplied task."""
         logger = logger.bind(module=__name__)
-        task_result, output_files, output_summary = self._process_task_output(
-            task, output
-        )
+        task_result, output_files, output_summary = self._process_task_output(output)
         task_result_data = task_result.model_dump_json(exclude_none=True)
 
         logger.info(
@@ -100,16 +93,16 @@ class TaskReporter:
             ) from e
 
     def _process_task_output(
-        self, task: Task, output: Optional[FunctionWorkerOutput]
+        self, output: TaskOutput
     ) -> Tuple[TaskResult, List[Any], TaskOutputSummary]:
         task_result = TaskResult(
             outcome="failure",
-            namespace=task.namespace,
-            compute_graph=task.compute_graph,
-            compute_fn=task.compute_fn,
-            invocation_id=task.invocation_id,
+            namespace=output.task.namespace,
+            compute_graph=output.task.compute_graph,
+            compute_fn=output.task.compute_fn,
+            invocation_id=output.task.invocation_id,
             executor_id=self._executor_id,
-            task_id=task.id,
+            task_id=output.task.id,
         )
         output_files: List[Any] = []
         summary: TaskOutputSummary = TaskOutputSummary()

indexify/executor/task_runner.py

@@ -0,0 +1,104 @@
+from typing import Any, Dict, Optional
+
+from .api_objects import Task
+from .function_executor.function_executor_state import FunctionExecutorState
+from .function_executor.server.function_executor_server_factory import (
+    FunctionExecutorServerFactory,
+)
+from .function_executor.single_task_runner import SingleTaskRunner
+from .function_executor.task_input import TaskInput
+from .function_executor.task_output import TaskOutput
+
+
+class TaskRunner:
+    """Routes a task to its container following a scheduling policy.
+
+    Due to the scheduling policy a task might be blocked for a while."""
+
+    def __init__(
+        self,
+        function_executor_server_factory: FunctionExecutorServerFactory,
+        base_url: str,
+        config_path: Optional[str],
+    ):
+        self._factory: FunctionExecutorServerFactory = function_executor_server_factory
+        self._base_url: str = base_url
+        self._config_path: Optional[str] = config_path
+        # We don't lock this map cause we never await while reading and modifying it.
+        self._function_executor_states: Dict[str, FunctionExecutorState] = {}
+
+    async def run(self, task_input: TaskInput, logger: Any) -> TaskOutput:
+        logger = logger.bind(module=__name__)
+        try:
+            return await self._run(task_input, logger)
+        except Exception as e:
+            logger.error(
+                "failed running the task",
+                exc_info=e,
+            )
+            return TaskOutput.internal_error(task_input.task)
+
+    async def _run(self, task_input: TaskInput, logger: Any) -> TaskOutput:
+        state = self._get_or_create_state(task_input.task)
+        async with state.lock:
+            await self._run_task_policy(state, task_input.task)
+            return await self._run_task(state, task_input, logger)
+
+    async def _run_task_policy(self, state: FunctionExecutorState, task: Task) -> None:
+        # Current policy for running tasks:
+        #   - There can only be a single Function Executor per function regardless of function versions.
+        #   --  If a Function Executor already exists for a different function version then wait until
+        #       all the tasks finish in the existing Function Executor and then destroy it.
+        #   --  This prevents failed tasks for different versions of the same function continiously
+        #       destroying each other's Function Executors.
+        #   - Each Function Executor rans at most 1 task concurrently.
+        await state.wait_running_tasks_less(1)
+
+        if state.function_id_with_version != _function_id_with_version(task):
+            await state.destroy_function_executor()
+            state.function_id_with_version = _function_id_with_version(task)
+            # At this point the state belongs to the version of the function from the task
+            # and there are no running tasks in the Function Executor.
+
+    def _get_or_create_state(self, task: Task) -> FunctionExecutorState:
+        id = _function_id_without_version(task)
+        if id not in self._function_executor_states:
+            state = FunctionExecutorState(
+                function_id_with_version=_function_id_with_version(task),
+                function_id_without_version=id,
+            )
+            self._function_executor_states[id] = state
+        return self._function_executor_states[id]
+
+    async def _run_task(
+        self, state: FunctionExecutorState, task_input: TaskInput, logger: Any
+    ) -> TaskOutput:
+        runner: SingleTaskRunner = SingleTaskRunner(
+            function_executor_state=state,
+            task_input=task_input,
+            function_executor_server_factory=self._factory,
+            base_url=self._base_url,
+            config_path=self._config_path,
+            logger=logger,
+        )
+        return await runner.run()
+
+    async def shutdown(self) -> None:
+        # When shutting down there's no need to wait for completion of the running
+        # FunctionExecutor tasks.
+        while self._function_executor_states:
+            id, state = self._function_executor_states.popitem()
+            # At this point the state is not visible to new tasks.
+            # Only ongoing tasks who read it already have a reference to it.
+            await state.destroy_function_executor_not_locked()
+            # The task running inside the Function Executor will fail because it's destroyed.
+            # asyncio tasks waiting to run inside the Function Executor will get cancelled by
+            # the caller's shutdown code.
+
+
+def _function_id_with_version(task: Task) -> str:
+    return f"versioned/{task.namespace}/{task.compute_graph}/{task.graph_version}/{task.compute_fn}"
+
+
+def _function_id_without_version(task: Task) -> str:
+    return f"not_versioned/{task.namespace}/{task.compute_graph}/{task.compute_fn}"

indexify/function_executor/function_executor_service.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union
+from typing import Iterator, Optional, Union
 
 import grpc
 import structlog
@@ -14,9 +14,14 @@ from .handlers.run_function.request_validator import (
     RequestValidator as RunTaskRequestValidator,
 )
 from .initialize_request_validator import InitializeRequestValidator
+from .invocation_state.invocation_state_proxy_server import (
+    InvocationStateProxyServer,
+)
+from .invocation_state.proxied_invocation_state import ProxiedInvocationState
 from .proto.function_executor_pb2 import (
     InitializeRequest,
     InitializeResponse,
+    InvocationStateResponse,
     RunTaskRequest,
     RunTaskResponse,
 )
@@ -24,15 +29,14 @@ from .proto.function_executor_pb2_grpc import FunctionExecutorServicer
 
 
 class FunctionExecutorService(FunctionExecutorServicer):
-    def __init__(self, indexify_server_address: str, config_path: Optional[str]):
-        self._indexify_server_address = indexify_server_address
-        self._config_path = config_path
+    def __init__(self):
         self._logger = structlog.get_logger(module=__name__)
         self._namespace: Optional[str] = None
         self._graph_name: Optional[str] = None
         self._graph_version: Optional[int] = None
         self._function_name: Optional[str] = None
         self._function: Optional[Union[IndexifyFunction, IndexifyRouter]] = None
+        self._invocation_state_proxy_server: Optional[InvocationStateProxyServer] = None
 
     def initialize(
         self, request: InitializeRequest, context: grpc.ServicerContext
@@ -65,6 +69,17 @@ class FunctionExecutorService(FunctionExecutorServicer):
 
         return InitializeResponse(success=True)
 
+    def initialize_invocation_state_server(
+        self,
+        client_responses: Iterator[InvocationStateResponse],
+        context: grpc.ServicerContext,
+    ):
+        self._invocation_state_proxy_server = InvocationStateProxyServer(
+            client_responses, self._logger
+        )
+        self._logger.info("initialized invocation proxy server")
+        yield from self._invocation_state_proxy_server.run()
+
     def run_task(
         self, request: RunTaskRequest, context: grpc.ServicerContext
     ) -> RunTaskResponse:
@@ -75,12 +90,12 @@ class FunctionExecutorService(FunctionExecutorServicer):
         RunTaskRequestValidator(request=request).check()
         return RunTaskHandler(
             request=request,
-            namespace=self._namespace,
             graph_name=self._graph_name,
             graph_version=self._graph_version,
             function_name=self._function_name,
             function=self._function,
+            invocation_state=ProxiedInvocationState(
+                request.task_id, self._invocation_state_proxy_server
+            ),
             logger=self._logger,
-            indexify_server_addr=self._indexify_server_address,
-            config_path=self._config_path,
         ).run()

indexify/function_executor/handlers/run_function/handler.py

@@ -16,6 +16,9 @@ from indexify.functions_sdk.indexify_functions import (
     IndexifyRouter,
     RouterCallResult,
 )
+from indexify.functions_sdk.invocation_state.invocation_state import (
+    InvocationState,
+)
 from indexify.http_client import IndexifyClient
 
 from .function_inputs_loader import FunctionInputs, FunctionInputsLoader
@@ -26,14 +29,12 @@ class Handler:
     def __init__(
         self,
         request: RunTaskRequest,
-        namespace: str,
         graph_name: str,
         graph_version: int,
         function_name: str,
         function: Union[IndexifyFunction, IndexifyRouter],
+        invocation_state: InvocationState,
         logger: Any,
-        indexify_server_addr: str,
-        config_path: Optional[str],
     ):
         self._function_name: str = function_name
         self._logger = logger.bind(
@@ -53,12 +54,7 @@ class Handler:
                 invocation_id=request.graph_invocation_id,
                 graph_name=graph_name,
                 graph_version=str(graph_version),
-                indexify_client=_indexify_client(
-                    logger=self._logger,
-                    namespace=namespace,
-                    indexify_server_addr=indexify_server_addr,
-                    config_path=config_path,
-                ),
+                invocation_state=invocation_state,
             ),
         )
 
@@ -139,9 +135,14 @@ def _indexify_client(
 
 
 def _is_router(func_wrapper: IndexifyFunctionWrapper) -> bool:
-    return (
-        str(type(func_wrapper.indexify_function))
-        == "<class 'indexify.functions_sdk.indexify_functions.IndexifyRouter'>"
+    """Determines if the function is a router.
+
+    A function is a router if it is an instance of IndexifyRouter or if it is an IndexifyRouter class.
+    """
+    return str(
+        type(func_wrapper.indexify_function)
+    ) == "<class 'indexify.functions_sdk.indexify_functions.IndexifyRouter'>" or isinstance(
+        func_wrapper.indexify_function, IndexifyRouter
     )
 
 

indexify/function_executor/invocation_state/invocation_state_proxy_server.py

@@ -0,0 +1,170 @@
+import queue
+import threading
+from typing import Any, Iterator, Optional
+
+from indexify.functions_sdk.object_serializer import (
+    CloudPickleSerializer,
+    get_serializer,
+)
+
+from ..proto.function_executor_pb2 import (
+    GetInvocationStateRequest,
+    InvocationStateRequest,
+    InvocationStateResponse,
+    SerializedObject,
+    SetInvocationStateRequest,
+)
+from .response_validator import ResponseValidator
+
+
+class InvocationStateProxyServer:
+    """A gRPC server that proxies InvocationState calls to the gRPC client.
+
+    The gRPC client is responsible for the actual implementation of the InvocationState.
+    We do the proxying to remove authorization logic and credentials from Function Executor.
+    This improves security posture of Function Executor because it may run untrusted code.
+    """
+
+    def __init__(
+        self, client_responses: Iterator[InvocationStateResponse], logger: Any
+    ):
+        self._client_responses: Iterator[InvocationStateResponse] = client_responses
+        self._logger: Any = logger.bind(module=__name__)
+        self._reciever_thread: threading.Thread = threading.Thread(
+            target=self._reciever
+        )
+        self._request_queue: queue.SimpleQueue = queue.SimpleQueue()
+        # This lock protects everything below.
+        self._lock: threading.Lock = threading.Lock()
+        # Python supports big integers natively so we don't need
+        # to be worried about interger overflows.
+        self._request_seq_num: int = 0
+        # Request ID -> Client Response.
+        self._response_map: dict[str, InvocationStateResponse] = {}
+        self._new_response: threading.Condition = threading.Condition(self._lock)
+
+    def run(self) -> Iterator[InvocationStateRequest]:
+        # There's no need to implement shutdown of the server and its threads because
+        # the server lives while the Function Executor process lives.
+        self._reciever_thread.start()
+        yield from self._sender()
+
+    def _reciever(self) -> None:
+        self._logger.info("reciever thread started")
+        try:
+            for response in self._client_responses:
+                validator = ResponseValidator(response)
+                try:
+                    validator.check()
+                except ValueError as e:
+                    self._logger.error("invalid response from the client", exc_info=e)
+                    continue
+
+                with self._lock:
+                    self._response_map[response.request_id] = response
+                    self._new_response.notify_all()
+        except Exception as e:
+            self._logger.error("error in reciever thread, exiting", exc_info=e)
+
+    def _sender(self) -> Iterator[InvocationStateRequest]:
+        while True:
+            yield self._request_queue.get()
+            with self._lock:
+                # Wait until we get a response for the request.
+                # This allows to ensure a serialized order of reads and writes so
+                # we can avoid a read returning not previously written value.
+                self._new_response.wait()
+
+    def set(self, task_id: str, key: str, value: Any) -> None:
+        with self._lock:
+            request_id: str = str(self._request_seq_num)
+            self._request_seq_num += 1
+
+            # We currently use CloudPickleSerializer for function inputs,
+            # outputs and invocation state values. This provides consistent UX.
+            request = InvocationStateRequest(
+                request_id=request_id,
+                task_id=task_id,
+                set=SetInvocationStateRequest(
+                    key=key,
+                    value=SerializedObject(
+                        content_type=CloudPickleSerializer.content_type,
+                        bytes=CloudPickleSerializer.serialize(value),
+                    ),
+                ),
+            )
+            self._request_queue.put(request)
+            while request_id not in self._response_map:
+                self._new_response.wait()
+
+            response: InvocationStateResponse = self._response_map.pop(request_id)
+            if response.request_id != request_id:
+                self._logger.error(
+                    "response request_id doesn't match actual request_id",
+                    request_id=request_id,
+                    response=response,
+                )
+                raise RuntimeError(
+                    "response request_id doesn't match actual request_id"
+                )
+            if not response.HasField("set"):
+                self._logger.error(
+                    "set response is missing in the client response",
+                    request_id=request_id,
+                    response=response,
+                )
+                raise RuntimeError("set response is missing in the client response")
+            if not response.success:
+                self._logger.error(
+                    "failed to set the invocation state for key",
+                    key=key,
+                )
+                raise RuntimeError("failed to set the invocation state for key")
+
+    def get(self, task_id: str, key: str) -> Optional[Any]:
+        with self._lock:
+            request_id: str = str(self._request_seq_num)
+            self._request_seq_num += 1
+
+            request = InvocationStateRequest(
+                request_id=request_id,
+                task_id=task_id,
+                get=GetInvocationStateRequest(
+                    key=key,
+                ),
+            )
+            self._request_queue.put(request)
+            while request_id not in self._response_map:
+                self._new_response.wait()
+
+            response: InvocationStateResponse = self._response_map.pop(request_id)
+            if response.request_id != request_id:
+                self._logger.error(
+                    "response request_id doesn't match actual request_id",
+                    request_id=request_id,
+                    response=response,
+                )
+                raise RuntimeError(
+                    "response request_id doesn't match actual request_id"
+                )
+            if not response.HasField("get"):
+                self._logger.error(
+                    "get response is missing in the client response",
+                    request_id=request_id,
+                    response=response,
+                )
+                raise RuntimeError("get response is missing in the client response")
+            if not response.success:
+                self._logger.error(
+                    "failed to get the invocation state for key",
+                    key=key,
+                )
+                raise RuntimeError("failed to get the invocation state for key")
+            if not response.get.HasField("value"):
+                return None
+
+            return get_serializer(response.get.value.content_type).deserialize(
+                response.get.value.bytes
+                if response.get.value.HasField("bytes")
+                else response.get.value.string
+            )

indexify/function_executor/invocation_state/proxied_invocation_state.py

@@ -0,0 +1,24 @@
+from typing import Any, Optional
+
+from indexify.functions_sdk.invocation_state.invocation_state import (
+    InvocationState,
+)
+
+from .invocation_state_proxy_server import InvocationStateProxyServer
+
+
+class ProxiedInvocationState(InvocationState):
+    """InvocationState that proxies the calls via InvocationStateProxyServer."""
+
+    def __init__(self, task_id: str, proxy_server: InvocationStateProxyServer):
+        self._task_id: str = task_id
+        self._proxy_server: InvocationStateProxyServer = proxy_server
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a key-value pair."""
+        self._proxy_server.set(self._task_id, key, value)
+
+    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+        """Get a value by key. If the key does not exist, return the default value."""
+        value: Optional[Any] = self._proxy_server.get(self._task_id, key)
+        return default if value is None else value

indexify/function_executor/invocation_state/response_validator.py

@@ -0,0 +1,29 @@
+from ..proto.function_executor_pb2 import InvocationStateResponse
+from ..proto.message_validator import MessageValidator
+
+
+class ResponseValidator(MessageValidator):
+    def __init__(self, response: InvocationStateResponse):
+        self._response = response
+
+    def check(self):
+        """Validates the request.
+
+        Raises: ValueError: If the response is invalid.
+        """
+        (
+            MessageValidator(self._response)
+            .required_field("request_id")
+            .required_field("success")
+        )
+
+        if self._response.HasField("set"):
+            pass
+        elif self._response.HasField("get"):
+            (
+                MessageValidator(self._response.get)
+                .required_field("key")
+                .optional_serialized_object("value")
+            )
+        else:
+            raise ValueError(f"Unknown response type: {self._response}")

indexify/function_executor/proto/function_executor.proto

@@ -33,6 +33,49 @@ message InitializeResponse {
     optional bool success = 1;
 }
 
+message SetInvocationStateRequest {
+    optional string key = 1;
+    optional SerializedObject value = 2;
+}
+
+message SetInvocationStateResponse {}
+
+message GetInvocationStateRequest {
+    optional string key = 1;
+}
+
+message GetInvocationStateResponse {
+    optional string key = 1;
+    optional SerializedObject value = 2;
+}
+
+// InvocationStateRequest is sent by RPC Server to the client
+// to perform actions on a task's graph invocation state.
+message InvocationStateRequest {
+    // The ID of the request sent by the client.
+    // Must be unique per Function Executor.
+    optional string request_id = 1;
+    // The ID of the task initiated the request.
+    optional string task_id = 2;
+    oneof request {
+        SetInvocationStateRequest set = 3;
+        GetInvocationStateRequest get = 4;
+    }
+}
+
+// InvocationStateResponse is sent by RPC client to the Server.
+// A response contains the result of the action performed on the
+// task's graph invocation state.
+message InvocationStateResponse {
+    // The id of the request this response is for.
+    optional string request_id = 1;
+    optional bool success = 2;
+    oneof response {
+        SetInvocationStateResponse set = 3;
+        GetInvocationStateResponse get = 4;
+    }
+}
+
 message FunctionOutput {
     repeated SerializedObject outputs = 1;
 }
@@ -64,6 +107,10 @@ service FunctionExecutor {
     // once per Function Executor as it can only run a single function.
     // It should be called before calling RunTask for the function.
     rpc initialize(InitializeRequest) returns (InitializeResponse);
+    // Initializes a server that sends requests to the client to perform actions on
+    // a task's graph invocation state. This method is called only once per Function Executor
+    // It should be called before calling RunTask for the function.
+    rpc initialize_invocation_state_server(stream InvocationStateResponse) returns (stream InvocationStateRequest);
     // Executes the task defined in the request.
     // Multiple tasks can be running in parallel.
     rpc run_task(RunTaskRequest) returns (RunTaskResponse);

indexify/function_executor/proto/function_executor_pb2.py

@@ -24,7 +24,7 @@ _sym_db = _symbol_database.Default()
 
 
 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
-    b'\n8indexify/function_executor/proto/function_executor.proto\x12\x19\x66unction_executor_service"i\n\x10SerializedObject\x12\x0f\n\x05\x62ytes\x18\x01 \x01(\x0cH\x00\x12\x10\n\x06string\x18\x02 \x01(\tH\x00\x12\x19\n\x0c\x63ontent_type\x18\x03 \x01(\tH\x01\x88\x01\x01\x42\x06\n\x04\x64\x61taB\x0f\n\r_content_type"\x88\x02\n\x11InitializeRequest\x12\x16\n\tnamespace\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\x17\n\ngraph_name\x18\x02 \x01(\tH\x01\x88\x01\x01\x12\x1a\n\rgraph_version\x18\x03 \x01(\x05H\x02\x88\x01\x01\x12\x1a\n\rfunction_name\x18\x05 \x01(\tH\x03\x88\x01\x01\x12?\n\x05graph\x18\x07 \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x04\x88\x01\x01\x42\x0c\n\n_namespaceB\r\n\x0b_graph_nameB\x10\n\x0e_graph_versionB\x10\n\x0e_function_nameB\x08\n\x06_graph"6\n\x12InitializeResponse\x12\x14\n\x07success\x18\x01 \x01(\x08H\x00\x88\x01\x01\x42\n\n\x08_success"N\n\x0e\x46unctionOutput\x12<\n\x07outputs\x18\x01 \x03(\x0b\x32+.function_executor_service.SerializedObject"\x1d\n\x0cRouterOutput\x12\r\n\x05\x65\x64ges\x18\x01 \x03(\t"\xb0\x02\n\x0eRunTaskRequest\x12 \n\x13graph_invocation_id\x18\x04 \x01(\tH\x00\x88\x01\x01\x12\x14\n\x07task_id\x18\x06 \x01(\tH\x01\x88\x01\x01\x12H\n\x0e\x66unction_input\x18\t \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x02\x88\x01\x01\x12M\n\x13\x66unction_init_value\x18\n \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x03\x88\x01\x01\x42\x16\n\x14_graph_invocation_idB\n\n\x08_task_idB\x11\n\x0f_function_inputB\x16\n\x14_function_init_value"\xf1\x02\n\x0fRunTaskResponse\x12\x14\n\x07task_id\x18\x01 \x01(\tH\x00\x88\x01\x01\x12G\n\x0f\x66unction_output\x18\x02 \x01(\x0b\x32).function_executor_service.FunctionOutputH\x01\x88\x01\x01\x12\x43\n\rrouter_output\x18\x03 \x01(\x0b\x32\'.function_executor_service.RouterOutputH\x02\x88\x01\x01\x12\x13\n\x06stdout\x18\x04 \x01(\tH\x03\x88\x01\x01\x12\x13\n\x06stderr\x18\x05 \x01(\tH\x04\x88\x01\x01\x12\x17\n\nis_reducer\x18\x06 \x01(\x08H\x05\x88\x01\x01\x12\x14\n\x07success\x18\x07 \x01(\x08H\x06\x88\x01\x01\x42\n\n\x08_task_idB\x12\n\x10_function_outputB\x10\n\x0e_router_outputB\t\n\x07_stdoutB\t\n\x07_stderrB\r\n\x0b_is_reducerB\n\n\x08_success2\xe0\x01\n\x10\x46unctionExecutor\x12i\n\ninitialize\x12,.function_executor_service.InitializeRequest\x1a-.function_executor_service.InitializeResponse\x12\x61\n\x08run_task\x12).function_executor_service.RunTaskRequest\x1a*.function_executor_service.RunTaskResponseb\x06proto3'
+    b'\n8indexify/function_executor/proto/function_executor.proto\x12\x19\x66unction_executor_service"i\n\x10SerializedObject\x12\x0f\n\x05\x62ytes\x18\x01 \x01(\x0cH\x00\x12\x10\n\x06string\x18\x02 \x01(\tH\x00\x12\x19\n\x0c\x63ontent_type\x18\x03 \x01(\tH\x01\x88\x01\x01\x42\x06\n\x04\x64\x61taB\x0f\n\r_content_type"\x88\x02\n\x11InitializeRequest\x12\x16\n\tnamespace\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\x17\n\ngraph_name\x18\x02 \x01(\tH\x01\x88\x01\x01\x12\x1a\n\rgraph_version\x18\x03 \x01(\x05H\x02\x88\x01\x01\x12\x1a\n\rfunction_name\x18\x05 \x01(\tH\x03\x88\x01\x01\x12?\n\x05graph\x18\x07 \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x04\x88\x01\x01\x42\x0c\n\n_namespaceB\r\n\x0b_graph_nameB\x10\n\x0e_graph_versionB\x10\n\x0e_function_nameB\x08\n\x06_graph"6\n\x12InitializeResponse\x12\x14\n\x07success\x18\x01 \x01(\x08H\x00\x88\x01\x01\x42\n\n\x08_success"\x80\x01\n\x19SetInvocationStateRequest\x12\x10\n\x03key\x18\x01 \x01(\tH\x00\x88\x01\x01\x12?\n\x05value\x18\x02 \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x01\x88\x01\x01\x42\x06\n\x04_keyB\x08\n\x06_value"\x1c\n\x1aSetInvocationStateResponse"5\n\x19GetInvocationStateRequest\x12\x10\n\x03key\x18\x01 \x01(\tH\x00\x88\x01\x01\x42\x06\n\x04_key"\x81\x01\n\x1aGetInvocationStateResponse\x12\x10\n\x03key\x18\x01 \x01(\tH\x00\x88\x01\x01\x12?\n\x05value\x18\x02 \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x01\x88\x01\x01\x42\x06\n\x04_keyB\x08\n\x06_value"\xf7\x01\n\x16InvocationStateRequest\x12\x17\n\nrequest_id\x18\x01 \x01(\tH\x01\x88\x01\x01\x12\x14\n\x07task_id\x18\x02 \x01(\tH\x02\x88\x01\x01\x12\x43\n\x03set\x18\x03 \x01(\x0b\x32\x34.function_executor_service.SetInvocationStateRequestH\x00\x12\x43\n\x03get\x18\x04 \x01(\x0b\x32\x34.function_executor_service.GetInvocationStateRequestH\x00\x42\t\n\x07requestB\r\n\x0b_request_idB\n\n\x08_task_id"\xfb\x01\n\x17InvocationStateResponse\x12\x17\n\nrequest_id\x18\x01 \x01(\tH\x01\x88\x01\x01\x12\x14\n\x07success\x18\x02 \x01(\x08H\x02\x88\x01\x01\x12\x44\n\x03set\x18\x03 \x01(\x0b\x32\x35.function_executor_service.SetInvocationStateResponseH\x00\x12\x44\n\x03get\x18\x04 \x01(\x0b\x32\x35.function_executor_service.GetInvocationStateResponseH\x00\x42\n\n\x08responseB\r\n\x0b_request_idB\n\n\x08_success"N\n\x0e\x46unctionOutput\x12<\n\x07outputs\x18\x01 \x03(\x0b\x32+.function_executor_service.SerializedObject"\x1d\n\x0cRouterOutput\x12\r\n\x05\x65\x64ges\x18\x01 \x03(\t"\xb0\x02\n\x0eRunTaskRequest\x12 \n\x13graph_invocation_id\x18\x04 \x01(\tH\x00\x88\x01\x01\x12\x14\n\x07task_id\x18\x06 \x01(\tH\x01\x88\x01\x01\x12H\n\x0e\x66unction_input\x18\t \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x02\x88\x01\x01\x12M\n\x13\x66unction_init_value\x18\n \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x03\x88\x01\x01\x42\x16\n\x14_graph_invocation_idB\n\n\x08_task_idB\x11\n\x0f_function_inputB\x16\n\x14_function_init_value"\xf1\x02\n\x0fRunTaskResponse\x12\x14\n\x07task_id\x18\x01 \x01(\tH\x00\x88\x01\x01\x12G\n\x0f\x66unction_output\x18\x02 \x01(\x0b\x32).function_executor_service.FunctionOutputH\x01\x88\x01\x01\x12\x43\n\rrouter_output\x18\x03 \x01(\x0b\x32\'.function_executor_service.RouterOutputH\x02\x88\x01\x01\x12\x13\n\x06stdout\x18\x04 \x01(\tH\x03\x88\x01\x01\x12\x13\n\x06stderr\x18\x05 \x01(\tH\x04\x88\x01\x01\x12\x17\n\nis_reducer\x18\x06 \x01(\x08H\x05\x88\x01\x01\x12\x14\n\x07success\x18\x07 \x01(\x08H\x06\x88\x01\x01\x42\n\n\x08_task_idB\x12\n\x10_function_outputB\x10\n\x0e_router_outputB\t\n\x07_stdoutB\t\n\x07_stderrB\r\n\x0b_is_reducerB\n\n\x08_success2\xf2\x02\n\x10\x46unctionExecutor\x12i\n\ninitialize\x12,.function_executor_service.InitializeRequest\x1a-.function_executor_service.InitializeResponse\x12\x8f\x01\n"initialize_invocation_state_server\x12\x32.function_executor_service.InvocationStateResponse\x1a\x31.function_executor_service.InvocationStateRequest(\x01\x30\x01\x12\x61\n\x08run_task\x12).function_executor_service.RunTaskRequest\x1a*.function_executor_service.RunTaskResponseb\x06proto3'
 )
 
 _globals = globals()
@@ -40,14 +40,26 @@ if not _descriptor._USE_C_DESCRIPTORS:
     _globals["_INITIALIZEREQUEST"]._serialized_end = 459
     _globals["_INITIALIZERESPONSE"]._serialized_start = 461
     _globals["_INITIALIZERESPONSE"]._serialized_end = 515
-    _globals["_FUNCTIONOUTPUT"]._serialized_start = 517
-    _globals["_FUNCTIONOUTPUT"]._serialized_end = 595
-    _globals["_ROUTEROUTPUT"]._serialized_start = 597
-    _globals["_ROUTEROUTPUT"]._serialized_end = 626
-    _globals["_RUNTASKREQUEST"]._serialized_start = 629
-    _globals["_RUNTASKREQUEST"]._serialized_end = 933
-    _globals["_RUNTASKRESPONSE"]._serialized_start = 936
-    _globals["_RUNTASKRESPONSE"]._serialized_end = 1305
-    _globals["_FUNCTIONEXECUTOR"]._serialized_start = 1308
-    _globals["_FUNCTIONEXECUTOR"]._serialized_end = 1532
+    _globals["_SETINVOCATIONSTATEREQUEST"]._serialized_start = 518
+    _globals["_SETINVOCATIONSTATEREQUEST"]._serialized_end = 646
+    _globals["_SETINVOCATIONSTATERESPONSE"]._serialized_start = 648
+    _globals["_SETINVOCATIONSTATERESPONSE"]._serialized_end = 676
+    _globals["_GETINVOCATIONSTATEREQUEST"]._serialized_start = 678
+    _globals["_GETINVOCATIONSTATEREQUEST"]._serialized_end = 731
+    _globals["_GETINVOCATIONSTATERESPONSE"]._serialized_start = 734
+    _globals["_GETINVOCATIONSTATERESPONSE"]._serialized_end = 863
+    _globals["_INVOCATIONSTATEREQUEST"]._serialized_start = 866
+    _globals["_INVOCATIONSTATEREQUEST"]._serialized_end = 1113
+    _globals["_INVOCATIONSTATERESPONSE"]._serialized_start = 1116
+    _globals["_INVOCATIONSTATERESPONSE"]._serialized_end = 1367
+    _globals["_FUNCTIONOUTPUT"]._serialized_start = 1369
+    _globals["_FUNCTIONOUTPUT"]._serialized_end = 1447
+    _globals["_ROUTEROUTPUT"]._serialized_start = 1449
+    _globals["_ROUTEROUTPUT"]._serialized_end = 1478
+    _globals["_RUNTASKREQUEST"]._serialized_start = 1481
+    _globals["_RUNTASKREQUEST"]._serialized_end = 1785
+    _globals["_RUNTASKRESPONSE"]._serialized_start = 1788
+    _globals["_RUNTASKRESPONSE"]._serialized_end = 2157
+    _globals["_FUNCTIONEXECUTOR"]._serialized_start = 2160
+    _globals["_FUNCTIONEXECUTOR"]._serialized_end = 2530
 # @@protoc_insertion_point(module_scope)