assemblyline-core 4.6.0.15__tar.gz → 4.6.0.18__tar.gz

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assemblyline-core
-Version: 4.6.0.15
+Version: 4.6.0.18
 Summary: Assemblyline 4 - Core components
 Home-page: https://github.com/CybercentreCanada/assemblyline-core/
 Author: CCCS Assemblyline development team

assemblyline_core-4.6.0.18/assemblyline_core/VERSION

@@ -0,0 +1 @@
+4.6.0.18

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core/dispatching/dispatcher.py

@@ -73,6 +73,7 @@ if TYPE_CHECKING:
     from redis import Redis
 
     from assemblyline.odm.models.file import File
+    from assemblyline.odm.models.config import Config
 
 
 APM_SPAN_TYPE = 'handle_message'
@@ -218,8 +219,18 @@ class TemporaryFileData:
 class SubmissionTask:
     """Dispatcher internal model for submissions"""
 
-    def __init__(self, submission, completed_queue, scheduler, datastore: AssemblylineDatastore, results=None,
-                 file_infos=None, file_tree=None, errors: Optional[Iterable[str]] = None):
+    def __init__(
+        self,
+        submission,
+        completed_queue,
+        scheduler,
+        datastore: AssemblylineDatastore,
+        config: Config,
+        results=None,
+        file_infos=None,
+        file_tree=None,
+        errors: Optional[Iterable[str]] = None,
+    ):
         self.submission: Submission = Submission(submission)
         submitter: Optional[User] = datastore.user.get_if_exists(self.submission.params.submitter)
         self.service_access_control: Optional[str] = None
@@ -227,6 +238,7 @@ class SubmissionTask:
             self.service_access_control = submitter.classification.value
 
         self.completed_queue = None
+
         if completed_queue:
             self.completed_queue = str(completed_queue)
 
@@ -265,9 +277,31 @@ class SubmissionTask:
                     recurse_tree(file_data['children'], depth + 1)
 
             recurse_tree(file_tree, 0)
+            sorted_file_depth = [(k, v) for k, v in sorted(self.file_depth.items(), key=lambda fd: fd[1])]
+        else:
+            sorted_file_depth = [(self.submission.files[0].sha256, 0)]
+
+        for sha256, depth in sorted_file_depth:
+            # populate temporary data to root level files
+            if depth == 0:
+                # Apply initial data parameter
+                temp_key_config = dict(config.submission.default_temporary_keys)
+                temp_key_config.update(config.submission.temporary_keys)
+                temporary_data = TemporaryFileData(sha256, config=temp_key_config)
+                self.temporary_data[sha256] = temporary_data
+                if self.submission.params.initial_data:
+                    try:
+                        for key, value in dict(json.loads(self.submission.params.initial_data)).items():
+                            if len(str(value)) > config.submission.max_temp_data_length:
+                                continue
+                            temporary_data.set_value(key, value)
+
+                    except (ValueError, TypeError):
+                        pass
 
         if results is not None:
             rescan = scheduler.expand_categories(self.submission.params.services.rescan)
+            result_keys = list(results.keys())
 
             # Replay the process of routing files for dispatcher internal state.
             for k, result in results.items():
@@ -282,24 +316,35 @@ class SubmissionTask:
                     self.forbid_for_children(sha256, service_name)
 
             # Replay the process of receiving results for dispatcher internal state
-            for k, result in results.items():
-                sha256, service, _ = k.split('.', 2)
-                if service not in rescan:
-                    extracted = result['response']['extracted']
-                    children: list[str] = [r['sha256'] for r in extracted]
-                    self.register_children(sha256, children)
-                    children_detail: list[tuple[str, str]] = [(r['sha256'], r['parent_relation']) for r in extracted]
-                    self.service_results[(sha256, service)] = ResultSummary(
-                        key=k, drop=result['drop_file'], score=result['result']['score'],
-                        children=children_detail, partial=result.get('partial', False))
-
-                tags = Result(result).scored_tag_dict()
-                for key, tag in tags.items():
-                    if key in self.file_tags[sha256].keys():
-                        # Sum score of already known tags
-                        self.file_tags[sha256][key]['score'] += tag['score']
-                    else:
-                        self.file_tags[sha256][key] = tag
+            # iterate through result based on file depth
+            for sha256, depth in sorted_file_depth:
+                results_to_process = list(filter(lambda k: sha256 in k, result_keys))
+                for result_key in results_to_process:
+                    result = results[result_key]
+                    sha256, service, _ = result_key.split(".", 2)
+
+                    if service not in rescan:
+                        extracted = result["response"]["extracted"]
+                        children: list[str] = [r["sha256"] for r in extracted]
+                        self.register_children(sha256, children)
+                        children_detail: list[tuple[str, str]] = [
+                            (r["sha256"], r["parent_relation"]) for r in extracted
+                        ]
+                        self.service_results[(sha256, service)] = ResultSummary(
+                            key=result_key,
+                            drop=result["drop_file"],
+                            score=result["result"]["score"],
+                            children=children_detail,
+                            partial=result.get("partial", False),
+                        )
+
+                    tags = Result(result).scored_tag_dict()
+                    for key, tag in tags.items():
+                        if key in self.file_tags[sha256].keys():
+                            # Sum score of already known tags
+                            self.file_tags[sha256][key]["score"] += tag["score"]
+                        else:
+                            self.file_tags[sha256][key] = tag
 
         if errors is not None:
             for e in errors:
@@ -334,6 +379,7 @@ class SubmissionTask:
         _parent_map is for dynamic recursion prevention
         temporary_data is for cascading the temp data to children
         """
+
         parent_temp = self.temporary_data[parent]
         for child in children:
             if child not in self.temporary_data:
@@ -706,7 +752,13 @@ class Dispatcher(ThreadedCoreBase):
                 # Start of process dispatcher transaction
                 with apm_span(self.apm_client, 'submission_message'):
                     # This is probably a complete task
-                    task = SubmissionTask(scheduler=self.scheduler, datastore=self.datastore, **message)
+
+                    task = SubmissionTask(
+                        scheduler=self.scheduler,
+                        datastore=self.datastore,
+                        config=self.config,
+                        **message,
+                    )
 
                     # Check the sid table
                     if task.sid in self.bad_sids:
@@ -739,6 +791,7 @@ class Dispatcher(ThreadedCoreBase):
 
         if not self.active_submissions.exists(sid):
             self.log.info("[%s] New submission received", sid)
+
             task.trace('submission_start')
             self.active_submissions.add(sid, {
                 'completed_queue': task.completed_queue,
@@ -760,21 +813,6 @@ class Dispatcher(ThreadedCoreBase):
         if submission.params.quota_item and submission.params.submitter:
             self.log.info(f"[{sid}] Submission counts towards {submission.params.submitter.upper()} quota")
 
-        # Apply initial data parameter
-        temp_key_config = dict(self.config.submission.default_temporary_keys)
-        temp_key_config.update(self.config.submission.temporary_keys)
-        temporary_data = TemporaryFileData(sha256, config=temp_key_config)
-        task.temporary_data[sha256] = temporary_data
-        if submission.params.initial_data:
-            try:
-                for key, value in dict(json.loads(submission.params.initial_data)).items():
-                    if len(str(value)) > self.config.submission.max_temp_data_length:
-                        continue
-                    temporary_data.set_value(key, value)
-
-            except (ValueError, TypeError) as err:
-                self.log.warning(f"[{sid}] could not process initialization data: {err}")
-
         self.tasks[sid] = task
         self._submission_timeouts.set(task.sid, SUBMISSION_TOTAL_TIMEOUT, None)
 
@@ -784,7 +822,10 @@ class Dispatcher(ThreadedCoreBase):
         # Initialize ancestry chain by identifying the root file
         file_info = self.get_fileinfo(task, sha256)
         file_type = file_info.type if file_info else 'NOT_FOUND'
-        temporary_data.local_values['ancestry'] = [[dict(type=file_type, parent_relation="ROOT", sha256=sha256)]]
+
+        task.temporary_data[sha256].local_values["ancestry"] = [
+            [dict(type=file_type, parent_relation="ROOT", sha256=sha256)]
+        ]
 
         # Start the file dispatching
         task.active_files.add(sha256)
@@ -875,7 +916,6 @@ class Dispatcher(ThreadedCoreBase):
             schedule_summary = [list(stage.keys()) for stage in task.file_schedules[sha256]]
             task.trace('schedule_built', sha256=sha256, message=str(schedule_summary))
 
-
         file_info = task.file_info[sha256]
         schedule: list = list(task.file_schedules[sha256])
         deep_scan, ignore_filtering = submission.params.deep_scan, submission.params.ignore_filtering

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core/ingester/ingester.py

@@ -112,6 +112,7 @@ class IngestTask(odm.Model):
     ingest_id = odm.UUID()  # Ingestion Identifier
     ingest_time = odm.Date(default="NOW")  # Time at which the file was ingested
     notify_time = odm.Optional(odm.Date())  # Time at which the user is notify the submission is finished
+    to_ingest = odm.Boolean(default=False)
 
 
 class Ingester(ThreadedCoreBase):
@@ -250,7 +251,13 @@ class Ingester(ThreadedCoreBase):
                         submission=sub,
                         ingest_id=sub.sid,
                     ))
-                    task.submission.sid = None  # Reset to new random uuid
+
+                    # if this is a new task from imported bundle we want to use the same sid
+                    # because all the submission information are stored in the datastore
+                    # else create a new sid for this submission
+                    if "bundle.source" not in task.submission.metadata:
+                        task.submission.sid = None  # Reset to new random uuid
+
                     # Write all input to the traffic queue
                     self.traffic_queue.publish(SubmissionMessage({
                         'msg': sub,
@@ -920,10 +927,15 @@ class Ingester(ThreadedCoreBase):
         return reason
 
     def submit(self, task: IngestTask):
-        self.submit_client.submit(
-            submission_obj=task.submission,
-            completed_queue=COMPLETE_QUEUE_NAME,
-        )
+
+        if "bundle.source" in task.submission.metadata:
+            self.submit_client.send_bundle_to_dispatch(task.submission, completed_queue=COMPLETE_QUEUE_NAME)
+        else:
+
+            self.submit_client.submit(
+                submission_obj=task.submission,
+                completed_queue=COMPLETE_QUEUE_NAME,
+            )
 
         self.timeout_queue.push(int(now(_max_time)), task.submission.scan_key)
         self.log.info(f"[{task.ingest_id} :: {task.sha256}] Submitted to dispatcher for analysis")

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core/replay/client.py

@@ -297,11 +297,14 @@ class APIClient(ClientBase):
         self.al_client.bundle.create(id, output=bundle_path, use_alert=use_alert)
 
     def load_bundle(self, bundle_path, min_classification, rescan_services, exist_ok=True, reclassification=None):
-        self.al_client.bundle.import_bundle(bundle_path,
-                                            min_classification=min_classification,
-                                            rescan_services=rescan_services,
-                                            exist_ok=exist_ok,
-                                            reclassification=reclassification)
+        self.al_client.bundle.import_bundle(
+            bundle_path,
+            min_classification=min_classification,
+            rescan_services=rescan_services,
+            exist_ok=exist_ok,
+            reclassification=reclassification,
+            to_ingest=True,  # send submissions to ingester
+        )
 
     def load_json(self, file_path, reclassification=None):
         from assemblyline_client import ClientError
@@ -412,11 +415,14 @@ class DirectClient(ClientBase):
         os.rename(temp_bundle_file, bundle_path)
 
     def load_bundle(self, bundle_path, min_classification, rescan_services, exist_ok=True, reclassification=None):
-        import_bundle(bundle_path,
-                      min_classification=min_classification,
-                      rescan_services=rescan_services,
-                      exist_ok=exist_ok,
-                      reclassification=reclassification)
+        import_bundle(
+            bundle_path,
+            min_classification=min_classification,
+            rescan_services=rescan_services,
+            exist_ok=exist_ok,
+            reclassification=reclassification,
+            to_ingest=True,  # send submissions to ingester
+        )
 
     def load_json(self, file_path, reclassification=None):
         # We're assuming all JSON that loaded has an "enabled" field
@@ -442,7 +448,6 @@ class DirectClient(ClientBase):
                         else:
                             raise
 
-
                 if collection == "workflow":
                     # If there has been any edits by another user, then preserve the enabled state
                     # Otherwise, the workflow will be synchronized with the origin system

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core/scaler/controllers/kubernetes_ctl.py

@@ -14,6 +14,12 @@ from time import sleep
 from typing import List, Optional, Tuple
 
 import urllib3
+from assemblyline.odm.models.config import Selector
+from assemblyline.odm.models.service import (
+    DependencyConfig,
+    DockerConfig,
+    PersistentVolume,
+)
 from cryptography import x509
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
@@ -22,6 +28,7 @@ from kubernetes import client, config, watch
 from kubernetes.client import (
     V1Affinity,
     V1Capabilities,
+    V1ConfigMap,
     V1ConfigMapVolumeSource,
     V1Container,
     V1Deployment,
@@ -62,12 +69,6 @@ from kubernetes.client import (
 )
 from kubernetes.client.rest import ApiException
 
-from assemblyline.odm.models.config import Selector
-from assemblyline.odm.models.service import (
-    DependencyConfig,
-    DockerConfig,
-    PersistentVolume,
-)
 from assemblyline_core.scaler.controllers.interface import ControllerInterface
 
 # RESERVE_MEMORY_PER_NODE = os.environ.get('RESERVE_MEMORY_PER_NODE')
@@ -390,7 +391,7 @@ class KubernetesController(ControllerInterface):
     def _dependency_name(self, service_name: str, container_name: str):
         return f"{self._deployment_name(service_name)}-{container_name}".lower()
 
-    def add_config_mount(self, name: str, config_map: str, key: str, target_path: str, read_only=True, core=False):
+    def add_config_mount(self, name: str, config_map: str, key: Optional[str], target_path: str, read_only=True, core=False):
         volumes, mounts = self.volumes, self.mounts
         if core:
             volumes, mounts = self.core_volumes, self.core_mounts
@@ -1379,3 +1380,19 @@ class KubernetesController(ControllerInterface):
         for np in (existing_netpol - {np.metadata.name for np in network_policies}):
             self.net_api.delete_namespaced_network_policy(namespace=self.namespace, name=np,
                                                           _request_timeout=API_TIMEOUT)
+
+    def update_config_map(self, data: dict, name: str):
+        """Update or create a ConfigMap in Kubernetes."""
+        config_map = V1ConfigMap(
+            metadata=V1ObjectMeta(name=name, namespace=self.namespace),
+            data=data
+        )
+        try:
+            self.api.patch_namespaced_config_map(name=name, namespace=self.namespace, body=config_map,
+                                                 _request_timeout=API_TIMEOUT)
+        except ApiException as error:
+            if error.status == 404:
+                self.api.create_namespaced_config_map(namespace=self.namespace, body=config_map,
+                                                      _request_timeout=API_TIMEOUT)
+            else:
+                raise

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core/scaler/scaler_server.py

@@ -19,7 +19,6 @@ from typing import Any, Dict, Optional
 
 import elasticapm
 import yaml
-
 from assemblyline.common.constants import (
     SCALER_TIMEOUT_QUEUE,
     SERVICE_STATE_HASH,
@@ -44,14 +43,13 @@ from assemblyline.remote.datatypes.hash import ExpiringHash, Hash
 from assemblyline.remote.datatypes.queues.named import NamedQueue
 from assemblyline.remote.datatypes.queues.priority import PriorityQueue
 from assemblyline.remote.datatypes.queues.priority import length as pq_length
-from assemblyline_core.scaler.controllers import KubernetesController
+
+from assemblyline_core.scaler import collection
+from assemblyline_core.scaler.controllers import DockerController, KubernetesController
 from assemblyline_core.scaler.controllers.interface import ServiceControlError
 from assemblyline_core.server_base import ServiceStage, ThreadedCoreBase
 from assemblyline_core.updater.helper import get_registry_config
 
-from . import collection
-from .controllers import DockerController
-
 APM_SPAN_TYPE = 'scaler'
 
 # How often (in seconds) to download new service data, try to scale managed services,
@@ -298,6 +296,16 @@ class ScalerServer(ThreadedCoreBase):
                         # be shared with privileged services.
                         pass
 
+        # Create a configuration file specifically meant for privileged services to consume
+        # This should only contain the relevant information to connect to the databases
+        privileged_config = yaml.dump({
+            'datastore': self.config.datastore.as_primitives(),
+            'filestore': self.config.filestore.as_primitives(),
+            'core': {
+                'redis': self.config.core.redis.as_primitives()
+            }
+        })
+
         labels = {
             'app': 'assemblyline',
             'section': 'service',
@@ -340,7 +348,9 @@ class ScalerServer(ThreadedCoreBase):
                                                    )
 
             # Add global configuration for privileged services
-            self.controller.add_config_mount(KUBERNETES_AL_CONFIG, config_map=KUBERNETES_AL_CONFIG, key="config",
+            # Check if the ConfigMap already exists, if it does, update it
+            self.controller.update_config_map(data={'config': privileged_config}, name='privileged-service-config')
+            self.controller.add_config_mount(KUBERNETES_AL_CONFIG, config_map='privileged-service-config', key="config",
                                              target_path="/etc/assemblyline/config.yml", read_only=True, core=True)
 
             # If we're passed an override for server-server and it's defining an HTTPS connection, then add a global
@@ -382,7 +392,7 @@ class ScalerServer(ThreadedCoreBase):
 
                 with open(os.path.join(DOCKER_CONFIGURATION_PATH, 'config.yml'), 'w') as handle:
                     # Convert to JSON before converting to YAML to account for direct ODM representation errors
-                    yaml.dump(json.loads(self.config.json()), handle)
+                    handle.write(privileged_config)
 
                 with open(os.path.join(DOCKER_CONFIGURATION_PATH, 'classification.yml'), 'w') as handle:
                     yaml.dump(get_classification().original_definition, handle)

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core/submission_client.py

@@ -37,6 +37,8 @@ from assemblyline.odm.models.result import Result
 from assemblyline.odm.models.submission import File, Submission
 from assemblyline.odm.models.config import Config
 from assemblyline_core.dispatching.client import DispatchClient
+from assemblyline_core.ingester.constants import INGEST_QUEUE_NAME
+from assemblyline.remote.datatypes.queues.named import NamedQueue
 
 Classification = forge.get_classification()
 SECONDS_PER_DAY = 24 * 60 * 60
@@ -72,6 +74,7 @@ class SubmissionClient:
 
         # A client for interacting with the dispatcher
         self.dispatcher = DispatchClient(datastore, redis)
+        self.ingest_queue = NamedQueue(INGEST_QUEUE_NAME, redis)
 
     def __enter__(self):
         return self
@@ -84,8 +87,16 @@ class SubmissionClient:
             self.identify.stop()
 
     @elasticapm.capture_span(span_type='submission_client')
-    def rescan(self, submission: Submission, results: Dict[str, Result], file_infos: Dict[str, FileInfo],
-               file_tree, errors: List[str], rescan_services: List[str]):
+    def rescan(
+        self,
+        submission,
+        results: Dict[str, Result],
+        file_infos: Dict[str, FileInfo],
+        file_tree: dict,
+        errors: List[str],
+        rescan_services: List[str],
+        to_ingest: bool = False,
+    ):
         """
         Rescan a submission started on another system.
         """
@@ -114,8 +125,29 @@ class SubmissionClient:
         self.datastore.submission.save(submission_obj.sid, submission_obj)
 
         # Dispatch the submission
-        self.log.debug("Submission complete. Dispatching: %s", submission_obj.sid)
-        self.dispatcher.dispatch_bundle(submission_obj, results, file_infos, file_tree, errors)
+        if to_ingest:
+            self.log.debug("Submission complete. Submission sent to ingester: %s", submission_obj.sid)
+
+            submission_obj = SubmissionObject(
+                {
+                    "sid": submission["sid"],
+                    "files": submission.get("files", []),
+                    "metadata": submission.get("metadata", {}),
+                    "params": submission.get("params", {}),
+                    "notification": submission.get("notification", {}),
+                    "scan_key": submission.get("scan_key", None),
+                    "errors": errors,
+                    "file_infos": file_infos,
+                    "file_tree": file_tree,
+                    "results": results,
+                }
+            ).as_primitives()
+
+            self.ingest_queue.push(submission_obj)
+
+        else:
+            self.log.debug("Submission complete. Dispatching: %s", submission_obj.sid)
+            self.dispatcher.dispatch_bundle(submission_obj, results, file_infos, file_tree, errors)
 
         return submission
 
@@ -252,3 +284,22 @@ class SubmissionClient:
             if extracted_path:
                 if os.path.exists(extracted_path):
                     os.unlink(extracted_path)
+
+    @elasticapm.capture_span(span_type="submission_client")
+    def send_bundle_to_dispatch(
+        self,
+        submission_obj: SubmissionObject,
+        completed_queue: str = None,
+    ):
+
+        sid = submission_obj.sid
+        submission = self.datastore.submission.get(sid)
+
+        self.dispatcher.dispatch_bundle(
+            submission=submission,
+            results=submission_obj.results,
+            file_infos=submission_obj.file_infos,
+            file_tree=submission_obj.file_tree,
+            errors=submission_obj.errors,
+            completed_queue=completed_queue,
+        )

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core/tasking_client.py

@@ -3,7 +3,6 @@ import time
 from typing import Any, Dict, Optional
 
 import elasticapm
-
 from assemblyline.common import forge
 from assemblyline.common.constants import SERVICE_STATE_HASH, ServiceStatus
 from assemblyline.common.dict_utils import flatten, unflatten
@@ -22,6 +21,7 @@ from assemblyline.odm.models.service import Service
 from assemblyline.odm.models.tagging import Tagging
 from assemblyline.remote.datatypes.events import EventSender, EventWatcher
 from assemblyline.remote.datatypes.hash import ExpiringHash
+
 from assemblyline_core.dispatching.client import DispatchClient
 
 
@@ -161,9 +161,31 @@ class TaskingClient:
                 self.datastore.service_delta.save(service.name, {'version': service.version})
                 self.datastore.service_delta.commit()
                 self.log.info(f"{log_prefix}{service.name} version ({service.version}) registered")
+            else:
+                # Check for any changes that should be merged into the service delta
+                service_delta = self.datastore.service_delta.get(service.name, as_obj=False)
+
+                # Check for any new configuration keys that should be added to the service delta
+                if service_delta.get('config'):
+                    new_config = {k: v for k, v in service.config.items() if k not in service_delta['config']}
+                    if new_config:
+                        if 'config' not in service_delta:
+                            service_delta['config'] = {}
+                        service_delta['config'].update(new_config)
+
+                # Check for any new submission parameters that should be added to the service delta
+                if service_delta.get('submission_params'):
+                    old_submission_params = {param['name'] for param in service_delta['submission_params']}
+                    for param in service.submission_params:
+                        if param['name'] not in old_submission_params:
+                            # New parameter, add it to the old submission params
+                            service_delta['submission_params'].append(param.as_primitives())
+
+                # Save any changes to the service delta
+                self.datastore.service_delta.save(service.name, service_delta)
 
             new_heuristics = []
-            
+
             plan = self.datastore.heuristic.get_bulk_plan()
             for index, heuristic in enumerate(heuristics):
                 heuristic_id = f'#{index}'  # Set heuristic id to it's position in the list for logging purposes

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core/updater/helper.py

@@ -1,23 +1,21 @@
-import os
-import requests
 import re
 import socket
 import string
 import time
-
-from assemblyline.common.version import FRAMEWORK_VERSION, SYSTEM_VERSION
-from assemblyline.odm.models.config import Config as SystemConfig, ServiceRegistry
-from assemblyline.odm.models.service import Service as ServiceConfig, DockerConfig
-
 from base64 import b64encode
 from collections import defaultdict
 from logging import Logger
 from typing import Dict, List
-from packaging.version import parse, Version
 from urllib.parse import urlencode
 
+import requests
+from assemblyline.common.version import FRAMEWORK_VERSION, SYSTEM_VERSION
+from assemblyline.odm.models.config import Config as SystemConfig
+from assemblyline.odm.models.config import ServiceRegistry
+from assemblyline.odm.models.service import DockerConfig
+from assemblyline.odm.models.service import Service as ServiceConfig
 from azure.identity import DefaultAzureCredential
-
+from packaging.version import Version, parse
 
 DEFAULT_DOCKER_REGISTRY = "hub.docker.com"
 

{assemblyline_core-4.6.0.15 → assemblyline_core-4.6.0.18}/assemblyline_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: assemblyline-core
-Version: 4.6.0.15
+Version: 4.6.0.18
 Summary: Assemblyline 4 - Core components
 Home-page: https://github.com/CybercentreCanada/assemblyline-core/
 Author: CCCS Assemblyline development team