assemblyline-v4-service 4.6.1.dev231__py3-none-any.whl → 4.7.0.dev25__py3-none-any.whl

assemblyline_v4_service/dev/updater.py

@@ -2,11 +2,14 @@ import importlib
 import inspect
 import json
 import os
+import shutil
 import tempfile
 import threading
 
 from assemblyline.common.isotime import now_as_iso
 from assemblyline.odm.models.service import SIGNATURE_DELIMITERS
+from assemblyline.odm.models.signature import Signature
+
 from assemblyline_v4_service.common.base import ServiceBase
 from assemblyline_v4_service.updater.client import (
     BadlistClient,
@@ -30,7 +33,9 @@ class TestSignatureClient(SignatureClient):
     def add_update_many(self, source, sig_type, data, dedup_name=True):
         os.makedirs(os.path.join(self.output_directory, sig_type, source), exist_ok=True)
         for d in data:
-            with open(os.path.join(self.output_directory, sig_type, source, d['name']), 'w') as f:
+            if isinstance(d, Signature):
+                d = d.as_primitives()
+            with open(os.path.join(self.output_directory, sig_type, source, d['signature_id']), 'w') as f:
                 json.dump(d, f)
 
         return {'success': len(data)}
@@ -126,7 +131,7 @@ def load_rules(service: ServiceBase):
 
                         if self.delimiter != "file":
                             # Render the response when calling `client.signature.download`
-                            os.removedirs(sourcepath)
+                            shutil.rmtree(sourcepath)
                             with open(os.path.join(self.latest_updates_dir, source), 'w') as f:
                                 f.write(SIGNATURE_DELIMITERS[self.delimiter].join(signaure_data))
 

assemblyline_v4_service/healthz.py

@@ -1,34 +1,33 @@
+"""Utility script for reading pod health status for kubernetes deployments."""
+from os import environ, path
+
 import requests
 
-from os import environ, path
-from assemblyline.common import forge
-from sys import exit
 
 UPDATES_CA = environ.get('UPDATES_CA', '/etc/assemblyline/ssl/al_root-ca.crt')
 SERVICE_SERVER_CA = environ.get('SERVICE_SERVER_CA', '/etc/assemblyline/ssl/al_root-ca.crt')
+REQUEST_TIMEOUT = 30
 
 
-# Intended for use with Kubernetes deployments
 def perform_check():
-    # If the service is privileged, test connectivity to core
-    if environ.get('PRIVILEGED', 'false').lower() == 'true':
-        forge.get_datastore()
-        forge.get_filestore(connection_attempts=1)
-        forge.get_service_queue(service=environ['AL_SERVICE_NAME'])
-    else:
-        service_api_host = environ['SERVICE_API_HOST']
-        verify = None if not service_api_host.startswith('https') else SERVICE_SERVER_CA
-        # Otherwise, perform a test for service-server availability
-        if not requests.get(f"{service_api_host}/healthz/live", verify=verify).ok:
-            raise Exception('Unable to reach service-server')
+    """
+    Test prerequisites for this service being healthy.
+
+    Intended for use with Kubernetes deployments.
+    """
+
+    # Probe service server
+    service_api_host = environ['SERVICE_API_HOST']
+    verify = None if not service_api_host.startswith('https') else SERVICE_SERVER_CA
+    if not requests.get(f"{service_api_host}/healthz/live", verify=verify, timeout=REQUEST_TIMEOUT).ok:
+        raise RuntimeError('Unable to reach service-server')
 
     # If running with an updater, check for availability. Make sure test doesn't run on the actual updater.
     if environ.get('updates_host') and not environ['HOSTNAME'].startswith(environ['updates_host']):
         scheme, verify = ("http", None) if not path.exists(UPDATES_CA) else ("https", UPDATES_CA)
-        if not requests.get(f"{scheme}://{environ['updates_host']}:{environ['updates_port']}/healthz/live",
-                            verify=verify).ok:
-            raise Exception('Unable to reach local update server')
-    exit()
+        updater_url = f"{scheme}://{environ['updates_host']}:{environ['updates_port']}/healthz/live"
+        if not requests.get(updater_url, verify=verify, timeout=REQUEST_TIMEOUT).ok:
+            raise RuntimeError('Unable to reach local update server')
 
 
 if __name__ == '__main__':

{assemblyline_v4_service-4.6.1.dev231.dist-info → assemblyline_v4_service-4.7.0.dev25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assemblyline-v4-service
-Version: 4.6.1.dev231
+Version: 4.7.0.dev25
 Summary: Assemblyline 4 - Service base
 Home-page: https://github.com/CybercentreCanada/assemblyline-v4-service/
 Author: CCCS Assemblyline development team

{assemblyline_v4_service-4.6.1.dev231.dist-info → assemblyline_v4_service-4.7.0.dev25.dist-info}/RECORD

@@ -1,22 +1,21 @@
-assemblyline_v4_service/VERSION,sha256=8DtAyK44jTf2L83IBmIrZvpo7UPaxJnP23exVsiQSO8,13
+assemblyline_v4_service/VERSION,sha256=86rnx2n5DlVlISBAT0O8ZIOeE-g_gwhj06QGH74PUGQ,12
 assemblyline_v4_service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-assemblyline_v4_service/healthz.py,sha256=3QGBg0EZuXC6UN411HFwpLNEop9UvS9feFhvBUTP-k4,1576
+assemblyline_v4_service/healthz.py,sha256=2Xu9NAQwrb_0mIMgNmpppDvYYq3HYz-ofLIv4tGP8Ns,1406
 assemblyline_v4_service/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-assemblyline_v4_service/run_privileged_service.py,sha256=un2zcZjQVKYwMWihLLmeUc3IMJ6ALnFbR1FPeMW1U2A,14486
 assemblyline_v4_service/run_service.py,sha256=XfdABk3hEZsIw31tmFcJc-FbcxvBF9tiDIlg9oHCtZA,5900
 assemblyline_v4_service/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-assemblyline_v4_service/common/api.py,sha256=Xzp8j4HCCfjPvNSGKiZl5ttH2_Itg47cjlH0NXNtth0,6849
-assemblyline_v4_service/common/base.py,sha256=psivTxiOeN2jqL3G3I26oY9JFK-qPuwrg5y_y_d7xYs,14127
+assemblyline_v4_service/common/api.py,sha256=hY1l-REWN77nflIYVhkDX7JtMFzUwsTzNhnbr3df29I,5189
+assemblyline_v4_service/common/base.py,sha256=jdxGX9Wd2B_SvOjfxRHdycTq_1Upb9KiDQ5ZaCqQsqw,13926
 assemblyline_v4_service/common/helper.py,sha256=xs9quuf-M1JOdKieBqOmWaOece0CtzXFhhe85xQYmuY,3289
 assemblyline_v4_service/common/ocr.py,sha256=NgkFqAq2lRzIveYUulKJmiiWYqwf4siYbL59n1Ow02o,8350
-assemblyline_v4_service/common/ontology_helper.py,sha256=9Ad81qbddg_pRMupT8o_KzxbKgpodaRqpc3mPoEKLtw,8494
-assemblyline_v4_service/common/request.py,sha256=W7fqC2xQE3i5i2jlCDyUDp3ZqJQQqSshNW0mQfJMkFg,11792
-assemblyline_v4_service/common/result.py,sha256=9AqM6qCYiia_Bpyn_fBFhzNQMcqJbtFSiGjp57fXW2E,32713
-assemblyline_v4_service/common/task.py,sha256=dJsvRpW0x88CCF_LW6w87jQ_UKTVaOs2Gb117IDNiU8,14233
+assemblyline_v4_service/common/ontology_helper.py,sha256=XxZ488-B7fCP4cMSMfeflzTG_cSQ3GwfH0nM_7enCiY,8496
+assemblyline_v4_service/common/request.py,sha256=Okj7X7MlNPTGitiQpuMMACsDsrgOd33ajWbIiFNXEjk,11729
+assemblyline_v4_service/common/result.py,sha256=rnjJJCZnXU2lmZwWoLIQwWGKa4l-Zx5NkT5lXyJfMa4,54924
+assemblyline_v4_service/common/task.py,sha256=yTNdQ3C07g3zzK3fxDdOeeZknn_SUBNPAbRLwFZsrzc,14168
 assemblyline_v4_service/common/utils.py,sha256=FDFsFcI6wt-pWyeQYnDWivsPbtme5RqVyofmNiggh6Y,3922
 assemblyline_v4_service/dev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 assemblyline_v4_service/dev/run_service_once.py,sha256=W9kR49IUbkt8tNXjCT40ZMh-8p5W_odxlkDx6nhTAYM,10656
-assemblyline_v4_service/dev/updater.py,sha256=b-FK6XPRZbETbl-SIYEhnYGT-W7EcQhnxwD6x2NMC7g,6411
+assemblyline_v4_service/dev/updater.py,sha256=uumFNJo6WSW6ngv9p9qZPD83jXF2jX4aYJs_IdpzmHo,6569
 assemblyline_v4_service/updater/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 assemblyline_v4_service/updater/__main__.py,sha256=9Os-u8Tf7MD73JSrUSPmOaErTgfvesNLiEeszU4ujXA,133
 assemblyline_v4_service/updater/app.py,sha256=Mtmx4bkXfP4nFqqa5q15jW8QIXr4JK84lCovxAVyvPs,3317
@@ -24,14 +23,14 @@ assemblyline_v4_service/updater/client.py,sha256=tLY84gaGdFBVIDaMgRHIEa7x2S8jBl7
 assemblyline_v4_service/updater/gunicorn_config.py,sha256=p3j2KPBeD5jvMw9O5i7vAtlRgPSVVxIG9AO0DfN82J8,1247
 assemblyline_v4_service/updater/helper.py,sha256=OTV6WA77wBDOSVWaxijNg-HpwvEwnZozH03S3Q4oUns,10764
 assemblyline_v4_service/updater/updater.py,sha256=XiqabDp89-t_J6C3U33R-RvA5lMIahFW_MsAVUGyXok,31876
-assemblyline_v4_service-4.6.1.dev231.dist-info/licenses/LICENCE.md,sha256=NSkYo9EH8h5oOkzg4VhjAHF4339MqPP2cQ8msTPgl-c,1396
+assemblyline_v4_service-4.7.0.dev25.dist-info/licenses/LICENCE.md,sha256=NSkYo9EH8h5oOkzg4VhjAHF4339MqPP2cQ8msTPgl-c,1396
 test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 test/conftest.py,sha256=W3SieQpZsZpGEmtLqY4aIlxREDSsHceyCrFcFsWUM0U,1851
 test/test_healthz.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 test/test_run_privileged_service.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 test/test_run_service.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 test/test_common/__init__.py,sha256=RkOm3vnVp5L947mD1jTo4bdOgLTZJ24_NX-kqfMn5a8,1259
-test/test_common/test_api.py,sha256=7wlo7wgB12T23zMLbwjJ3GIomLHqE_Qvs3xkibSsR1U,4902
+test/test_common/test_api.py,sha256=jkgQxVZ6zvGkGL2yCePr8ebvsmH93awfCJm11o11XWA,4231
 test/test_common/test_base.py,sha256=fuJSSlPxIDHq6HU1xbvaMFitw2z1spOZNHD2SJ4UUic,13346
 test/test_common/test_helper.py,sha256=sO6YAiBhKTqaxlpLhFYDuy2ZdbuF2cg07Ylzo83ZzQs,2575
 test/test_common/test_ocr.py,sha256=X_Y3c_yfRljD0o2SRUHuotKLTTX0lD5zW68mzQ7LKu4,1250
@@ -40,7 +39,7 @@ test/test_common/test_request.py,sha256=HiDU1n4Rjso_U0qDME4ohA_9j7rpfqLSD1-e2Rfq
 test/test_common/test_result.py,sha256=ZtLUddBDA_BTIjG3Jasbq78_AdEjCRe4cb85XLBwH5o,43585
 test/test_common/test_task.py,sha256=P44mNcSe-3tJgDk9ppN3KbM7oN4LBVIuhONG-Gveh74,19007
 test/test_common/test_utils.py,sha256=TbnBxqpS_ZC5ptXR9XJX3xtbItD0mTbtiBxxdyP8J5k,5904
-assemblyline_v4_service-4.6.1.dev231.dist-info/METADATA,sha256=IonPDpmHPmwNmIfb2yW_EC1DFE7kVDXGmjz0BufwTbI,5625
-assemblyline_v4_service-4.6.1.dev231.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-assemblyline_v4_service-4.6.1.dev231.dist-info/top_level.txt,sha256=LpTOEaVCatkrvbVq3EZseMSIa2PQZU-2rhuO_FTpZgY,29
-assemblyline_v4_service-4.6.1.dev231.dist-info/RECORD,,
+assemblyline_v4_service-4.7.0.dev25.dist-info/METADATA,sha256=WiWDzeRFZ7tNT7MunyO5y73UTKHxbnqJHpp6l0Re2dk,5624
+assemblyline_v4_service-4.7.0.dev25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+assemblyline_v4_service-4.7.0.dev25.dist-info/top_level.txt,sha256=LpTOEaVCatkrvbVq3EZseMSIa2PQZU-2rhuO_FTpZgY,29
+assemblyline_v4_service-4.7.0.dev25.dist-info/RECORD,,

test/test_common/test_api.py

@@ -118,27 +118,3 @@ def test_serviceapi_lookup_safelist():
 
 # TODO
 # SafelistClient requires forge access
-
-# def test_privilegedserviceapi_init():
-#     log = logging.getLogger('assemblyline')
-#     psa = PrivilegedServiceAPI(log)
-#     assert psa.log == log
-#     assert isinstance(psa.safelist_client, SafelistClient)
-
-
-# def test_privilegedserviceapi_get_safelist():
-#     log = logging.getLogger('assemblyline')
-#     psa = PrivilegedServiceAPI(log)
-#     assert psa.get_safelist() == {}
-
-#     # TODO
-#     # Test not in development mode
-
-
-# def test_privilegedserviceapi_lookup_safelist():
-#     log = logging.getLogger('assemblyline')
-#     psa = PrivilegedServiceAPI(log)
-#     assert psa.lookup_safelist("qhash") is None
-
-    # TODO
-    # Test not in development mode

assemblyline_v4_service/run_privileged_service.py

@@ -1,337 +0,0 @@
-import copy
-import json
-import os
-import shutil
-import tempfile
-from io import BytesIO
-from json import JSONDecodeError
-
-import yaml
-from assemblyline_core.server_base import ServerBase
-from assemblyline_core.tasking_client import TaskingClient
-
-from assemblyline.common.digests import get_sha256_for_file
-from assemblyline.common.importing import load_module_by_path
-from assemblyline.common.metrics import MetricsFactory
-from assemblyline.common.str_utils import StringTable
-from assemblyline.common.version import BUILD_MINOR, FRAMEWORK_VERSION, SYSTEM_VERSION
-from assemblyline.filestore import FileStoreException
-from assemblyline.odm.messages.service_heartbeat import Metrics
-from assemblyline.odm.messages.task import Task as ServiceTask
-from assemblyline.remote.datatypes import get_client
-from assemblyline_v4_service.common.base import is_recoverable_runtime_error
-
-SERVICE_PATH = os.environ['SERVICE_PATH']
-SERVICE_TAG = os.environ.get("SERVICE_TAG", f"{FRAMEWORK_VERSION}.{SYSTEM_VERSION}.{BUILD_MINOR}.dev0").encode("utf-8")
-SERVICE_MANIFEST = os.path.join(os.getcwd(), os.environ.get('MANIFEST_FOLDER', ''), 'service_manifest.yml')
-TMP_SERVICE_MANIFEST = f"/tmp/{os.environ.get('RUNTIME_PREFIX', 'service')}_manifest.yml"
-REGISTER_ONLY = os.environ.get('REGISTER_ONLY', 'False').lower() == 'true'
-
-SERVICE_NAME = SERVICE_PATH.split(".")[-1].lower()
-SHUTDOWN_SECONDS_LIMIT = 10
-TASK_REQUEST_TIMEOUT = 30
-
-STATUSES = StringTable('STATUSES', [
-    ('INITIALIZING', 0),
-    ('WAITING_FOR_TASK', 1),
-    ('DOWNLOADING_FILE', 2),
-    ('PROCESSING', 3),
-    ('RESULT_FOUND', 4),
-    ('ERROR_FOUND', 5),
-    ('STOPPING', 6),
-    ('FILE_NOT_FOUND', 7),
-])
-
-
-class RunPrivilegedService(ServerBase):
-    def __init__(self, shutdown_timeout: int = SHUTDOWN_SECONDS_LIMIT):
-        super(RunPrivilegedService, self).__init__(
-            f'assemblyline.service.{SERVICE_NAME}', shutdown_timeout=shutdown_timeout)
-
-        self.client_id = os.environ.get('HOSTNAME', 'dev-service')
-
-        self.redis = get_client(
-            host=self.config.core.redis.nonpersistent.host,
-            port=self.config.core.redis.nonpersistent.port,
-            private=False,
-        )
-
-        self.redis_persist = get_client(
-            host=self.config.core.redis.persistent.host,
-            port=self.config.core.redis.persistent.port,
-            private=False,
-        )
-
-        self.tasking_client = TaskingClient(redis=self.redis, redis_persist=self.redis_persist,
-                                            register_only=REGISTER_ONLY)
-        self.tasking_dir = os.environ.get('TASKING_DIR', tempfile.gettempdir())
-
-        self.service = None
-        self.service_config = {}
-        self.service_name = None
-        self.service_tool_version = None
-
-        self.status = STATUSES.INITIALIZING
-        self.metric_factory = None
-
-    def _load_manifest(self):
-        bio = BytesIO()
-        with open(SERVICE_MANIFEST, "rb") as srv_manifest:
-            for line in srv_manifest.readlines():
-                bio.write(line.replace(b"$SERVICE_TAG", SERVICE_TAG))
-            bio.flush()
-        bio.seek(0)
-
-        return yaml.safe_load(bio)
-
-    def _update_manifest(self, data):
-        with open(SERVICE_MANIFEST, 'r') as yml_fh:
-            manifest = yaml.safe_load(yml_fh)
-            manifest.update(data)
-
-        with open(TMP_SERVICE_MANIFEST, 'w') as yml_fh:
-            yaml.safe_dump(manifest, yml_fh)
-
-        data = manifest
-
-    def _cleanup_working_directory(self):
-        # Make the tasking dir if it does not exists
-        if not os.path.exists(self.tasking_dir):
-            os.makedirs(self.tasking_dir)
-
-        for file in os.listdir(self.tasking_dir):
-            file_path = os.path.join(self.tasking_dir, file)
-            try:
-                if file_path == TMP_SERVICE_MANIFEST:
-                    # We'd like to keep the service_manifest file committed to disk
-                    continue
-
-                if os.path.isfile(file_path):
-                    os.unlink(file_path)
-                elif os.path.isdir(file_path):
-                    shutil.rmtree(file_path)
-            except Exception:
-                pass
-
-    def try_run(self):
-        self.status = STATUSES.INITIALIZING
-
-        # Try to load service class
-        try:
-            service_class = load_module_by_path(SERVICE_PATH)
-        except Exception:
-            self.log.error("Could not find service in path.")
-            raise
-
-        # Load on-disk manifest for bootstrap/registration
-        service_manifest = self._load_manifest()
-        file_required = service_manifest.get('file_required', True)
-
-        # Register the service
-        registration = self.tasking_client.register_service(service_manifest)
-
-        # Are we just registering?
-        if not registration['keep_alive'] or REGISTER_ONLY:
-            self.status = STATUSES.STOPPING
-            self.stop()
-            return
-
-        # Commit service manifest changes back to disk
-        self._update_manifest(registration.get('service_config', {}))
-
-        # Instantiate the service based of the registration results
-        self.service_config = registration.get('service_config', {})
-        self.service = service_class(config=self.service_config.get('config'))
-        self.service_name = self.service_config['name']
-        self.service_tool_version = self.service.get_tool_version()
-        self.metric_factory = MetricsFactory('service', Metrics, name=self.service_name,
-                                             export_zero=False, redis=self.redis)
-
-        # Start the service
-        self.service.start_service()
-
-        while self.running:
-            # Cleanup the working directory
-            self._cleanup_working_directory()
-
-            # Get a task
-            self.status = STATUSES.WAITING_FOR_TASK
-            task, _ = self.tasking_client.get_task(self.client_id, self.service_name, self.service_config['version'],
-                                                   self.service_tool_version, self.metric_factory)
-
-            if not task:
-                continue
-
-            # Load Task
-            try:
-                # Inspect task to ensure submission parameters are given, add defaults where necessary
-                params = {x['name']: x['default'] for x in service_manifest.get('submission_params', [])}
-                params.update(task['service_config'])
-                task['service_config'] = params
-                service_task = ServiceTask(task)
-                self.log.info(f"[{service_task.sid}] New task received")
-            except ValueError as e:
-                self.log.error(f"Invalid task received: {str(e)}")
-                continue
-
-            # Download file if needed
-            if file_required:
-                self.status = STATUSES.DOWNLOADING_FILE
-                file_path = os.path.join(self.tasking_dir, service_task.fileinfo.sha256)
-                received_file_sha256 = None
-                self.log.info(f"[{service_task.sid}] Downloading file: {service_task.fileinfo.sha256}")
-                try:
-                    self.tasking_client.filestore.download(service_task.fileinfo.sha256, file_path)
-                    received_file_sha256 = get_sha256_for_file(file_path)
-                except FileStoreException:
-                    self.status = STATUSES.FILE_NOT_FOUND
-                    self.log.error(
-                        f"[{service_task.sid}] Requested file not found in the system: {service_task.fileinfo.sha256}")
-
-                # If the file retrieved is different from what we requested, report the error
-                if received_file_sha256 and received_file_sha256 != service_task.fileinfo.sha256:
-                    self.status = STATUSES.ERROR_FOUND
-                    self.log.error(f"[{service_task.sid}] Downloaded ({received_file_sha256}) doesn't match "
-                                   f"requested ({service_task.fileinfo.sha256})")
-
-            # Process if we're not already in error
-            if self.status not in [STATUSES.ERROR_FOUND, STATUSES.FILE_NOT_FOUND]:
-                self.status = STATUSES.PROCESSING
-                self.service.handle_task(service_task)
-
-                # Check for the response from the service
-                result_json = os.path.join(
-                    self.tasking_dir, f"{service_task.sid}_{service_task.fileinfo.sha256}_result.json")
-                error_json = os.path.join(
-                    self.tasking_dir, f"{service_task.sid}_{service_task.fileinfo.sha256}_error.json")
-                if os.path.exists(result_json):
-                    self.status = STATUSES.RESULT_FOUND
-                elif os.path.exists(error_json):
-                    self.status = STATUSES.ERROR_FOUND
-                else:
-                    self.status = STATUSES.ERROR_FOUND
-                    error_json = None
-
-            # Handle the service response
-            if self.status == STATUSES.RESULT_FOUND:
-                self.log.info(f"[{service_task.sid}] Task successfully completed")
-                try:
-                    self._handle_task_result(result_json, service_task)
-                except RuntimeError as re:
-                    if is_recoverable_runtime_error(re):
-                        self.log.info(f"[{service_task.sid}] Service trying to use a threadpool during shutdown, "
-                                      "sending recoverable error.")
-                        self._handle_task_error(service_task)
-                    else:
-                        raise
-            elif self.status == STATUSES.ERROR_FOUND:
-                self.log.info(f"[{service_task.sid}] Task completed with errors")
-                self._handle_task_error(service_task, error_json_path=error_json)
-            elif self.status == STATUSES.FILE_NOT_FOUND:
-                self.log.info(f"[{service_task.sid}] Task completed with errors due to missing file from filestore")
-                self._handle_task_error(service_task, status="FAIL_NONRECOVERABLE", error_type="EXCEPTION")
-
-    def _handle_task_result(self, result_json_path: str, task: ServiceTask):
-        with open(result_json_path, 'r') as f:
-            result = json.load(f)
-
-        # Map of file info by SHA256
-        result_files = {}
-        for file in result['response']['extracted'] + result['response']['supplementary']:
-            result_files[file['sha256']] = copy.deepcopy(file)
-            file.pop('path', None)
-
-        new_tool_version = result.get('response', {}).get('service_tool_version', None)
-        if new_tool_version is not None and self.service_tool_version != new_tool_version:
-            self.service_tool_version = new_tool_version
-
-        resp = {'success': False, 'missing_files': []}
-        freshen = True
-
-        while not resp['success']:
-            for f_sha256 in resp['missing_files']:
-                file_info = result_files[f_sha256]
-                self.log.info(f"[{task.sid}] Uploading file {file_info['path']} [{file_info['sha256']}]")
-
-                self.tasking_client.upload_file(
-                    file_info['path'],
-                    file_info['classification'],
-                    task.ttl,
-                    file_info.get('is_section_image', False),
-                    file_info.get('is_supplementary', False),
-                    expected_sha256=file_info['sha256']
-                )
-
-            try:
-                resp = self.tasking_client.task_finished(
-                    dict(task=task.as_primitives(), result=result, freshen=freshen), self.client_id,
-                    self.service_name, self.metric_factory)
-                if resp is None:
-                    self._handle_task_error(task, message="No result or error provided by service.",
-                                            error_type='EXCEPTION', status='FAIL_NONRECOVERABLE')
-                    return
-            except ValueError as e:
-                self._handle_task_error(task, message=str(e), error_type='EXCEPTION', status='FAIL_NONRECOVERABLE')
-                return
-
-            freshen = False
-
-    def _handle_task_error(self, task: ServiceTask, error_json_path=None,
-                           message=None, error_type=None, status=None):
-        if task is None:
-            return
-
-        if self.service:
-            version = self.service_config['version']
-        else:
-            version = '0'
-
-        error = dict(
-            response=dict(
-                message=message or "The service instance processing this task has terminated unexpectedly.",
-                service_name=task.service_name,
-                service_version=version,
-                status=status or 'FAIL_RECOVERABLE',
-            ),
-            sha256=task.fileinfo.sha256,
-            type=error_type or 'UNKNOWN',
-        )
-
-        if error_json_path:
-            try:
-                with open(error_json_path, 'r') as f:
-                    error = json.load(f)
-            except (IOError, JSONDecodeError, OSError):
-                self.log.exception(f"[{task.sid}] An error occurred while loading service error file.")
-
-        try:
-            resp = self.tasking_client.task_finished(
-                dict(task=task.as_primitives(), error=error), self.client_id,
-                self.service_name, self.metric_factory)
-            if resp is None:
-                self.log.error(f"[{task.sid}] The tasking client failed to detect the error data.")
-        except ValueError as e:
-            self.log.exception(
-                f"[{task.sid}] An error occured while trying to save the result error in the system: '{str(e)}'")
-
-    def stop(self):
-        if self.status == STATUSES.WAITING_FOR_TASK:
-            # A task request was sent and a task might be received, so shutdown after giving service time to process it
-            self._shutdown_timeout = TASK_REQUEST_TIMEOUT + self.service_config.get('timeout', SHUTDOWN_SECONDS_LIMIT)
-        elif self.status not in [STATUSES.INITIALIZING, STATUSES.STOPPING]:
-            # A task is currently running, so wait until service timeout before doing a hard stop
-            self._shutdown_timeout = self.service_config.get('timeout', SHUTDOWN_SECONDS_LIMIT)
-        else:
-            # Already the default
-            self._shutdown_timeout = SHUTDOWN_SECONDS_LIMIT
-
-        if self.service:
-            self.service.stop_service()
-
-        self.tasking_client.stop()
-
-        super().stop()
-
-
-if __name__ == '__main__':
-    RunPrivilegedService().serve_forever()