assemblyline-core 4.5.1.dev38__tar.gz → 4.5.1.dev90__tar.gz

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/PKG-INFO

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

assemblyline-core-4.5.1.dev90/assemblyline_core/VERSION

@@ -0,0 +1 @@
+4.5.1.dev90

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core/archiver/run_archiver.py

@@ -7,8 +7,8 @@ from assemblyline.common import forge
 from assemblyline.common.archiving import ARCHIVE_QUEUE_NAME
 from assemblyline.common.metrics import MetricsFactory
 from assemblyline.datastore.collection import ESCollection, Index
+from assemblyline.datastore.exceptions import VersionConflictException
 from assemblyline.odm.messages.archive_heartbeat import Metrics
-from assemblyline.odm.models.submission import Submission
 from assemblyline.remote.datatypes import get_client
 from assemblyline.remote.datatypes.queues.named import NamedQueue
 
@@ -62,7 +62,12 @@ class Archiver(ServerBase):
             return
         else:
             try:
-                archive_type, type_id, delete_after = message
+                if len(message) == 3:
+                    archive_type, type_id, delete_after = message
+                    metadata = None
+                else:
+                    archive_type, type_id, delete_after, metadata = message
+
                 self.counter.increment('received')
             except Exception:
                 self.log.error(f"Invalid message received: {message}")
@@ -76,7 +81,19 @@ class Archiver(ServerBase):
             if archive_type == "submission":
                 self.counter.increment('submission')
                 # Load submission
-                submission: Submission = self.datastore.submission.get_if_exists(type_id)
+                while True:
+                    try:
+                        submission, version = self.datastore.submission.get_if_exists(type_id, version=True)
+
+                        # If we have metadata passed in the message, we need to apply it before archiving the submission
+                        if metadata and self.config.core.archiver.use_metadata:
+                            submission.metadata.update({f"archive.{k}": v for k, v in metadata.items()})
+                            self.datastore.submission.save(type_id, submission, version=version)
+
+                        break
+                    except VersionConflictException as vce:
+                        self.log.info(f"Retrying saving metadata due to version conflict: {str(vce)}")
+
                 if not submission:
                     raise SubmissionNotFound(type_id)
 

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core/metrics/heartbeat_formatter.py

@@ -7,6 +7,7 @@ from assemblyline.common.archiving import ARCHIVE_QUEUE_NAME
 from assemblyline.common.constants import DISPATCH_TASK_HASH, SUBMISSION_QUEUE, \
     SERVICE_STATE_HASH, ServiceStatus
 from assemblyline.datastore.exceptions import SearchException
+from assemblyline.odm.messages.retrohunt_heartbeat import RetrohuntMessage
 from assemblyline.odm.messages.scaler_heartbeat import ScalerMessage
 from assemblyline.odm.messages.scaler_status_heartbeat import ScalerStatusMessage
 from assemblyline.odm.messages.alerter_heartbeat import AlerterMessage
@@ -15,6 +16,7 @@ from assemblyline.odm.messages.dispatcher_heartbeat import DispatcherMessage
 from assemblyline.odm.messages.expiry_heartbeat import ExpiryMessage
 from assemblyline.odm.messages.ingest_heartbeat import IngestMessage
 from assemblyline.odm.messages.service_heartbeat import ServiceMessage
+from assemblyline.odm.messages.elastic_heartbeat import ElasticMessage
 from assemblyline.odm.messages.vacuum_heartbeat import VacuumMessage
 from assemblyline.remote.datatypes import get_client
 from assemblyline.remote.datatypes.hash import Hash, ExpiringHash
@@ -289,5 +291,56 @@ class HeartbeatFormatter(object):
             except Exception:
                 self.log.exception("An exception occurred while generating VacuumMessage")
 
+        elif m_type == "elastic":
+            try:
+                msg = {
+                    "sender": self.sender,
+                    "msg": {
+                        "instances": instances,
+                        'unassigned_shards': m_data['unassigned'],
+                        "request_time": m_data['request_time'],
+                        "shard_sizes": [{'name': index, 'shard_size': size}
+                                        for index, size in m_data['shard_sizes'].items()],
+                    }
+                }
+                self.status_queue.publish(ElasticMessage(msg).as_primitives())
+                self.log.info(f"Sent elastic heartbeat: {msg['msg']}")
+            except Exception:
+                self.log.exception("An exception occurred while generating ElasticMessage")
+
+        elif m_type == "retrohunt":
+            try:
+
+                status = m_data.get('status', {})
+                fetcher = status.get('fetcher', {})
+                resources = status.get('resources', {})
+                storage = status.get('storage', {})
+                last_minute_cpu = sum(report.get('cpu_load_1m', 0) for report in resources.values())
+                memory = sum(report.get('memory', 0) for report in resources.values())
+                free_storage = [report.get('high_water', 0) for report in storage.values()]
+                min_storage = sum_storage = 0
+                if free_storage:
+                    min_storage = min(free_storage)
+                    sum_storage = sum(free_storage)
+
+                msg = {
+                    "sender": self.sender,
+                    "msg": {
+                        'instances': instances,
+                        'request_time': m_data['request_time'],
+                        'pending_files': fetcher.get('pending_files', 0),
+                        'ingested_last_minute': fetcher.get('last_minute_throughput', 0),
+                        'worker_storage_available': min_storage,
+                        'total_storage_available': sum_storage,
+                        'active_searches': status.get('active_searches', 0),
+                        'last_minute_cpu': last_minute_cpu,
+                        'total_memory_used': memory,
+                    }
+                }
+                self.status_queue.publish(RetrohuntMessage(msg).as_primitives())
+                self.log.info(f"Sent retrohunt heartbeat: {msg['msg']}")
+            except Exception:
+                self.log.exception("An exception occurred while generating RetrohuntMessage")
+
         else:
             self.log.warning(f"Skipping unknown counter: {m_name} [{m_type}] ==> {m_data}")

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core/metrics/metrics_server.py

@@ -3,6 +3,7 @@
 import tempfile
 import sys
 import time
+import threading
 from collections import Counter
 from threading import Lock, Thread
 from os import environ, path
@@ -259,6 +260,7 @@ class HeartbeatManager(ServerBase):
         self.metrics_queue = CommsQueue(METRICS_QUEUE)
         self.scheduler = BackgroundScheduler(daemon=True)
         self.hm = HeartbeatFormatter("heartbeat_manager", self.log, config=self.config)
+        self.hauntedhouse_client = forge.get_hauntedhouse_client(self.config)
 
         self.counters_lock = Lock()
         self.counters = {}
@@ -281,6 +283,10 @@ class HeartbeatManager(ServerBase):
         self.scheduler.add_job(self._export_hearbeats, 'interval', seconds=self.config.core.metrics.export_interval)
         self.scheduler.start()
 
+        threading.Thread(target=self._call_interval, args=('es_shards', self._fetch_shards), daemon=True).start()
+        if self.config.retrohunt.enabled:
+            threading.Thread(target=self._call_interval, args=('retrohunt', self._fetch_retrohunt), daemon=True).start()
+
         while self.running:
             for msg in self.metrics_queue.listen():
                 # APM Transaction start
@@ -316,6 +322,70 @@ class HeartbeatManager(ServerBase):
                 if self.apm_client:
                     self.apm_client.end_transaction('process_message', 'success')
 
+    def _call_interval(self, name, method):
+        while self.running:
+            # Run the heartbeat
+            send_time = time.time()
+            try:
+                method()
+            except Exception:
+                self.log.exception('Error running metric fetcher %s', name)
+
+            # Wait until we are inline with the heartbeat interval
+            elapsed = time.time() - send_time
+            remaining = self.config.core.metrics.export_interval - elapsed
+            if remaining > 0:
+                self.sleep(remaining)
+
+    def _fetch_shards(self):
+        request_time = None
+        sizes = {}
+        unassigned = 0
+        nodes = set()
+        try:
+            # Pull shard data from elastisearch
+            start_time = time.time()
+            response = self.datastore.ds.client.cat.shards(bytes='b', format='json', master_timeout='5s')
+            for shard in response.body:
+                index = shard['index']
+                node = shard['node']
+                if node:
+                    sizes.setdefault(index, 0)
+                    sizes[index] = max(sizes[index], int(shard.get('store') or 0))
+                    nodes.add(node)
+                else:
+                    unassigned += 1
+            request_time = time.time() - start_time
+
+        finally:
+            # Export metrics heartbeat, send None and empty if an error occurs while getting the data
+            # the error will be logged in the outer function
+            metrics = {
+                'shard_sizes': sizes,
+                'request_time': request_time,
+                'unassigned': unassigned
+            }
+            self.hm.send_heartbeat('elastic', 'datastore', metrics, len(nodes))
+
+    def _fetch_retrohunt(self):
+        status = {}
+        request_time = None
+        try:
+            # Pull status message from retrohunt
+            start_time = time.time()
+            status = self.hauntedhouse_client.status()
+            request_time = time.time() - start_time
+
+        finally:
+            metrics = {
+                'request_time': request_time,
+                'status': status,
+            }
+            instances = len(status.get('storage', {}))
+
+            # Export heartbeat
+            self.hm.send_heartbeat('retrohunt', 'hauntedhouse', metrics, instances)
+
     def _export_hearbeats(self):
         try:
             self.heartbeat()

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core/scaler/controllers/docker_ctl.py

@@ -121,7 +121,10 @@ class DockerController(ControllerInterface):
                                                  aliases=['service-server'])
 
                 # As long as the current service server is still running, just block its exit code in this thread
-                self.service_server.wait()
+                try:
+                    self.service_server.wait()
+                except docker.errors.NotFound:
+                    pass
 
                 # If it does return, find the new service server
                 self.service_server = self.find_service_server()
@@ -158,6 +161,14 @@ class DockerController(ControllerInterface):
             if 'already exists' in str(e):
                 return
             raise e
+        except docker.errors.NotFound as e:
+            if aliases == ['service-server']:
+                # We've lost our service-server container, time to find another
+                self.service_server = self.find_service_server()
+                network.connect(self.service_server, aliases=aliases)
+                return
+            raise e
+
 
     def _start(self, service_name):
         """Launch a docker container in a manner suitable for Assemblyline."""

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core/scaler/controllers/kubernetes_ctl.py

@@ -21,7 +21,7 @@ from assemblyline.odm.models.config import Selector
 
 from kubernetes import client, config, watch
 from kubernetes.client import V1Deployment, V1DeploymentSpec, V1PodTemplateSpec, V1DeploymentStrategy, \
-    V1PodSpec, V1PodOS, V1ObjectMeta, V1Volume, V1Container, V1VolumeMount, V1EnvVar, V1ConfigMapVolumeSource, \
+    V1PodSpec, V1ObjectMeta, V1Volume, V1Container, V1VolumeMount, V1EnvVar, V1ConfigMapVolumeSource, \
     V1PersistentVolumeClaimVolumeSource, V1LabelSelector, V1ResourceRequirements, V1PersistentVolumeClaim, \
     V1PersistentVolumeClaimSpec, V1NetworkPolicy, V1NetworkPolicySpec, V1NetworkPolicyEgressRule, V1NetworkPolicyPeer, \
     V1NetworkPolicyIngressRule, V1Secret, V1SecretVolumeSource, V1LocalObjectReference, V1Service, \
@@ -839,25 +839,14 @@ class KubernetesController(ControllerInterface):
                 volume_mounts=chown_mounts
             ))
 
-        pod_os = None
-        security_context = V1PodSecurityContext(fs_group=1000)
-        if docker_config.operating_system:
-            #  Allow Kubernetes to schedule the pod to a compatible node
-            pod_os = V1PodOS(name=docker_config.operating_system)
-
-        if docker_config.operating_system == 'windows':
-            security_context = None
-
-
         pod = V1PodSpec(
             init_containers=init_containers,
             volumes=all_volumes,
             containers=self._create_containers(service_name, deployment_name, docker_config,
                                                all_mounts, core_container=core_mounts),
-            os=pod_os,
             priority_class_name=self.dependency_priority if high_priority else self.priority,
             termination_grace_period_seconds=shutdown_seconds,
-            security_context=security_context,
+            security_context=V1PodSecurityContext(fs_group=1000),
             service_account_name=service_account,
             affinity=selector_to_node_affinity(self.linux_node_selector),
         )

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core/updater/helper.py

@@ -12,114 +12,95 @@ from base64 import b64encode
 from collections import defaultdict
 from logging import Logger
 from packaging.version import parse, Version
-from typing import Any, Dict, List, Tuple
 
 DEFAULT_DOCKER_REGISTRY = "registry.hub.docker.com"
 
 
 class ContainerRegistry():
-    def __init__(self, server, headers: Dict[str, str] = None, verify: bool = True,
-                 proxies: Dict[str, str] = None, *args, **kwargs):
-        self.server = server
-        self.session = requests.Session()
-        self.session.headers = headers
-        self.session.verify = verify
-        self.session.proxies = proxies
-
-    def _make_request(self, path: str) -> Dict[str, Any]:
-        request_path = f"{self.server}{path}"
-        resp = None
-        try:
-            resp = self.session.get(f"https://{request_path}")
-        except requests.exceptions.SSLError:
-            # Connect to insecure registry over HTTP (development only)
-            if not self.session.verify:
-                resp = self.session.get(f"http://{request_path}")
-        # Test for valid response
-        if resp and resp.ok:
-            return resp.json()
-        return None
-
     # Provide a means of obtaining a list of tags from a container registry
-    def get_image_tags(self, image_name) -> List[str]:
-        raise NotImplementedError()
-
-    # Provide a means of obtaining the compatible operating system for the container image
-    def get_image_os(self, image_name, image_tag) -> str:
+    def _get_proprietary_registry_tags(self, server, image_name, auth, verify, proxies=None, token_server=None):
         raise NotImplementedError()
 
 
-class DockerHub(ContainerRegistry):
-    def __init__(self, update_channel, proxies: Dict[str, str] = None, *args, **kwargs):
-        super().__init__(DEFAULT_DOCKER_REGISTRY, None, True, proxies)
-        self.update_channel = update_channel
-
-    def get_image_tags(self, image_name) -> List[str]:
-        resp = self._make_request(f"/v2/repositories/{image_name}/tags?page_size=5&page=1&name={self.update_channel}")
-        if resp:
-            return [x['name'] for x in resp['results']]
-        return []
-
-    def get_image_os(self, image_name, image_tag) -> str:
-        resp = self._make_request(f"/v2/repositories/{image_name}/tags/{image_tag}")
-        if resp:
-            return resp['images'][0]['os']
-        return None
-
-
-# Ref: https://docs.docker.com/registry/spec/api/#detail
 class DockerRegistry(ContainerRegistry):
-    def get_image_tags(self, image_name) -> List[str]:
+    def _get_proprietary_registry_tags(self, server, image_name, auth, verify, proxies=None, token_server=None):
         # Find latest tag for each types
-        resp = self._make_request(f"/v2/{image_name}/tags/list")
-        if resp:
-            return resp['tags'] or []
-        return []
+        url = f"https://{server}/v2/{image_name}/tags/list"
 
-    def get_image_os(self, image_name, image_tag) -> str:
-        resp = self._make_request(f"/v2/{image_name}/manifests/{image_tag}")
-        if resp:
-            # Retrieve OS compatibilty from historical record
-            return json.loads(resp['history'][0]['v1Compatibility'])['os']
+        # Get tag list
+        headers = {}
+        if auth:
+            headers["Authorization"] = auth
+        else:
+            # Retrieve token for authentication: https://distribution.github.io/distribution/spec/auth/token/
 
-        # Unable to determine the OS compatibility
-        return None
+            # Assume the token server is the same as the container image registry host if not explicitly set
+            token_server = token_server if token_server else server
+            token_url = f"https://{token_server}/token?scope=repository:{image_name}:pull"
+            resp = requests.get(token_url)
+            if resp.ok:
+                # Request to obtain token was successful, set Authorization header for registry API
+                token = resp.json().get('token')
+                headers["Authorization"] = f"Bearer {token}"
 
+        resp = None
+        try:
+            resp = requests.get(url, headers=headers, verify=verify, proxies=proxies)
+        except requests.exceptions.SSLError:
+            # Connect to insecure registry over HTTP (development only)
+            if not verify:
+                url = f"http://{server}/v2/{image_name}/tags/list"
+                resp = requests.get(url, headers=headers, verify=verify, proxies=proxies)
+        # Test for valid response
+        if resp and resp.ok:
+            # Test for positive list of tags
+            resp_data = resp.json()
+            return resp_data['tags'] or []
+        return []
 
-# Ref: https://github.com/goharbor/harbor/blob/main/api/v2.0/swagger.yaml
 class HarborRegistry(ContainerRegistry):
-    def _get_project_repo_ids(self, image_name) -> Tuple[str, str]:
+    def _get_proprietary_registry_tags(self, server, image_name, auth, verify, proxies=None, token_server=None):
         # Determine project/repo IDs from image name
         project_id, repo_id = image_name.split('/', 1)
         repo_id = repo_id.replace('/', "%2F")
-        return project_id, repo_id
+        url = f"https://{server}/api/v2.0/projects/{project_id}/repositories/{repo_id}/artifacts?page_size=0"
 
-    def get_image_tags(self, image_name) -> List[str]:
-        project_id, repo_id = self._get_project_repo_ids(image_name)
-        resp = self._make_request(f"/api/v2.0/projects/{project_id}/repositories/{repo_id}/artifacts?page_size=0")
-        if resp:
-            return [tag['name'] for image in resp if image['tags'] for tag in image['tags']]
-        return []
-
-    def get_image_os(self, image_name, image_tag) -> str:
-        project_id, repo_id = self._get_project_repo_ids(image_name)
-        resp = self._make_request(f"/api/v2.0/projects/{project_id}/repositories/{repo_id}/artifacts/{image_tag}")
-        if resp:
-            # Retrieve OS compatibilty from reference
-            return resp['references'][0]['platform']['os']
+        headers = {}
+        if auth:
+            headers["Authorization"] = auth
+        else:
+            # Retrieve token for authentication: https://github.com/goharbor/harbor/wiki/Harbor-FAQs#api
+
+            # Assume the token server is the same as the container image registry host if not explicitly set
+            token_server = token_server if token_server else server
+            token_url = f"https://{server}/service/token?scope=repository:{image_name}:pull"
+            resp = requests.get(token_url)
+            if resp.ok:
+                # Request to obtain token was successful, set Authorization header for registry API
+                token = resp.json().get('token')
+                headers["Authorization"] = f"Bearer {token}"
+        resp = None
+        try:
+            resp = requests.get(url, headers=headers, verify=verify, proxies=proxies)
+        except requests.exceptions.SSLError:
+            # Connect to insecure registry over HTTP (development only)
+            if not verify:
+                url = f"http://{server}/api/v2.0/projects/{project_id}/repositories/{repo_id}/artifacts"
+                resp = requests.get(url, headers=headers, verify=verify, proxies=proxies)
 
-        # Unable to determine the OS compatibility
-        return None
+        if resp and resp.ok:
+            return [tag['name'] for image in resp.json() if image['tags'] for tag in image['tags']]
+        return []
 
 
 REGISTRY_TYPE_MAPPING = {
-    'dockerhub': DockerHub,
-    'docker': DockerRegistry,
-    'harbor': HarborRegistry
+    'docker': DockerRegistry(),
+    'harbor': HarborRegistry()
 }
 
 
-def get_latest_tag_for_service(service_config: ServiceConfig, system_config: SystemConfig, logger: Logger, prefix: str = ""):
+def get_latest_tag_for_service(
+        service_config: ServiceConfig, system_config: SystemConfig, logger: Logger, prefix: str = ""):
     def process_image(image):
         # Find which server to search in
         server = image.split("/")[0]
@@ -180,25 +161,23 @@ def get_latest_tag_for_service(service_config: ServiceConfig, system_config: Sys
         # We're assuming that if only a password is given, then this is a token
         auth = f"Bearer {service_config.docker_config.registry_password}"
 
+    registry = REGISTRY_TYPE_MAPPING[service_config.docker_config.registry_type]
+    token_server = None
     proxies = None
     for reg_conf in system_config.core.updater.registry_configs:
         if reg_conf.name == server:
             proxies = reg_conf.proxies or None
+            token_server = reg_conf.token_server or None
             break
 
-    registry_type = 'dockerhub' if server == DEFAULT_DOCKER_REGISTRY else service_config.docker_config.registry_type
-    registry_args = {
-        'server': server,
-        'headers': {'Authorization': auth},
-        'verify': not system_config.services.allow_insecure_registry,
-        'proxies': proxies,
-        'update_channel': update_channel
-    }
-
-    registry: ContainerRegistry = REGISTRY_TYPE_MAPPING[registry_type](**registry_args)
-    tags = registry.get_image_tags(image_name)
-
+    if server == DEFAULT_DOCKER_REGISTRY:
+        tags = _get_dockerhub_tags(image_name, update_channel, proxies)
+    else:
+        tags = registry._get_proprietary_registry_tags(server, image_name, auth,
+                                                       not system_config.services.allow_insecure_registry,
+                                                       proxies, token_server)
     tag_name = None
+
     # Pre-filter tags to only consider 'compatible' tags relative to the running system
     tags = [t for t in tags
             if re.match(f"({FRAMEWORK_VERSION})[.]({SYSTEM_VERSION})[.]\\d+[.]({update_channel})\\d+", t)]
@@ -222,10 +201,28 @@ def get_latest_tag_for_service(service_config: ServiceConfig, system_config: Sys
     image_variables = defaultdict(str)
     image_variables.update(system_config.services.image_variables)
     image = string.Template(image).safe_substitute(image_variables)
-    os = registry.get_image_os(image_name, tag_name)
+    server, image_name = process_image(image)
 
     # Append server to image if not the default server
-    if server != DEFAULT_DOCKER_REGISTRY:
+    if server != "registry.hub.docker.com":
         image_name = "/".join([server, image_name])
 
-    return image_name, tag_name, auth_config, os
+    return image_name, tag_name, auth_config
+
+
+# Default for obtaining tags from DockerHub
+def _get_dockerhub_tags(image_name, update_channel, proxies=None):
+    # Find latest tag for each types
+    url = f"https://{DEFAULT_DOCKER_REGISTRY}/v2/repositories/{image_name}/tags" \
+        f"?page_size=5&page=1&name={update_channel}"
+
+    # Get tag list
+    resp = requests.get(url, proxies=proxies)
+
+    # Test for valid response
+    if resp.ok:
+        # Test for positive list of tags
+        resp_data = resp.json()
+        return [x['name'] for x in resp_data['results']]
+
+    return []

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core/updater/run_updater.py

@@ -476,10 +476,10 @@ class ServiceUpdater(ThreadedCoreBase):
                          'version': tag,
                          'docker_config': {'image': install_data.get('image')}})
 
-                    image_name, tag_name, auth, os = get_latest_tag_for_service(
+                    image_name, tag_name, auth = get_latest_tag_for_service(
                         service,  self.config, self.log, prefix="[CI] ")
 
-                    docker_config = dict(image=f"{image_name}:{tag_name}", operating_system=os)
+                    docker_config = dict(image=f"{image_name}:{tag_name}")
                     if auth:
                         docker_config.update(dict(registry_username=auth['username'],
                                                   registry_password=auth['password']))
@@ -675,7 +675,7 @@ class ServiceUpdater(ThreadedCoreBase):
 
             for service in self.datastore.list_all_services(full=True):
                 discovered_services.append(service.name)
-                image_name, tag_name, auth, _ = get_latest_tag_for_service(service, self.config, self.log, prefix="[CV] ")
+                image_name, tag_name, auth = get_latest_tag_for_service(service, self.config, self.log, prefix="[CV] ")
                 self.latest_service_tags.set(service.name,
                                              {'auth': auth, 'image': image_name, service.update_channel: tag_name})
 

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core/vacuum/worker.py

@@ -270,6 +270,7 @@ class FileProcessor(threading.Thread):
         # Remove UI specific params
         settings.pop('default_zip_password', None)
         settings.pop('download_encoding', None)
+        settings.pop('executive_summary', None)
         settings.pop('expand_min_score', None)
         settings.pop('submission_view', None)
         settings.pop('ui4', None)

{assemblyline-core-4.5.1.dev38 → assemblyline-core-4.5.1.dev90}/assemblyline_core.egg-info/PKG-INFO

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

assemblyline-core-4.5.1.dev38/assemblyline_core/VERSION

@@ -1 +0,0 @@
-4.5.1.dev38