code: def handle_message_multiprocessing(
      worker_settings, queue_item, credentials
  ):
      # this is a temp hack to prevent some multithreading issues
      time.sleep(0.5)
      queue_config = worker_settings.queue_config
      queue_config.client_config.create_producer = False
      queue_config.client_config.n_consumers = 0
  
      # relative
      from ...node.node import Node
  
      worker = Node(
          id=worker_settings.id,
          name=worker_settings.name,
          signing_key=worker_settings.signing_key,
          document_store_config=worker_settings.document_store_config,
          action_store_config=worker_settings.action_store_config,
          blob_storage_config=worker_settings.blob_store_config,
          queue_config=queue_config,
          is_subprocess=True,
          migrate=False,
      )
  
      job_item = worker.job_stash.get_by_uid(
          credentials, queue_item.job_id
      ).ok()
  
      # Set monitor thread for this job.
      monitor_thread = MonitorThread(queue_item, worker, credentials)
      monitor_thread.start()
  
      if queue_item.service == "user":
          queue_item.service = "userservice"
  
      try:
          call_method = getattr(
              worker.get_service(queue_item.service), queue_item.method
          )
  
          role = worker.get_role_for_credentials(
              credentials=credentials
          )
  
          context = AuthedServiceContext(
              node=worker,
              credentials=credentials,
              role=role,
              job_id=queue_item.job_id,
              has_execute_permissions=queue_item.has_execute_permissions,
          )
  
          # relative
          from ...node.node import AuthNodeContextRegistry
  
          AuthNodeContextRegistry.set_node_context(
              node_uid=worker.id,
              context=context,
              user_verify_key=credentials,
          )
  
          result: Any = call_method(
              context, *queue_item.args, **queue_item.kwargs
          )
  
          if isinstance(result, Ok):
              status = Status.COMPLETED
              job_status = JobStatus.COMPLETED
              result = result.ok()
          elif isinstance(result, SyftError) or isinstance(result, Err):
              status = Status.ERRORED
              job_status = JobStatus.ERRORED
      except Exception as e:  # nosec
          status = Status.ERRORED
          job_status = JobStatus.ERRORED
          # stdlib
  
          raise e
          # result = SyftError(
          #     message=f"Failed with exception: {e}, {traceback.format_exc()}"
          # )
          # print("HAD AN ERROR WHILE HANDLING MESSAGE", result.message)
  
      queue_item.result = result
      queue_item.resolved = True
      queue_item.status = status
  
      # get new job item to get latest iter status
      job_item = worker.job_stash.get_by_uid(
          credentials, job_item.id
      ).ok()
  
      # if result.is_ok():
  
      job_item.node_uid = worker.id
      job_item.result = result
      job_item.resolved = True
      job_item.status = job_status
  
      worker.queue_stash.set_result(credentials, queue_item)
      worker.job_stash.set_result(credentials, job_item)
  
      # Finish monitor thread
      monitor_thread.stop()
  
imports: import multiprocessing
  import threading
  import time
  from typing import Any
  from typing import Optional
  from typing import Type
  from typing import Union
  import psutil
  from result import Err
  from result import Ok
  from result import Result
  from ...node.credentials import SyftVerifyKey
  from ...serde.deserialize import _deserialize
  from ...serde.serializable import serializable
  from ...service.context import AuthedServiceContext
  from ...types.datetime import DateTime
  from ...types.uid import UID
  from ..job.job_stash import Job
  from ..job.job_stash import JobStash
  from ..job.job_stash import JobStatus
  from ..response import SyftError
  from ..response import SyftSuccess
  from ..worker.worker_stash import WorkerStash
  from .base_queue import AbstractMessageHandler
  from .base_queue import BaseQueueManager
  from .base_queue import QueueConfig
  from .base_queue import QueueConsumer
  from .base_queue import QueueProducer
  from .queue_stash import QueueItem
  from .queue_stash import Status
label_desc: Use image node_id 1 for calling a global function with example usage: handle_message_multiprocessing(worker_settings, queue_item, credentials) without return types