Version bump to v1.15.0

Store worker statistics under worker id and not internal redis key
Fix unit tests

apiserver/apierrors/errors.conf

@@ -27,7 +27,7 @@
     24: ["not_public_object", "object is not public"]
 
     # Auth / Login
-    75: ["invalid_access_key", "access key not found for user"]
+    75: ["invalid_access_key", "access key not found"]
 
     # Tasks
     100: ["task_error", "general task error"]
@@ -50,6 +50,12 @@
     130: ["task_not_found", "task not found"]
     131: ["events_not_added", "events not added"]
 
+    # Reports
+    150: ["operation_supported_on_reports_only", "passed task is not report"]
+
+    # Pipelines
+    160: ["cannot_remove_all_runs", "at least one pipeline run should be left"]
+
     # Models
     200: ["model_error", "general task error"]
     201: ["invalid_model_id", "invalid model id"]
@@ -70,12 +76,14 @@
     402: ["project_has_tasks", "project has associated tasks"]
     403: ["project_not_found", "project not found"]
     405: ["project_has_models", "project has associated models"]
+    406: ["project_has_datasets", "project has associated non-empty datasets"]
     407: ["invalid_project_name", "invalid project name"]
     408: ["cannot_update_project_location", "Cannot update project location. Use projects.move instead"]
     409: ["project_path_exceeds_max", "Project path exceed the maximum allowed depth"]
     410: ["project_source_and_destination_are_the_same", "Project has the same source and destination paths"]
     411: ["project_cannot_be_moved_under_itself", "Project can not be moved under itself in the projects hierarchy"]
     412: ["project_cannot_be_merged_into_its_child", "Project can not be merged into its own child"]
+    413: ["project_has_pipelines", "project has associated pipelines with active controllers"]
 
     # Queues
     701: ["invalid_queue_id", "invalid queue id"]

apiserver/apimodels/__init__.py

@@ -61,6 +61,13 @@ class ListField(fields.ListField):
             item.validate()
 
 
+class ScalarField(fields.BaseField):
+
+    """String field."""
+
+    types = (str, int, float, bool)
+
+
 class DictField(fields.BaseField):
     types = (dict,)
 

apiserver/apimodels/events.py

@@ -13,6 +13,14 @@ from apiserver.config_repo import config
 from apiserver.utilities.stringenum import StringEnum
 
 
+class TaskRequest(Base):
+    task: str = StringField(required=True)
+
+
+class ModelRequest(Base):
+    model: str = StringField(required=True)
+
+
 class HistogramRequestBase(Base):
     samples: int = IntField(default=2000, validators=[Min(1), Max(6000)])
     key: ScalarKeyEnum = ActualEnumField(ScalarKeyEnum, default=ScalarKeyEnum.iter)
@@ -29,6 +37,11 @@ class ScalarMetricsIterHistogramRequest(HistogramRequestBase):
     model_events: bool = BoolField(default=False)
 
 
+class GetMetricsAndVariantsRequest(Base):
+    task: str = StringField(required=True)
+    model_events: bool = BoolField(default=False)
+
+
 class MultiTaskScalarMetricsIterHistogramRequest(HistogramRequestBase):
     tasks: Sequence[str] = ListField(
         items_types=str,
@@ -36,11 +49,12 @@ class MultiTaskScalarMetricsIterHistogramRequest(HistogramRequestBase):
             Length(
                 minimum_value=1,
                 maximum_value=config.get(
-                    "services.tasks.multi_task_histogram_limit", 10
+                    "services.tasks.multi_task_histogram_limit", 100
                 ),
             )
         ],
     )
+    metrics: Sequence[MetricVariants] = ListField(items_types=MetricVariants)
     model_events: bool = BoolField(default=False)
 
 
@@ -50,6 +64,12 @@ class TaskMetric(Base):
     variants: Sequence[str] = ListField(items_types=str)
 
 
+class LegacyMetricEventsRequest(TaskRequest):
+    iters: int = IntField(default=1, validators=validators.Min(1))
+    scroll_id: str = StringField()
+    model_events: bool = BoolField(default=False)
+
+
 class MetricEventsRequest(Base):
     metrics: Sequence[TaskMetric] = ListField(
         items_types=TaskMetric, validators=[Length(minimum_value=1)]
@@ -58,7 +78,14 @@ class MetricEventsRequest(Base):
     navigate_earlier: bool = BoolField(default=True)
     refresh: bool = BoolField(default=False)
     scroll_id: str = StringField()
-    model_events: bool = BoolField()
+    model_events: bool = BoolField(default=False)
+
+
+class VectorMetricsIterHistogramRequest(Base):
+    task: str = StringField(required=True)
+    metric: str = StringField(required=True)
+    variant: str = StringField(required=True)
+    model_events: bool = BoolField(default=False)
 
 
 class GetVariantSampleRequest(Base):
@@ -109,6 +136,11 @@ class TaskEventsRequest(TaskEventsRequestBase):
     model_events: bool = BoolField(default=False)
 
 
+class LegacyLogEventsRequest(TaskEventsRequestBase):
+    order: Optional[str] = ActualEnumField(LogOrderEnum, default=LogOrderEnum.desc)
+    scroll_id: str = StringField()
+
+
 class LogEventsRequest(TaskEventsRequestBase):
     batch_size: int = IntField(default=5000)
     navigate_earlier: bool = BoolField(default=True)
@@ -148,13 +180,30 @@ class MultiTasksRequestBase(Base):
 
 
 class SingleValueMetricsRequest(MultiTasksRequestBase):
-    pass
+    metrics: Sequence[MetricVariants] = ListField(items_types=MetricVariants)
 
 
 class TaskMetricsRequest(MultiTasksRequestBase):
     event_type: EventType = ActualEnumField(EventType, required=True)
 
 
+class MultiTaskMetricsRequest(MultiTasksRequestBase):
+    event_type: EventType = ActualEnumField(EventType, default=EventType.all)
+
+
+class LegacyMultiTaskEventsRequest(MultiTasksRequestBase):
+    iters: int = IntField(default=1, validators=validators.Min(1))
+    scroll_id: str = StringField()
+
+
+class MultiTaskPlotsRequest(MultiTasksRequestBase):
+    iters: int = IntField(default=1)
+    scroll_id: str = StringField()
+    no_scroll: bool = BoolField(default=False)
+    last_iters_per_task_metric: bool = BoolField(default=True)
+    metrics: Sequence[MetricVariants] = ListField(items_types=MetricVariants)
+
+
 class TaskPlotsRequest(Base):
     task: str = StringField(required=True)
     iters: int = IntField(default=1)
@@ -164,6 +213,14 @@ class TaskPlotsRequest(Base):
     model_events: bool = BoolField(default=False)
 
 
+class GetScalarMetricDataRequest(Base):
+    task: str = StringField(required=True)
+    metric: str = StringField(required=True)
+    scroll_id: str = StringField()
+    no_scroll: bool = BoolField(default=False)
+    model_events: bool = BoolField(default=False)
+
+
 class ClearScrollRequest(Base):
     scroll_id: str = StringField()
 

apiserver/apimodels/login.py

@@ -5,8 +5,9 @@ from apiserver.apimodels import DictField, callable_default
 
 
 class GetSupportedModesRequest(Base):
-    state = StringField(help_text="ASCII base64 encoded application state")
-    callback_url_prefix = StringField()
+    pass
+    # state = StringField(help_text="ASCII base64 encoded application state")
+    # callback_url_prefix = StringField()
 
 
 class BasicGuestMode(Base):

apiserver/apimodels/models.py

@@ -42,12 +42,29 @@ class ModelRequest(models.Base):
     model = fields.StringField(required=True)
 
 
+class TaskRequest(models.Base):
+    task = fields.StringField(required=True)
+
+
+class UpdateForTaskRequest(TaskRequest):
+    uri = fields.StringField()
+    iteration = fields.IntField()
+    override_model_id = fields.StringField()
+
+
+class UpdateModelRequest(ModelRequest):
+    task = fields.StringField()
+    iteration = fields.IntField()
+
+
 class DeleteModelRequest(ModelRequest):
     force = fields.BoolField(default=False)
+    delete_external_artifacts = fields.BoolField(default=True)
 
 
 class ModelsDeleteManyRequest(BatchRequest):
     force = fields.BoolField(default=False)
+    delete_external_artifacts = fields.BoolField(default=True)
 
 
 class PublishModelRequest(ModelRequest):
@@ -79,3 +96,4 @@ class AddOrUpdateMetadataRequest(AddOrUpdateMetadata):
 
 class ModelsGetRequest(models.Base):
     include_stats = fields.BoolField(default=False)
+    allow_public = fields.BoolField(default=True)

apiserver/apimodels/organization.py

@@ -1,6 +1,11 @@
-from jsonmodels import fields, models
+from enum import auto
+from typing import Sequence
 
-from apiserver.apimodels import DictField
+from jsonmodels import fields, models
+from jsonmodels.validators import Length
+
+from apiserver.apimodels import DictField, ActualEnumField, ScalarField
+from apiserver.utilities.stringenum import StringEnum
 
 
 class Filter(models.Base):
@@ -19,5 +24,39 @@ class EntitiesCountRequest(models.Base):
     models = DictField()
     pipelines = DictField()
     datasets = DictField()
+    reports = DictField()
     active_users = fields.ListField(str)
     search_hidden = fields.BoolField(default=False)
+    allow_public = fields.BoolField(default=True)
+
+
+class EntityType(StringEnum):
+    task = auto()
+    model = auto()
+
+
+class ValueMapping(models.Base):
+    key = ScalarField(nullable=True)
+    value = ScalarField(nullable=True)
+
+
+class FieldMapping(models.Base):
+    field = fields.StringField(required=True)
+    name = fields.StringField()
+    values: Sequence[ValueMapping] = fields.ListField(items_types=[ValueMapping])
+
+
+class PrepareDownloadForGetAllRequest(models.Base):
+    entity_type = ActualEnumField(EntityType)
+    allow_public = fields.BoolField(default=True)
+    search_hidden = fields.BoolField(default=False)
+    only_fields = fields.ListField(
+        items_types=[str], validators=[Length(1)], required=True
+    )
+    field_mappings: Sequence[FieldMapping] = fields.ListField(
+        items_types=[FieldMapping], validators=[Length(1)], required=True
+    )
+
+
+class DownloadForGetAllRequest(models.Base):
+    prepare_id = fields.StringField(required=True)

apiserver/apimodels/pipelines.py

@@ -1,4 +1,5 @@
 from jsonmodels import models, fields
+from jsonmodels.validators import Length
 
 from apiserver.apimodels import ListField
 
@@ -8,12 +9,13 @@ class Arg(models.Base):
     value = fields.StringField(required=True)
 
 
+class DeleteRunsRequest(models.Base):
+    project = fields.StringField(required=True)
+    ids = ListField([str], required=True, validators=[Length(1)])
+
+
 class StartPipelineRequest(models.Base):
     task = fields.StringField(required=True)
     queue = fields.StringField(required=True)
     args = ListField(Arg)
-
-
-class StartPipelineResponse(models.Base):
-    pipeline = fields.StringField(required=True)
-    enqueued = fields.BoolField(required=True)
+    verify_watched_queue = fields.BoolField(default=False)

apiserver/apimodels/projects.py

@@ -1,8 +1,11 @@
+from enum import Enum, auto
+
 from jsonmodels import models, fields
 
 from apiserver.apimodels import ListField, ActualEnumField, DictField
 from apiserver.apimodels.organization import TagsRequest
 from apiserver.database.model import EntityVisibility
+from apiserver.utilities.stringenum import StringEnum
 
 
 class ProjectRequest(models.Base):
@@ -20,6 +23,7 @@ class MoveRequest(ProjectRequest):
 class DeleteRequest(ProjectRequest):
     force = fields.BoolField(default=False)
     delete_contents = fields.BoolField(default=False)
+    delete_external_artifacts = fields.BoolField(default=True)
 
 
 class ProjectOrNoneRequest(models.Base):
@@ -27,6 +31,11 @@ class ProjectOrNoneRequest(models.Base):
     include_subprojects = fields.BoolField(default=True)
 
 
+class GetUniqueMetricsRequest(ProjectOrNoneRequest):
+    model_metrics = fields.BoolField(default=False)
+    ids = fields.ListField(str)
+
+
 class GetParamsRequest(ProjectOrNoneRequest):
     page = fields.IntField(default=0)
     page_size = fields.IntField(default=500)
@@ -37,23 +46,44 @@ class ProjectTagsRequest(TagsRequest):
 
 
 class MultiProjectRequest(models.Base):
-    projects = fields.ListField(str)
+    projects = fields.ListField(items_types=[str, type(None)])
     include_subprojects = fields.BoolField(default=True)
 
 
 class ProjectTaskParentsRequest(MultiProjectRequest):
     tasks_state = ActualEnumField(EntityVisibility)
+    task_name = fields.StringField()
 
 
-class ProjectHyperparamValuesRequest(MultiProjectRequest):
+class EntityTypeEnum(StringEnum):
+    task = auto()
+    model = auto()
+
+
+class ProjectUserNamesRequest(MultiProjectRequest):
+    entity = ActualEnumField(EntityTypeEnum, default=EntityTypeEnum.task)
+
+
+class MultiProjectPagedRequest(MultiProjectRequest):
+    allow_public = fields.BoolField(default=True)
+    page = fields.IntField(default=0)
+    page_size = fields.IntField(default=500)
+
+
+class ProjectHyperparamValuesRequest(MultiProjectPagedRequest):
     section = fields.StringField(required=True)
     name = fields.StringField(required=True)
-    allow_public = fields.BoolField(default=True)
+    pattern = fields.StringField()
 
 
-class ProjectModelMetadataValuesRequest(MultiProjectRequest):
+class ProjectModelMetadataValuesRequest(MultiProjectPagedRequest):
     key = fields.StringField(required=True)
-    allow_public = fields.BoolField(default=True)
+
+
+class ProjectChildrenType(Enum):
+    pipeline = "pipeline"
+    report = "report"
+    dataset = "dataset"
 
 
 class ProjectsGetRequest(models.Base):
@@ -62,8 +92,12 @@ class ProjectsGetRequest(models.Base):
     include_stats_filter = DictField()
     stats_with_children = fields.BoolField(default=True)
     stats_for_state = ActualEnumField(EntityVisibility, default=EntityVisibility.active)
-    non_public = fields.BoolField(default=False)
+    non_public = fields.BoolField(default=False)  # legacy, use allow_public instead
     active_users = fields.ListField(str)
     check_own_contents = fields.BoolField(default=False)
     shallow_search = fields.BoolField(default=False)
     search_hidden = fields.BoolField(default=False)
+    allow_public = fields.BoolField(default=True)
+    children_type = ActualEnumField(ProjectChildrenType)
+    children_tags = fields.ListField(str)
+    children_tags_filter = DictField()

apiserver/apimodels/reports.py

@@ -0,0 +1,84 @@
+from typing import Sequence
+
+from jsonmodels import validators
+from jsonmodels.fields import StringField, ListField, BoolField, EmbeddedField, IntField
+from jsonmodels.models import Base
+from jsonmodels.validators import Length
+
+from apiserver.apimodels.events import MetricVariants, HistogramRequestBase
+
+
+class UpdateReportRequest(Base):
+    task = StringField(required=True)
+    name = StringField(nullable=True, validators=Length(minimum_value=3))
+    tags = ListField(items_types=[str])
+    comment = StringField()
+    report = StringField()
+    report_assets = ListField(items_types=[str])
+
+
+class CreateReportRequest(Base):
+    name = StringField(required=True, validators=Length(minimum_value=3))
+    tags = ListField(items_types=[str])
+    comment = StringField()
+    report = StringField()
+    project = StringField()
+    report_assets = ListField(items_types=[str])
+
+
+class PublishReportRequest(Base):
+    task = StringField(required=True)
+    message = StringField(default="")
+
+
+class ArchiveReportRequest(Base):
+    task = StringField(required=True)
+    message = StringField(default="")
+
+
+class ShareReportRequest(Base):
+    task = StringField(required=True)
+    share = BoolField(default=True)
+
+
+class DeleteReportRequest(Base):
+    task = StringField(required=True)
+    force = BoolField(default=False)
+
+
+class MoveReportRequest(Base):
+    task = StringField(required=True)
+    project = StringField()
+    project_name = StringField()
+
+
+class EventsRequest(Base):
+    iters = IntField(default=1, validators=validators.Min(1))
+    metrics: Sequence[MetricVariants] = ListField(items_types=MetricVariants)
+
+
+class PlotEventsRequest(EventsRequest):
+    last_iters_per_task_metric: bool = BoolField(default=True)
+
+
+class ScalarMetricsIterHistogram(HistogramRequestBase):
+    metrics: Sequence[MetricVariants] = ListField(items_types=MetricVariants)
+
+
+class SingleValueMetrics(Base):
+    pass
+
+
+class GetTasksDataRequest(Base):
+    debug_images: EventsRequest = EmbeddedField(EventsRequest)
+    plots: PlotEventsRequest = EmbeddedField(PlotEventsRequest)
+    scalar_metrics_iter_histogram: ScalarMetricsIterHistogram = EmbeddedField(
+        ScalarMetricsIterHistogram
+    )
+    single_value_metrics: SingleValueMetrics = EmbeddedField(SingleValueMetrics)
+    allow_public = BoolField(default=True)
+    model_events: bool = BoolField(default=False)
+
+
+class GetAllRequest(Base):
+    allow_public = BoolField(default=True)

apiserver/apimodels/server.py

@@ -6,6 +6,10 @@ class ReportStatsOptionRequest(Base):
     enabled = BoolField(default=None, nullable=True)
 
 
+class GetConfigRequest(Base):
+    path = StringField()
+
+
 class ReportStatsOptionResponse(Base):
     supported = BoolField(default=True)
     enabled = BoolField()

apiserver/apimodels/tasks.py

@@ -96,6 +96,11 @@ class UpdateRequest(TaskUpdateRequest):
     status_message = StringField(default="")
 
 
+class DequeueRequest(UpdateRequest):
+    remove_from_all_queues = BoolField(default=False)
+    new_status = StringField()
+
+
 class EnqueueRequest(UpdateRequest):
     queue = StringField()
     queue_name = StringField()
@@ -274,6 +279,11 @@ class StopManyRequest(TaskBatchRequest):
     force = BoolField(default=False)
 
 
+class DequeueManyRequest(TaskBatchRequest):
+    remove_from_all_queues = BoolField(default=False)
+    new_status = StringField()
+
+
 class EnqueueManyRequest(TaskBatchRequest):
     queue = StringField()
     queue_name = StringField()
@@ -318,3 +328,13 @@ class DeleteModelsRequest(TaskRequest):
     models: Sequence[ModelItemKey] = ListField(
         [ModelItemKey], validators=Length(minimum_value=1)
     )
+
+
+class GetAllReq(models.Base):
+    allow_public = BoolField(default=True)
+    search_hidden = BoolField(default=False)
+
+
+class UpdateTagsRequest(BatchRequest):
+    add_tags = ListField([str])
+    remove_tags = ListField([str])

apiserver/apimodels/users.py

@@ -4,6 +4,10 @@ from jsonmodels.models import Base
 from apiserver.apimodels import DictField
 
 
+class UserRequest(Base):
+    user = StringField(required=True)
+
+
 class CreateRequest(Base):
     id = StringField(required=True)
     name = StringField(required=True)

apiserver/apimodels/workers.py

@@ -12,9 +12,8 @@ from jsonmodels.fields import (
 )
 from jsonmodels.models import Base
 
-from apiserver.apimodels import make_default, ListField, EnumField, JsonSerializableMixin
-
-DEFAULT_TIMEOUT = 10 * 60
+from apiserver.apimodels import ListField, EnumField, JsonSerializableMixin
+from apiserver.config_repo import config
 
 
 class WorkerRequest(Base):
@@ -24,9 +23,10 @@ class WorkerRequest(Base):
 
 
 class RegisterRequest(WorkerRequest):
-    timeout = make_default(
-        IntField, DEFAULT_TIMEOUT
-    )()  # registration timeout in seconds (default is 10min)
+    timeout = IntField(
+        default=int(config.get("services.workers.default_worker_timeout_sec", 10 * 60))
+    )
+    """ registration timeout in seconds (default is 10min) """
     queues = ListField(six.string_types)  # list of queues this worker listens to
 
 
@@ -106,6 +106,10 @@ class GetAllResponse(Base):
     workers = ListField(WorkerResponseEntry)
 
 
+class GetCountRequest(GetAllRequest):
+    last_seen = IntField(default=0)
+
+
 class StatsBase(Base):
     worker_ids = ListField(str)
 

apiserver/bll/event/event_common.py

@@ -8,7 +8,8 @@ from elasticsearch import Elasticsearch
 
 from apiserver.config_repo import config
 from apiserver.database.errors import translate_errors_context
-from apiserver.tools import safe_get
+from apiserver.database.model.task.task import Task
+from apiserver.utilities.dicts import nested_get
 
 
 class EventType(Enum):
@@ -22,6 +23,7 @@ class EventType(Enum):
 
 SINGLE_SCALAR_ITERATION = -(2 ** 31)
 MetricVariants = Mapping[str, Sequence[str]]
+TaskCompanies = Mapping[str, Sequence[Task]]
 
 
 class EventSettings:
@@ -52,14 +54,17 @@ class EventSettings:
         return int(self._max_es_allowed_aggregation_buckets * percentage)
 
 
-def get_index_name(company_id: str, event_type: str):
+def get_index_name(company_id: Union[str, Sequence[str]], event_type: str):
     event_type = event_type.lower().replace(" ", "_")
-    return f"events-{event_type}-{company_id.lower()}"
+    if isinstance(company_id, str):
+        company_id = [company_id]
+
+    return ",".join(f"events-{event_type}-{(c_id or '').lower()}" for c_id in company_id)
 
 
 def check_empty_data(es: Elasticsearch, company_id: str, event_type: EventType) -> bool:
     es_index = get_index_name(company_id, event_type.value)
-    if not es.indices.exists(es_index):
+    if not es.indices.exists(index=es_index):
         return True
     return False
 
@@ -118,8 +123,8 @@ def get_max_metric_and_variant_counts(
             es, company_id=company_id, event_type=event_type, body=es_req, **kwargs,
         )
 
-    metrics_count = safe_get(
-        es_res, "aggregations/metrics_count/value", max_metrics_count
+    metrics_count = nested_get(
+        es_res, ("aggregations", "metrics_count", "value"), max_metrics_count
     )
     if not metrics_count:
         return max_metrics_count, max_variants_count

apiserver/bll/event/event_metrics.py

@@ -18,12 +18,13 @@ from apiserver.bll.event.event_common import (
     get_metric_variants_condition,
     get_max_metric_and_variant_counts,
     SINGLE_SCALAR_ITERATION,
+    TaskCompanies,
 )
 from apiserver.bll.event.scalar_key import ScalarKey, ScalarKeyEnum
+from apiserver.bll.query import Builder as QueryBuilder
 from apiserver.config_repo import config
 from apiserver.database.errors import translate_errors_context
-from apiserver.database.model.task.task import Task
-from apiserver.tools import safe_get
+from apiserver.utilities.dicts import nested_get
 
 log = config.logger(__file__)
 
@@ -108,37 +109,51 @@ class EventMetrics:
 
     def compare_scalar_metrics_average_per_iter(
         self,
-        company_id,
-        tasks: Sequence[Task],
+        companies: TaskCompanies,
         samples,
         key: ScalarKeyEnum,
+        metric_variants: MetricVariants = None,
     ):
         """
         Compare scalar metrics for different tasks per metric and variant
         The amount of points in each histogram should not exceed the requested samples
         """
         event_type = EventType.metrics_scalar
-        if check_empty_data(self.es, company_id=company_id, event_type=event_type):
+        companies = {
+            company_id: tasks
+            for company_id, tasks in companies.items()
+            if not check_empty_data(
+                self.es, company_id=company_id, event_type=event_type
+            )
+        }
+        if not companies:
             return {}
 
-        task_name_by_id = {t.id: t.name for t in tasks}
         get_scalar_average_per_iter = partial(
             self._get_scalar_average_per_iter_core,
-            company_id=company_id,
             event_type=event_type,
             samples=samples,
             key=ScalarKey.resolve(key),
+            metric_variants=metric_variants,
             run_parallel=False,
         )
-        task_ids = [t.id for t in tasks]
+        task_ids, company_ids = zip(
+            *(
+                (t.id, t.company)
+                for t in itertools.chain.from_iterable(companies.values())
+            )
+        )
         with ThreadPoolExecutor(max_workers=EventSettings.max_workers) as pool:
             task_metrics = zip(
-                task_ids, pool.map(get_scalar_average_per_iter, task_ids)
+                task_ids, pool.map(get_scalar_average_per_iter, task_ids, company_ids)
             )
 
+        task_names = {
+            t.id: t.name for t in itertools.chain.from_iterable(companies.values())
+        }
         res = defaultdict(lambda: defaultdict(dict))
         for task_id, task_data in task_metrics:
-            task_name = task_name_by_id[task_id]
+            task_name = task_names[task_id]
             for metric_key, metric_data in task_data.items():
                 for variant_key, variant_data in metric_data.items():
                     variant_data["name"] = task_name
@@ -147,18 +162,35 @@ class EventMetrics:
         return res
 
     def get_task_single_value_metrics(
-        self, company_id: str, tasks: Sequence[Task]
+        self,
+        companies: TaskCompanies,
+        metric_variants: MetricVariants = None,
     ) -> Mapping[str, dict]:
         """
         For the requested tasks return all the events delivered for the single iteration (-2**31)
         """
-        if check_empty_data(
-            self.es, company_id=company_id, event_type=EventType.metrics_scalar
-        ):
+        companies = {
+            company_id: [t.id for t in tasks]
+            for company_id, tasks in companies.items()
+            if not check_empty_data(
+                self.es, company_id=company_id, event_type=EventType.metrics_scalar
+            )
+        }
+        if not companies:
             return {}
 
-        task_ids = [t.id for t in tasks]
-        task_events = self._get_task_single_value_metrics(company_id, task_ids)
+        with ThreadPoolExecutor(max_workers=EventSettings.max_workers) as pool:
+            task_events = list(
+                itertools.chain.from_iterable(
+                    pool.map(
+                        partial(
+                            self._get_task_single_value_metrics,
+                            metric_variants=metric_variants,
+                        ),
+                        companies.items(),
+                    )
+                ),
+            )
 
         def _get_value(event: dict):
             return {
@@ -172,18 +204,19 @@ class EventMetrics:
         }
 
     def _get_task_single_value_metrics(
-        self, company_id: str, task_ids: Sequence[str]
+        self, tasks: Tuple[str, Sequence[str]], metric_variants: MetricVariants = None
     ) -> Sequence[dict]:
+        company_id, task_ids = tasks
+        must = [
+            {"terms": {"task": task_ids}},
+            {"term": {"iter": SINGLE_SCALAR_ITERATION}},
+        ]
+        if metric_variants:
+            must.append(get_metric_variants_condition(metric_variants))
+
         es_req = {
             "size": 10000,
-            "query": {
-                "bool": {
-                    "must": [
-                        {"terms": {"task": task_ids}},
-                        {"term": {"iter": SINGLE_SCALAR_ITERATION}},
-                    ]
-                }
-            },
+            "query": {"bool": {"must": must}},
         }
         with translate_errors_context():
             es_res = search_company_events(
@@ -256,7 +289,8 @@ class EventMetrics:
         query = {"bool": {"must": must}}
         search_args = dict(es=self.es, company_id=company_id, event_type=event_type)
         max_metrics, max_variants = get_max_metric_and_variant_counts(
-            query=query, **search_args,
+            query=query,
+            **search_args,
         )
         max_variants = int(max_variants // 2)
         es_req = {
@@ -308,12 +342,12 @@ class EventMetrics:
         total amount of intervals does not exceeds the samples
         Return the interval and resulting amount of intervals
         """
-        count = safe_get(data, "count/value", default=0)
+        count = nested_get(data, ("count", "value"), default=0)
         if count < samples:
             return metric, variant, 1, count
 
-        min_index = safe_get(data, "min_index/value", default=0)
-        max_index = safe_get(data, "max_index/value", default=min_index)
+        min_index = nested_get(data, ("min_index", "value"), default=0)
+        max_index = nested_get(data, ("max_index", "value"), default=min_index)
         index_range = max_index - min_index + 1
         interval = max(1, math.ceil(float(index_range) / samples))
         max_samples = math.ceil(float(index_range) / interval)
@@ -342,7 +376,8 @@ class EventMetrics:
         query = self._get_task_metrics_query(task_id=task_id, metrics=metrics)
         search_args = dict(es=self.es, company_id=company_id, event_type=event_type)
         max_metrics, max_variants = get_max_metric_and_variant_counts(
-            query=query, **search_args,
+            query=query,
+            **search_args,
         )
         max_variants = int(max_variants // 2)
         es_req = {
@@ -408,7 +443,9 @@ class EventMetrics:
 
     @classmethod
     def _get_task_metrics_query(
-        cls, task_id: str, metrics: Sequence[Tuple[str, str]],
+        cls,
+        task_id: str,
+        metrics: Sequence[Tuple[str, str]],
     ):
         must = cls._task_conditions(task_id)
         if metrics:
@@ -427,12 +464,96 @@ class EventMetrics:
 
         return {"bool": {"must": must}}
 
+    def get_multi_task_metrics(self, companies: TaskCompanies, event_type: EventType) -> Mapping[str, list]:
+        """
+        For the requested tasks return reported metrics and variants
+        """
+        tasks_ids = {
+            company: [t.id for t in tasks]
+            for company, tasks in companies.items()
+        }
+        with ThreadPoolExecutor(EventSettings.max_workers) as pool:
+            companies_res: Sequence = list(
+                pool.map(
+                    partial(
+                        self._get_multi_task_metrics,
+                        event_type=event_type,
+                    ),
+                    tasks_ids.items(),
+                )
+            )
+
+        if len(companies_res) == 1:
+            return companies_res[0]
+
+        res = defaultdict(set)
+        for c_res in companies_res:
+            for m, vars_ in c_res.items():
+                res[m].update(vars_)
+
+        return {
+            k: list(v)
+            for k, v in res.items()
+        }
+
+    def _get_multi_task_metrics(
+        self, company_tasks: Tuple[str, Sequence[str]], event_type: EventType
+    ) -> Mapping[str, list]:
+        company_id, task_ids = company_tasks
+        if check_empty_data(self.es, company_id, event_type):
+            return {}
+
+        search_args = dict(
+            es=self.es,
+            company_id=company_id,
+            event_type=event_type,
+        )
+        query = QueryBuilder.terms("task", task_ids)
+        max_metrics, max_variants = get_max_metric_and_variant_counts(
+            query=query,
+            **search_args,
+        )
+        es_req = {
+            "size": 0,
+            "query": query,
+            "aggs": {
+                "metrics": {
+                    "terms": {
+                        "field": "metric",
+                        "size": max_metrics,
+                        "order": {"_key": "asc"},
+                    },
+                    "aggs": {
+                        "variants": {
+                            "terms": {
+                                "field": "variant",
+                                "size": max_variants,
+                                "order": {"_key": "asc"},
+                            },
+                        }
+                    }
+                }
+            },
+        }
+
+        es_res = search_company_events(
+            body=es_req,
+            **search_args,
+        )
+        aggs_result = es_res.get("aggregations")
+        if not aggs_result:
+            return {}
+
+        return {
+            mb["key"]: [vb["key"] for vb in mb["variants"]["buckets"]]
+            for mb in aggs_result["metrics"]["buckets"]
+        }
+
     def get_task_metrics(
         self, company_id, task_ids: Sequence, event_type: EventType
     ) -> Sequence:
         """
-        For the requested tasks return all the metrics that
-        reported events of the requested types
+        For the requested tasks return reported metrics per task
         """
         if check_empty_data(self.es, company_id, event_type):
             return {}
@@ -471,5 +592,5 @@ class EventMetrics:
 
         return [
             metric["key"]
-            for metric in safe_get(es_res, "aggregations/metrics/buckets", default=[])
+            for metric in nested_get(es_res, ("aggregations", "metrics", "buckets"), default=[])
         ]

apiserver/bll/event/events_iterator.py

@@ -64,13 +64,13 @@ class EventsIterator:
         self,
         event_type: EventType,
         company_id: str,
-        task_id: str,
+        task_ids: Sequence[str],
         metric_variants: MetricVariants = None,
     ) -> int:
         if check_empty_data(self.es, company_id, event_type):
             return 0
 
-        query, _ = self._get_initial_query_and_must(task_id, metric_variants)
+        query, _ = self._get_initial_query_and_must(task_ids, metric_variants)
         es_req = {
             "query": query,
         }
@@ -100,7 +100,7 @@ class EventsIterator:
         For the last key-field value all the events are brought (even if the resulting size exceeds batch_size)
         so that events with this value will not be lost between the calls.
         """
-        query, must = self._get_initial_query_and_must(task_id, metric_variants)
+        query, must = self._get_initial_query_and_must([task_id], metric_variants)
 
         # retrieve the next batch of events
         es_req = {
@@ -158,14 +158,14 @@ class EventsIterator:
 
     @staticmethod
     def _get_initial_query_and_must(
-        task_id: str, metric_variants: MetricVariants = None
+        task_ids: Sequence[str], metric_variants: MetricVariants = None
     ) -> Tuple[dict, list]:
         if not metric_variants:
-            must = [{"term": {"task": task_id}}]
-            query = {"term": {"task": task_id}}
+            query = {"terms": {"task": task_ids}}
+            must = [query]
         else:
             must = [
-                {"term": {"task": task_id}},
+                {"terms": {"task": task_ids}},
                 get_metric_variants_condition(metric_variants),
             ]
             query = {"bool": {"must": must}}

apiserver/bll/event/metric_events_iterator.py

@@ -6,7 +6,6 @@ from operator import itemgetter
 from typing import Sequence, Tuple, Optional, Mapping, Callable
 
 import attr
-import dpath
 from boltons.iterutils import first
 from elasticsearch import Elasticsearch
 from jsonmodels.fields import StringField, ListField, IntField
@@ -27,6 +26,7 @@ from apiserver.config_repo import config
 from apiserver.database.errors import translate_errors_context
 from apiserver.database.model.task.metrics import MetricEventStats
 from apiserver.database.model.task.task import Task
+from apiserver.utilities.dicts import nested_get
 
 
 class VariantState(Base):
@@ -75,18 +75,25 @@ class MetricEventsIterator:
 
     def get_task_events(
         self,
-        company_id: str,
+        companies: Mapping[str, str],
         task_metrics: Mapping[str, dict],
         iter_count: int,
         navigate_earlier: bool = True,
         refresh: bool = False,
         state_id: str = None,
     ) -> MetricEventsResult:
-        if check_empty_data(self.es, company_id, self.event_type):
+        companies = {
+            task_id: company_id
+            for task_id, company_id in companies.items()
+            if not check_empty_data(
+                self.es, company_id=company_id, event_type=self.event_type
+            )
+        }
+        if not companies:
             return MetricEventsResult()
 
         def init_state(state_: MetricEventsScrollState):
-            state_.tasks = self._init_task_states(company_id, task_metrics)
+            state_.tasks = self._init_task_states(companies, task_metrics)
 
         def validate_state(state_: MetricEventsScrollState):
             """
@@ -95,7 +102,7 @@ class MetricEventsIterator:
             Refresh the state if requested
             """
             if refresh:
-                self._reinit_outdated_task_states(company_id, state_, task_metrics)
+                self._reinit_outdated_task_states(companies, state_, task_metrics)
 
         with self.cache_manager.get_or_create_state(
             state_id=state_id, init_state=init_state, validate_state=validate_state
@@ -112,7 +119,7 @@ class MetricEventsIterator:
                     pool.map(
                         partial(
                             self._get_task_metric_events,
-                            company_id=company_id,
+                            companies=companies,
                             iter_count=iter_count,
                             navigate_earlier=navigate_earlier,
                             specific_variants_requested=specific_variants_requested,
@@ -125,7 +132,7 @@ class MetricEventsIterator:
 
     def _reinit_outdated_task_states(
         self,
-        company_id,
+        companies: Mapping[str, str],
         state: MetricEventsScrollState,
         task_metrics: Mapping[str, dict],
     ):
@@ -133,9 +140,7 @@ class MetricEventsIterator:
         Determine the metrics for which new event_type events were added
         since their states were initialized and re-init these states
         """
-        tasks = Task.objects(id__in=list(task_metrics), company=company_id).only(
-            "id", "metric_stats"
-        )
+        tasks = Task.objects(id__in=list(task_metrics)).only("id", "metric_stats")
 
         def get_last_update_times_for_task_metrics(
             task: Task,
@@ -175,7 +180,7 @@ class MetricEventsIterator:
             if metrics_to_recalc:
                 task_metrics_to_recalc[task] = metrics_to_recalc
 
-        updated_task_states = self._init_task_states(company_id, task_metrics_to_recalc)
+        updated_task_states = self._init_task_states(companies, task_metrics_to_recalc)
 
         def merge_with_updated_task_states(
             old_state: TaskScrollState, updates: Sequence[TaskScrollState]
@@ -205,14 +210,14 @@ class MetricEventsIterator:
         ]
 
     def _init_task_states(
-        self, company_id: str, task_metrics: Mapping[str, dict]
+        self, companies: Mapping[str, str], task_metrics: Mapping[str, dict]
     ) -> Sequence[TaskScrollState]:
         """
         Returned initialized metric scroll stated for the requested task metrics
         """
         with ThreadPoolExecutor(EventSettings.max_workers) as pool:
             task_metric_states = pool.map(
-                partial(self._init_metric_states_for_task, company_id=company_id),
+                partial(self._init_metric_states_for_task, companies=companies),
                 task_metrics.items(),
             )
 
@@ -232,13 +237,14 @@ class MetricEventsIterator:
         pass
 
     def _init_metric_states_for_task(
-        self, task_metrics: Tuple[str, dict], company_id: str
+        self, task_metrics: Tuple[str, dict], companies: Mapping[str, str]
     ) -> Sequence[MetricState]:
         """
         Return metric scroll states for the task filled with the variant states
         for the variants that reported any event_type events
         """
         task, metrics = task_metrics
+        company_id = companies[task]
         must = [{"term": {"task": task}}, *self._get_extra_conditions()]
         if metrics:
             must.append(get_metric_variants_condition(metrics))
@@ -299,13 +305,13 @@ class MetricEventsIterator:
         return [
             MetricState(
                 metric=metric["key"],
-                timestamp=dpath.get(metric, "last_event_timestamp/value"),
+                timestamp=nested_get(metric, ("last_event_timestamp", "value")),
                 variants=[
                     init_variant_state(variant)
-                    for variant in dpath.get(metric, "variants/buckets")
+                    for variant in nested_get(metric, ("variants", "buckets"))
                 ],
             )
-            for metric in dpath.get(es_res, "aggregations/metrics/buckets")
+            for metric in nested_get(es_res, ("aggregations", "metrics", "buckets"))
         ]
 
     @abc.abstractmethod
@@ -319,7 +325,7 @@ class MetricEventsIterator:
     def _get_task_metric_events(
         self,
         task_state: TaskScrollState,
-        company_id: str,
+        companies: Mapping[str, str],
         iter_count: int,
         navigate_earlier: bool,
         specific_variants_requested: bool,
@@ -391,7 +397,10 @@ class MetricEventsIterator:
         }
         with translate_errors_context():
             es_res = search_company_events(
-                self.es, company_id=company_id, event_type=self.event_type, body=es_req,
+                self.es,
+                company_id=companies[task_state.task],
+                event_type=self.event_type,
+                body=es_req,
             )
         if "aggregations" not in es_res:
             return task_state.task, []
@@ -421,14 +430,14 @@ class MetricEventsIterator:
         def get_iteration_events(it_: dict) -> Sequence:
             return [
                 self._process_event(ev["_source"])
-                for m in dpath.get(it_, "metrics/buckets")
-                for v in dpath.get(m, "variants/buckets")
-                for ev in dpath.get(v, "events/hits/hits")
+                for m in nested_get(it_, ("metrics", "buckets"))
+                for v in nested_get(m, ("variants", "buckets"))
+                for ev in nested_get(v, ("events", "hits", "hits"))
                 if is_valid_event(ev["_source"])
             ]
 
         iterations = []
-        for it in dpath.get(es_res, "aggregations/iters/buckets"):
+        for it in nested_get(es_res, ("aggregations", "iters", "buckets")):
             events = get_iteration_events(it)
             if events:
                 iterations.append({"iter": it["key"], "events": events})

apiserver/bll/model/__init__.py

@@ -5,14 +5,18 @@ from mongoengine import Q
 
 from apiserver.apierrors import errors
 from apiserver.apimodels.models import ModelTaskPublishResponse
-from apiserver.bll.task.utils import deleted_prefix
+from apiserver.bll.task.utils import deleted_prefix, get_last_metric_updates
+from apiserver.config_repo import config
 from apiserver.database.model import EntityVisibility
 from apiserver.database.model.model import Model
 from apiserver.database.model.task.task import Task, TaskStatus
+from apiserver.service_repo.auth import Identity
 from .metadata import Metadata
 
 
 class ModelBLL:
+    event_bll = None
+
     @classmethod
     def get_company_model_by_id(
         cls, company_id: str, model_id: str, only_fields=None
@@ -28,11 +32,7 @@ class ModelBLL:
 
     @staticmethod
     def assert_exists(
-        company_id,
-        model_ids,
-        only=None,
-        allow_public=False,
-        return_models=True,
+        company_id, model_ids, only=None, allow_public=False, return_models=True,
     ) -> Optional[Sequence[Model]]:
         model_ids = [model_ids] if isinstance(model_ids, str) else model_ids
         ids = set(model_ids)
@@ -58,13 +58,15 @@ class ModelBLL:
         cls,
         model_id: str,
         company_id: str,
+        identity: Identity,
         force_publish_task: bool = False,
-        publish_task_func: Callable[[str, str, bool], dict] = None,
+        publish_task_func: Callable[[str, str, Identity, bool], dict] = None,
     ) -> Tuple[int, ModelTaskPublishResponse]:
         model = cls.get_company_model_by_id(company_id=company_id, model_id=model_id)
         if model.ready:
             raise errors.bad_request.ModelIsReady(company=company_id, model=model_id)
 
+        user_id = identity.user
         published_task = None
         if model.task and publish_task_func:
             task = (
@@ -74,18 +76,25 @@ class ModelBLL:
             )
             if task and task.status != TaskStatus.published:
                 task_publish_res = publish_task_func(
-                    model.task, company_id, force_publish_task
+                    model.task, company_id, identity, force_publish_task
                 )
                 published_task = ModelTaskPublishResponse(
                     id=model.task, data=task_publish_res
                 )
 
-        updated = model.update(upsert=False, ready=True, last_update=datetime.utcnow())
+        now = datetime.utcnow()
+        updated = model.update(
+            upsert=False,
+            ready=True,
+            last_update=now,
+            last_change=now,
+            last_changed_by=user_id,
+        )
         return updated, published_task
 
     @classmethod
     def delete_model(
-        cls, model_id: str, company_id: str, force: bool
+        cls, model_id: str, company_id: str, user_id: str, force: bool, delete_external_artifacts: bool = True,
     ) -> Tuple[int, Model]:
         model = cls.get_company_model_by_id(
             company_id=company_id,
@@ -111,49 +120,88 @@ class ModelBLL:
 
         if model.task:
             task = Task.objects(id=model.task).first()
-            if task and task.status == TaskStatus.published:
-                if not force:
-                    raise errors.bad_request.ModelCreatingTaskExists(
-                        "and published, use force=True to delete", task=model.task
-                    )
-                if task.models.output and model_id in task.models.output:
-                    now = datetime.utcnow()
+            if task:
+                now = datetime.utcnow()
+                if task.status == TaskStatus.published:
+                    if not force:
+                        raise errors.bad_request.ModelCreatingTaskExists(
+                            "and published, use force=True to delete", task=model.task
+                        )
                     Task._get_collection().update_one(
                         filter={"_id": model.task, "models.output.model": model_id},
                         update={
                             "$set": {
                                 "models.output.$[elem].model": deleted_model_id,
                                 "output.error": f"model deleted on {now.isoformat()}",
+                                "last_change": now,
+                                "last_changed_by": user_id,
                             },
-                            "last_change": now,
                         },
                         array_filters=[{"elem.model": model_id}],
                         upsert=False,
                     )
+                else:
+                    task.update(
+                        pull__models__output__model=model_id,
+                        set__last_change=now,
+                        set__last_changed_by=user_id,
+                    )
 
+        delete_external_artifacts = delete_external_artifacts and config.get(
+            "services.async_urls_delete.enabled", True
+        )
+        if delete_external_artifacts:
+            from apiserver.bll.task.task_cleanup import (
+                collect_debug_image_urls,
+                collect_plot_image_urls,
+                _schedule_for_delete,
+            )
+            urls = set()
+            urls.update(collect_debug_image_urls(company_id, model_id))
+            urls.update(collect_plot_image_urls(company_id, model_id))
+            if model.uri:
+                urls.add(model.uri)
+            if urls:
+                _schedule_for_delete(
+                    task_id=model_id,
+                    company=company_id,
+                    user=user_id,
+                    urls=urls,
+                    can_delete_folders=False,
+                )
+
+        if not cls.event_bll:
+            from apiserver.bll.event import EventBLL
+            cls.event_bll = EventBLL()
+
+        cls.event_bll.delete_task_events(company_id, model_id, allow_locked=True, model=True)
         del_count = Model.objects(id=model_id, company=company_id).delete()
         return del_count, model
 
     @classmethod
-    def archive_model(cls, model_id: str, company_id: str):
+    def archive_model(cls, model_id: str, company_id: str, user_id: str):
         cls.get_company_model_by_id(
             company_id=company_id, model_id=model_id, only_fields=("id",)
         )
+        now = datetime.utcnow()
         archived = Model.objects(company=company_id, id=model_id).update(
             add_to_set__system_tags=EntityVisibility.archived.value,
-            last_update=datetime.utcnow(),
+            last_change=now,
+            last_changed_by=user_id,
         )
 
         return archived
 
     @classmethod
-    def unarchive_model(cls, model_id: str, company_id: str):
+    def unarchive_model(cls, model_id: str, company_id: str, user_id: str):
         cls.get_company_model_by_id(
             company_id=company_id, model_id=model_id, only_fields=("id",)
         )
+        now = datetime.utcnow()
         unarchived = Model.objects(company=company_id, id=model_id).update(
             pull__system_tags=EntityVisibility.archived.value,
-            last_update=datetime.utcnow(),
+            last_change=now,
+            last_changed_by=user_id,
         )
 
         return unarchived
@@ -178,12 +226,43 @@ class ModelBLL:
                         "labels_count": {"$size": {"$objectToArray": "$labels"}}
                     }
                 },
-                {
-                    "$project": {"labels_count": 1},
-                },
+                {"$project": {"labels_count": 1}},
             ]
         )
-        return {
-            r.pop("_id"): r
-            for r in result
+        return {r.pop("_id"): r for r in result}
+
+    @staticmethod
+    def update_statistics(
+        company_id: str,
+        user_id: str,
+        model_id: str,
+        last_update: datetime = None,
+        last_iteration_max: int = None,
+        last_scalar_events: Dict[str, Dict[str, dict]] = None,
+    ):
+        last_update = last_update or datetime.utcnow()
+        updates = {
+            "last_update": datetime.utcnow(),
+            "last_change": last_update,
+            "last_changed_by": user_id,
         }
+        if last_iteration_max is not None:
+            updates.update(max__last_iteration=last_iteration_max)
+
+        raw_updates = {}
+        if last_scalar_events is not None:
+            raw_updates = {}
+            if last_scalar_events is not None:
+                get_last_metric_updates(
+                    task_id=model_id,
+                    last_scalar_events=last_scalar_events,
+                    raw_updates=raw_updates,
+                    extra_updates=updates,
+                    model_events=True,
+                )
+
+        ret = Model.objects(id=model_id).update_one(**updates)
+        if ret and raw_updates:
+            Model.objects(id=model_id).update_one(__raw__=[{"$set": raw_updates}])
+
+        return ret

apiserver/bll/model/metadata.py

@@ -5,7 +5,6 @@ from mongoengine import Document
 from apiserver.apierrors import errors
 from apiserver.apimodels.metadata import MetadataItem
 from apiserver.database.model.base import GetMixin
-from apiserver.service_repo import APICall
 from apiserver.utilities.parameter_key_escaper import (
     ParameterKeyEscaper,
     mongoengine_safe,
@@ -87,13 +86,13 @@ class Metadata:
         return paths
 
     @classmethod
-    def escape_query_parameters(cls, call: APICall) -> dict:
-        if not call.data:
-            return call.data
+    def escape_query_parameters(cls, call_data: dict) -> dict:
+        if not call_data:
+            return call_data
 
-        keys = list(call.data)
+        keys = list(call_data)
         call_data = {
-            safe_key: call.data[key]
+            safe_key: call_data[key]
             for key, safe_key in zip(keys, Metadata.escape_paths(keys))
         }
 

apiserver/bll/organization/__init__.py

@@ -1,8 +1,11 @@
 from collections import defaultdict
 from enum import Enum
-from typing import Sequence, Dict
+from typing import Sequence, Dict, Type
 
+from apiserver.apierrors import errors
+from apiserver.bll.util import update_project_time
 from apiserver.config_repo import config
+from apiserver.database.model.model import AttributedDocument
 from apiserver.database.model.model import Model
 from apiserver.database.model.task.task import Task
 from apiserver.redis_manager import redman
@@ -22,6 +25,51 @@ class OrgBLL:
         self._task_tags = _TagsCache(Task, self.redis)
         self._model_tags = _TagsCache(Model, self.redis)
 
+    def edit_entity_tags(
+        self,
+        company_id,
+        entity_cls: Type[AttributedDocument],
+        entity_ids: Sequence[str],
+        add_tags: Sequence[str],
+        remove_tags: Sequence[str],
+    ) -> int:
+        if entity_cls not in (Task, Model):
+            raise errors.bad_request.ValidationError(
+                "Tags editing can be called on tasks or models only"
+            )
+        if not entity_ids:
+            raise errors.bad_request.ValidationError(
+                "No entity ids provided for editing tags"
+            )
+        if not (add_tags or remove_tags):
+            raise errors.bad_request.ValidationError(
+                "Either add tags or remove tags should be provided"
+            )
+
+        updated = 0
+        if add_tags:
+            updated += entity_cls.objects(company=company_id, id__in=entity_ids).update(
+                add_to_set__tags=add_tags
+            )
+        if remove_tags:
+            updated += entity_cls.objects(company=company_id, id__in=entity_ids).update(
+                pull_all__tags=remove_tags
+            )
+        if not updated:
+            return 0
+
+        projects = entity_cls.objects(company=company_id, id__in=entity_ids).distinct(
+            "project"
+        )
+        update_project_time(project_ids=projects)
+        self.update_tags(
+            company_id,
+            entity=Tags.Task if entity_cls is Task else Tags.Model,
+            projects=projects,
+            tags=add_tags or remove_tags
+        )
+        return updated
+
     def get_tags(
         self,
         company_id: str,
@@ -50,10 +98,10 @@ class OrgBLL:
         return ret
 
     def update_tags(
-        self, company_id: str, entity: Tags, project: str, tags=None, system_tags=None,
+        self, company_id: str, entity: Tags, projects: Sequence[str], tags=None, system_tags=None,
     ):
         tags_cache = self._get_tags_cache_for_entity(entity)
-        tags_cache.update_tags(company_id, project, tags, system_tags)
+        tags_cache.update_tags(company_id, projects, tags, system_tags)
 
     def reset_tags(self, company_id: str, entity: Tags, projects: Sequence[str]):
         tags_cache = self._get_tags_cache_for_entity(entity)

apiserver/bll/organization/tags_cache.py

@@ -107,7 +107,7 @@ class _TagsCache:
 
         return ret
 
-    def update_tags(self, company_id: str, project: str, tags=None, system_tags=None):
+    def update_tags(self, company_id: str, projects: Sequence[str], tags=None, system_tags=None):
         """
         Updates tags. If reset is set then both tags and system_tags
         are recalculated. Otherwise only those that are not 'None'
@@ -123,7 +123,7 @@ class _TagsCache:
         if not fields:
             return
 
-        self._delete_redis_keys(company_id, projects=[project], fields=fields)
+        self._delete_redis_keys(company_id, projects=projects, fields=fields)
 
     def reset_tags(self, company_id: str, projects: Sequence[str]):
         self._delete_redis_keys(

apiserver/bll/project/project_bll.py

@@ -1,8 +1,7 @@
-import itertools
 from collections import defaultdict
 from datetime import datetime, timedelta
 from functools import reduce
-from itertools import groupby
+from itertools import groupby, chain
 from operator import itemgetter
 from typing import (
     Sequence,
@@ -15,15 +14,16 @@ from typing import (
     Callable,
     Mapping,
     Any,
+    Union,
 )
 
-from boltons.iterutils import partition
 from mongoengine import Q, Document
 
 from apiserver import database
 from apiserver.apierrors import errors
+from apiserver.apimodels.projects import ProjectChildrenType
 from apiserver.config_repo import config
-from apiserver.database.model import EntityVisibility, AttributedDocument
+from apiserver.database.model import EntityVisibility, AttributedDocument, User
 from apiserver.database.model.base import GetMixin
 from apiserver.database.model.model import Model
 from apiserver.database.model.project import Project
@@ -40,16 +40,25 @@ from .sub_projects import (
     _ids_with_children,
     _ids_with_parents,
     _get_project_depth,
+    ProjectsChildren,
 )
 
 log = config.logger(__file__)
 max_depth = config.get("services.projects.sub_projects.max_depth", 10)
+reports_project_name = ".reports"
+datasets_project_name = ".datasets"
+pipelines_project_name = ".pipelines"
+reports_tag = "reports"
+dataset_tag = "dataset"
+pipeline_tag = "pipeline"
 
 
 class ProjectBLL:
+    child_classes = (Task, Model)
+
     @classmethod
     def merge_project(
-        cls, company, source_id: str, destination_id: str
+        cls, company: str, source_id: str, destination_id: str
     ) -> Tuple[int, int, Set[str]]:
         """
         Move all the tasks and sub projects from the source project to the destination
@@ -81,7 +90,7 @@ class ProjectBLL:
             )
 
         moved_entities = 0
-        for entity_type in (Task, Model):
+        for entity_type in cls.child_classes:
             moved_entities += entity_type.objects(
                 company=company,
                 project=source_id,
@@ -297,18 +306,21 @@ class ProjectBLL:
         """
         Move a batch of entities to `project` or a project named `project_name` (create if does not exist)
         """
-        project = cls.find_or_create(
-            user=user,
-            company=company,
-            project_id=project,
-            project_name=project_name,
-            description="",
-        )
-        extra = (
-            {"set__last_change": datetime.utcnow()}
-            if hasattr(entity_cls, "last_change")
-            else {}
-        )
+        if project_name or project:
+            project = cls.find_or_create(
+                user=user,
+                company=company,
+                project_id=project,
+                project_name=project_name,
+                description="",
+            )
+
+        extra = {}
+        if hasattr(entity_cls, "last_change"):
+            extra["set__last_change"] = datetime.utcnow()
+        if hasattr(entity_cls, "last_changed_by"):
+            extra["set__last_changed_by"] = user
+
         entity_cls.objects(company=company, id__in=ids).update(
             set__project=project, **extra
         )
@@ -329,6 +341,17 @@ class ProjectBLL:
     ) -> Tuple[Sequence, Sequence]:
         archived = EntityVisibility.archived.value
 
+        def project_task_fields():
+            return {
+                "$project": {
+                    "project": 1,
+                    "status": 1,
+                    "system_tags": 1,
+                    "started": 1,
+                    "completed": 1,
+                }
+            }
+
         def ensure_valid_fields():
             """
             Make sure system tags is always an array (required by subsequent $in in archived_tasks_cond
@@ -356,6 +379,7 @@ class ProjectBLL:
                     users=users,
                 )
             },
+            project_task_fields(),
             ensure_valid_fields(),
             {
                 "$group": {
@@ -394,6 +418,18 @@ class ProjectBLL:
                                 "$completed",
                                 {"$gt": ["$completed", time_thresh]},
                                 additional_cond,
+                                {
+                                    "$not": {
+                                        "$in": [
+                                            "$status",
+                                            [
+                                                TaskStatus.queued,
+                                                TaskStatus.in_progress,
+                                                TaskStatus.failed,
+                                            ],
+                                        ]
+                                    }
+                                },
                             ]
                         },
                         "then": 1,
@@ -492,6 +528,7 @@ class ProjectBLL:
                     users=users,
                 )
             },
+            project_task_fields(),
             ensure_valid_fields(),
             {
                 # for each project
@@ -507,7 +544,7 @@ class ProjectBLL:
     def aggregate_project_data(
         func: Callable[[T, T], T],
         project_ids: Sequence[str],
-        child_projects: Mapping[str, Sequence[Project]],
+        child_projects: ProjectsChildren,
         data: Mapping[str, T],
     ) -> Dict[str, T]:
         """
@@ -527,7 +564,10 @@ class ProjectBLL:
 
     @classmethod
     def get_dataset_stats(
-        cls, company: str, project_ids: Sequence[str], users: Sequence[str] = None,
+        cls,
+        company: str,
+        project_ids: Sequence[str],
+        users: Sequence[str] = None,
     ) -> Dict[str, dict]:
         if not project_ids:
             return {}
@@ -559,6 +599,140 @@ class ProjectBLL:
             for r in Task.aggregate(task_runtime_pipeline)
         }
 
+    @staticmethod
+    def _get_projects_children(
+        project_ids: Sequence[str],
+        search_hidden: bool,
+        allowed_ids: Sequence[str],
+    ) -> Tuple[ProjectsChildren, Set[str]]:
+        child_projects = _get_sub_projects(
+            project_ids,
+            _only=("id", "name"),
+            search_hidden=search_hidden,
+            allowed_ids=allowed_ids,
+        )
+        return (
+            child_projects,
+            {c.id for c in chain.from_iterable(child_projects.values())},
+        )
+
+    @staticmethod
+    def _get_children_info(
+        project_ids: Sequence[str], child_projects: ProjectsChildren
+    ) -> dict:
+        return {
+            project: sorted(
+                [{"id": c.id, "name": c.name} for c in child_projects.get(project, [])],
+                key=itemgetter("name"),
+            )
+            for project in project_ids
+        }
+
+    @classmethod
+    def _get_project_dataset_stats_core(
+        cls,
+        company: str,
+        project_ids: Sequence[str],
+        project_field: str,
+        entity_class: Type[AttributedDocument],
+        include_children: bool = True,
+        filter_: Mapping[str, Any] = None,
+        users: Sequence[str] = None,
+        selected_project_ids: Sequence[str] = None,
+    ) -> Tuple[Dict[str, dict], Dict[str, dict]]:
+        if not project_ids:
+            return {}, {}
+
+        child_projects = {}
+        project_ids_with_children = set(project_ids)
+        if include_children:
+            child_projects, children_ids = cls._get_projects_children(
+                project_ids,
+                search_hidden=True,
+                allowed_ids=selected_project_ids,
+            )
+            project_ids_with_children |= children_ids
+
+        pipeline = [
+            {
+                "$match": cls.get_match_conditions(
+                    company=company,
+                    project_ids=list(project_ids_with_children),
+                    filter_=filter_,
+                    users=users,
+                    project_field=project_field,
+                )
+            },
+            {"$project": {project_field: 1, "tags": 1}},
+            {
+                "$group": {
+                    "_id": f"${project_field}",
+                    "count": {"$sum": 1},
+                    "tags": {"$push": "$tags"},
+                }
+            },
+        ]
+        res = entity_class.aggregate(pipeline)
+
+        project_stats = {
+            result["_id"]: {
+                "count": result.get("count", 0),
+                "tags": set(chain.from_iterable(result.get("tags", []))),
+            }
+            for result in res
+        }
+
+        def concat_dataset_stats(a: dict, b: dict) -> dict:
+            return {
+                "count": a.get("count", 0) + b.get("count", 0),
+                "tags": a.get("tags", {}) | b.get("tags", {}),
+            }
+
+        top_project_stats = cls.aggregate_project_data(
+            func=concat_dataset_stats,
+            project_ids=project_ids,
+            child_projects=child_projects,
+            data=project_stats,
+        )
+        for _, stat in top_project_stats.items():
+            stat["tags"] = sorted(list(stat.get("tags", {})))
+
+        empty_stats = {"count": 0, "tags": []}
+        stats = {
+            project: {"datasets": top_project_stats.get(project, empty_stats)}
+            for project in project_ids
+        }
+        return stats, cls._get_children_info(project_ids, child_projects)
+
+    @classmethod
+    def get_project_dataset_stats(
+        cls,
+        company: str,
+        project_ids: Sequence[str],
+        include_children: bool = True,
+        filter_: Mapping[str, Any] = None,
+        users: Sequence[str] = None,
+        selected_project_ids: Sequence[str] = None,
+    ) -> Tuple[Dict[str, dict], Dict[str, dict]]:
+        filter_ = filter_ or {}
+        filter_system_tags = filter_.get("system_tags")
+        if not isinstance(filter_system_tags, list):
+            filter_system_tags = []
+        if dataset_tag not in filter_system_tags:
+            filter_system_tags.append(dataset_tag)
+            filter_["system_tags"] = filter_system_tags
+
+        return cls._get_project_dataset_stats_core(
+            company=company,
+            project_ids=project_ids,
+            project_field="parent",
+            entity_class=Project,
+            include_children=include_children,
+            filter_=filter_,
+            users=users,
+            selected_project_ids=selected_project_ids,
+        )
+
     @classmethod
     def get_project_stats(
         cls,
@@ -569,24 +743,21 @@ class ProjectBLL:
         search_hidden: bool = False,
         filter_: Mapping[str, Any] = None,
         users: Sequence[str] = None,
-        user_active_project_ids: Sequence[str] = None,
+        selected_project_ids: Sequence[str] = None,
     ) -> Tuple[Dict[str, dict], Dict[str, dict]]:
         if not project_ids:
             return {}, {}
 
-        child_projects = (
-            _get_sub_projects(
+        child_projects = {}
+        project_ids_with_children = set(project_ids)
+        if include_children:
+            child_projects, children_ids = cls._get_projects_children(
                 project_ids,
-                _only=("id", "name"),
                 search_hidden=search_hidden,
-                allowed_ids=user_active_project_ids,
+                allowed_ids=selected_project_ids,
             )
-            if include_children
-            else {}
-        )
-        project_ids_with_children = set(project_ids) | {
-            c.id for c in itertools.chain.from_iterable(child_projects.values())
-        }
+            project_ids_with_children |= children_ids
+
         status_count_pipeline, runtime_pipeline = cls.make_projects_get_all_pipelines(
             company,
             project_ids=list(project_ids_with_children),
@@ -690,14 +861,7 @@ class ProjectBLL:
             for project in project_ids
         }
 
-        children = {
-            project: sorted(
-                [{"id": c.id, "name": c.name} for c in child_projects.get(project, [])],
-                key=itemgetter("name"),
-            )
-            for project in project_ids
-        }
-        return stats, children
+        return stats, cls._get_children_info(project_ids, child_projects)
 
     @classmethod
     def get_active_users(
@@ -705,7 +869,7 @@ class ProjectBLL:
         company,
         project_ids: Sequence[str],
         user_ids: Optional[Sequence[str]] = None,
-    ) -> Set[str]:
+    ) -> Set[Union[str, type(None)]]:
         """
         Get the set of user ids that created tasks/models in the given projects
         If project_ids is empty then all projects are examined
@@ -722,7 +886,7 @@ class ProjectBLL:
             projects_query &= Q(id__in=project_ids)
 
         res = set(Project.objects(projects_query).distinct(field="user"))
-        for cls_ in (Task, Model):
+        for cls_ in cls.child_classes:
             res |= set(cls_.objects(query).distinct(field="user"))
 
         return res
@@ -751,61 +915,102 @@ class ProjectBLL:
         return tags, system_tags
 
     @classmethod
-    def get_projects_with_active_user(
+    def get_projects_with_selected_children(
         cls,
         company: str,
-        users: Sequence[str],
+        users: Sequence[str] = None,
         project_ids: Optional[Sequence[str]] = None,
         allow_public: bool = True,
+        children_type: ProjectChildrenType = None,
+        children_tags: Sequence[str] = None,
+        children_tags_filter: dict = None,
     ) -> Tuple[Sequence[str], Sequence[str]]:
         """
-        Get the projects ids where user created any tasks including all the parents of these projects
+        Get the projects ids matching children_condition (if passed) or where the passed user created any tasks
+        including all the parents of these projects
         If project ids are specified then filter the results by these project ids
         """
-        query = Q(user__in=users)
+        if not (users or children_type):
+            raise errors.bad_request.ValidationError(
+                "Either active users or children_condition should be specified"
+            )
 
-        if allow_public:
-            query &= get_company_or_none_constraint(company)
+        query = (
+            get_company_or_none_constraint(company)
+            if allow_public
+            else Q(company=company)
+        )
+        if users:
+            query &= Q(user__in=users)
+
+        project_query = None
+        if children_tags_filter:
+            child_query = query & GetMixin.get_list_filter_query(
+                "tags", children_tags_filter
+            )
+        elif children_tags:
+            child_query = query & GetMixin.get_list_field_query("tags", children_tags)
         else:
-            query &= Q(company=company)
+            child_query = query
+
+        if children_type == ProjectChildrenType.dataset:
+            child_queries = {
+                Project: child_query
+                & Q(system_tags__in=[dataset_tag], basename__ne=datasets_project_name)
+            }
+        elif children_type == ProjectChildrenType.pipeline:
+            child_queries = {
+                Project: child_query
+                & Q(system_tags__in=[pipeline_tag], basename__ne=pipelines_project_name)
+            }
+        elif children_type == ProjectChildrenType.report:
+            child_queries = {Task: child_query & Q(system_tags__in=[reports_tag])}
+        else:
+            project_query = query
+            child_queries = {entity_cls: query for entity_cls in cls.child_classes}
 
-        user_projects_query = query
         if project_ids:
             ids_with_children = _ids_with_children(project_ids)
-            query &= Q(project__in=ids_with_children)
-            user_projects_query &= Q(id__in=ids_with_children)
+            if project_query:
+                project_query &= Q(id__in=ids_with_children)
+            for child_cls in child_queries:
+                child_queries[child_cls] &= (
+                    Q(parent__in=ids_with_children)
+                    if child_cls is Project
+                    else Q(project__in=ids_with_children)
+                )
 
-        res = {p.id for p in Project.objects(user_projects_query).only("id")}
-        for cls_ in (Task, Model):
-            res |= set(cls_.objects(query).distinct(field="project"))
+        res = (
+            set(Project.objects(project_query).scalar("id")) if project_query else set()
+        )
+        for cls_, query_ in child_queries.items():
+            res |= set(
+                cls_.objects(query_).distinct(
+                    field="id" if cls_ is Project else "project"
+                )
+            )
 
         res = list(res)
         if not res:
             return res, res
 
-        user_active_project_ids = _ids_with_parents(res)
+        selected_project_ids = _ids_with_parents(res)
         filtered_ids = (
-            list(set(user_active_project_ids) & set(project_ids))
+            list(set(selected_project_ids) & set(project_ids))
             if project_ids
-            else list(user_active_project_ids)
+            else list(selected_project_ids)
         )
 
-        return filtered_ids, user_active_project_ids
+        return filtered_ids, selected_project_ids
 
-    @classmethod
-    def get_task_parents(
-        cls,
-        company_id: str,
-        projects: Sequence[str],
-        include_subprojects: bool,
+    @staticmethod
+    def _get_project_query(
+        company: str,
+        projects: Sequence,
+        include_subprojects: bool = True,
         state: Optional[EntityVisibility] = None,
-    ) -> Sequence[dict]:
-        """
-        Get list of unique parent tasks sorted by task name for the passed company projects
-        If projects is None or empty then get parents for all the company tasks
-        """
-        query = Q(company=company_id)
-
+    ) -> Q:
+        query = get_company_or_none_constraint(company)
         if projects:
             if include_subprojects:
                 projects = _ids_with_children(projects)
@@ -818,6 +1023,25 @@ class ProjectBLL:
         elif state == EntityVisibility.active:
             query &= Q(system_tags__nin=[EntityVisibility.archived.value])
 
+        return query
+
+    @classmethod
+    def get_task_parents(
+        cls,
+        company_id: str,
+        projects: Sequence[str],
+        include_subprojects: bool,
+        state: Optional[EntityVisibility] = None,
+        name: str = None,
+    ) -> Sequence[dict]:
+        """
+        Get list of unique parent tasks sorted by task name for the passed company projects
+        If projects is None or empty then get parents for all the company tasks
+        """
+        query = cls._get_project_query(
+            company_id, projects, include_subprojects=include_subprojects, state=state
+        )
+
         parent_ids = set(Task.objects(query).distinct("parent"))
         if not parent_ids:
             return []
@@ -825,23 +1049,37 @@ class ProjectBLL:
         parents = Task.get_many_with_join(
             company_id,
             query=Q(id__in=parent_ids),
+            query_dict={"name": name} if name else None,
             allow_public=True,
             override_projection=("id", "name", "project.name"),
         )
+
         return sorted(parents, key=itemgetter("name"))
 
+    @classmethod
+    def get_entity_users(
+        cls,
+        company: str,
+        entity_cls: Type[Union[Task, Model]],
+        projects: Sequence[str],
+        include_subprojects: bool,
+    ) -> Sequence[dict]:
+        query = cls._get_project_query(
+            company, projects, include_subprojects=include_subprojects
+        )
+        user_ids = entity_cls.objects(query).distinct(field="user")
+        if not user_ids:
+            return []
+        users = User.objects(id__in=user_ids).only("id", "name")
+        return [{"id": u.id, "name": u.name} for u in users]
+
     @classmethod
     def get_task_types(cls, company, project_ids: Optional[Sequence]) -> set:
         """
         Return the list of unique task types used by company and public tasks
         If project ids passed then only tasks from these projects are considered
         """
-        query = get_company_or_none_constraint(company)
-        if project_ids:
-            project_ids = _ids_with_children(project_ids)
-            query &= Q(project__in=project_ids)
-        else:
-            query &= Q(system_tags__nin=[EntityVisibility.hidden.value])
+        query = cls._get_project_query(company, project_ids)
         res = Task.objects(query).distinct(field="type")
         return set(res).intersection(external_task_types)
 
@@ -851,10 +1089,7 @@ class ProjectBLL:
         Return the list of unique frameworks used by company and public models
         If project ids passed then only models from these projects are considered
         """
-        query = get_company_or_none_constraint(company)
-        if project_ids:
-            project_ids = _ids_with_children(project_ids)
-            query &= Q(project__in=project_ids)
+        query = cls._get_project_query(company, project_ids)
         return Model.objects(query).distinct(field="framework")
 
     @staticmethod
@@ -863,10 +1098,11 @@ class ProjectBLL:
         project_ids: Sequence[str],
         filter_: Mapping[str, Any],
         users: Sequence[str],
+        project_field: str = "project",
     ):
         conditions = {
             "company": {"$in": [None, "", company]},
-            "project": {"$in": project_ids},
+            project_field: {"$in": project_ids},
         }
         if users:
             conditions["user"] = {"$in": users}
@@ -874,29 +1110,125 @@ class ProjectBLL:
         if not filter_:
             return conditions
 
+        or_conditions = []
         for field, field_filter in filter_.items():
-            if not (
-                field_filter
-                and isinstance(field_filter, list)
-                and all(isinstance(t, str) for t in field_filter)
-            ):
+            if not (field_filter and isinstance(field_filter, (list, dict))):
                 raise errors.bad_request.ValidationError(
-                    f"List of strings expected for the field: {field}"
+                    f"Non empty list or dictionary expected for the field: {field}"
                 )
-            exclude, include = partition(field_filter, lambda x: x.startswith("-"))
-            conditions[field] = {
-                **({"$in": include} if include else {}),
-                **({"$nin": [e[1:] for e in exclude]} if exclude else {}),
-            }
+
+            if isinstance(field_filter, list):
+                if not all(isinstance(t, str) for t in field_filter):
+                    raise errors.bad_request.ValidationError(
+                        f"Only string values are allowed in the list filter: {field}"
+                    )
+                helper = GetMixin.NewListFieldBucketHelper(
+                    field, data=field_filter, legacy=True
+                )
+                op = helper.global_operator
+                db_query = {op: helper.actions}
+            else:
+                helper = GetMixin.ListQueryFilter.from_data(field, field_filter)
+                db_query = helper.db_query
+
+            for op, actions in db_query.items():
+                field_conditions = {}
+                for action, values in actions.items():
+                    value = list(set(values)) if isinstance(values, list) else values
+                    for key in reversed(action.split("__")):
+                        value = {f"${key}": value}
+                    field_conditions.update(value)
+
+                if op == Q.OR and len(field_conditions) > 1:
+                    or_conditions.append(
+                        {
+                            "$or": [
+                                {field: {db_modifier: cond}}
+                                for db_modifier, cond in field_conditions.items()
+                            ]
+                        }
+                    )
+                else:
+                    conditions[field] = field_conditions
+
+        if or_conditions:
+            if len(or_conditions) == 1:
+                conditions = next(iter(or_conditions))
+            else:
+                conditions["$and"] = [c for c in or_conditions]
 
         return conditions
 
+    @classmethod
+    def _calc_own_datasets_core(
+        cls,
+        company: str,
+        project_ids: Sequence[str],
+        project_field: str,
+        entity_class: Type[AttributedDocument],
+        filter_: Mapping[str, Any] = None,
+        users: Sequence[str] = None,
+    ) -> Dict[str, dict]:
+        """
+        Returns the amount of hyper datasets per requested project
+        """
+        if not project_ids:
+            return {}
+
+        pipeline = [
+            {
+                "$match": cls.get_match_conditions(
+                    company=company,
+                    project_ids=project_ids,
+                    filter_=filter_,
+                    users=users,
+                    project_field=project_field,
+                )
+            },
+            {"$project": {project_field: 1}},
+            {"$group": {"_id": f"${project_field}", "count": {"$sum": 1}}},
+        ]
+        datasets = {
+            data["_id"]: data["count"] for data in entity_class.aggregate(pipeline)
+        }
+
+        return {pid: {"own_datasets": datasets.get(pid, 0)} for pid in project_ids}
+
+    @classmethod
+    def calc_own_datasets(
+        cls,
+        company: str,
+        project_ids: Sequence[str],
+        filter_: Mapping[str, Any] = None,
+        users: Sequence[str] = None,
+    ) -> Dict[str, dict]:
+        """
+        Returns the amount of datasets per requested project
+        """
+        filter_ = filter_ or {}
+        filter_system_tags = filter_.get("system_tags")
+        if not isinstance(filter_system_tags, list):
+            filter_system_tags = []
+        if dataset_tag not in filter_system_tags:
+            filter_system_tags.append(dataset_tag)
+            filter_["system_tags"] = filter_system_tags
+
+        return cls._calc_own_datasets_core(
+            company=company,
+            project_ids=project_ids,
+            project_field="parent",
+            entity_class=Project,
+            filter_=filter_,
+            users=users,
+        )
+
     @classmethod
     def calc_own_contents(
         cls,
         company: str,
         project_ids: Sequence[str],
         filter_: Mapping[str, Any] = None,
+        specific_state: Optional[EntityVisibility] = None,
         users: Sequence[str] = None,
     ) -> Dict[str, dict]:
         """
@@ -907,6 +1239,20 @@ class ProjectBLL:
         if not project_ids:
             return {}
 
+        if specific_state:
+            filter_ = filter_ or {}
+            system_tags_filter = filter_.get("system_tags", [])
+            archived = EntityVisibility.archived.value
+            non_archived = f"-{EntityVisibility.archived.value}"
+            if not any(t in system_tags_filter for t in (archived, non_archived)):
+                filter_ = {k: v for k, v in filter_.items()}
+                filter_["system_tags"] = [
+                    archived
+                    if specific_state == EntityVisibility.archived
+                    else non_archived,
+                    *system_tags_filter,
+                ]
+
         pipeline = [
             {
                 "$match": cls.get_match_conditions(

apiserver/bll/project/project_cleanup.py

@@ -1,6 +1,9 @@
+from collections import defaultdict
+from datetime import datetime
 from typing import Tuple, Set, Sequence
 
 import attr
+from mongoengine import Q
 
 from apiserver.apierrors import errors
 from apiserver.bll.event import EventBLL
@@ -14,12 +17,19 @@ from apiserver.config_repo import config
 from apiserver.database.model import EntityVisibility
 from apiserver.database.model.model import Model
 from apiserver.database.model.project import Project
-from apiserver.database.model.task.task import Task, ArtifactModes, TaskType
+from apiserver.database.model.task.task import Task, ArtifactModes, TaskType, TaskStatus
+from .project_bll import (
+    ProjectBLL,
+    pipeline_tag,
+    pipelines_project_name,
+    dataset_tag,
+    datasets_project_name,
+    reports_tag,
+)
 from .sub_projects import _ids_with_children
 
 log = config.logger(__file__)
 event_bll = EventBLL()
-async_events_delete = config.get("services.tasks.async_events_delete", False)
 
 
 @attr.s(auto_attribs=True)
@@ -31,30 +41,83 @@ class DeleteProjectResult:
     urls: TaskUrls = None
 
 
+def _get_child_project_ids(
+    project_id: str,
+) -> Tuple[Sequence[str], Sequence[str], Sequence[str]]:
+    project_ids = _ids_with_children([project_id])
+    pipeline_ids = list(
+        Project.objects(
+            id__in=project_ids,
+            system_tags__in=[pipeline_tag],
+            basename__ne=pipelines_project_name,
+        ).scalar("id")
+    )
+    dataset_ids = list(
+        Project.objects(
+            id__in=project_ids,
+            system_tags__in=[dataset_tag],
+            basename__ne=datasets_project_name,
+        ).scalar("id")
+    )
+    return project_ids, pipeline_ids, dataset_ids
+
+
 def validate_project_delete(company: str, project_id: str):
     project = Project.get_for_writing(
         company=company, id=project_id, _only=("id", "path", "system_tags")
     )
     if not project:
         raise errors.bad_request.InvalidProjectId(id=project_id)
-    is_pipeline = "pipeline" in (project.system_tags or [])
-    project_ids = _ids_with_children([project_id])
+
+    project_ids, pipeline_ids, dataset_ids = _get_child_project_ids(project_id)
     ret = {}
-    for cls in (Task, Model):
-        ret[f"{cls.__name__.lower()}s"] = cls.objects(project__in=project_ids).count()
-    for cls in (Task, Model):
-        query = dict(
-            project__in=project_ids, system_tags__nin=[EntityVisibility.archived.value]
-        )
-        name = f"non_archived_{cls.__name__.lower()}s"
-        if not is_pipeline:
-            ret[name] = cls.objects(**query).count()
-        else:
-            ret[name] = (
-                cls.objects(**query, type=TaskType.controller).count()
-                if cls == Task
-                else 0
+    if pipeline_ids:
+        pipelines_with_active_controllers = Task.objects(
+            project__in=pipeline_ids,
+            type=TaskType.controller,
+            system_tags__nin=[EntityVisibility.archived.value],
+        ).distinct("project")
+        ret["pipelines"] = len(pipelines_with_active_controllers)
+    else:
+        ret["pipelines"] = 0
+    if dataset_ids:
+        datasets_with_data = Task.objects(
+            project__in=dataset_ids,
+            system_tags__nin=[EntityVisibility.archived.value],
+        ).distinct("project")
+        ret["datasets"] = len(datasets_with_data)
+    else:
+        ret["datasets"] = 0
+
+    project_ids = list(set(project_ids) - set(pipeline_ids) - set(dataset_ids))
+    if project_ids:
+        in_project_query = Q(project__in=project_ids)
+        for cls in (Task, Model):
+            query = (
+                in_project_query & Q(system_tags__nin=[reports_tag])
+                if cls is Task
+                else in_project_query
             )
+            ret[f"{cls.__name__.lower()}s"] = cls.objects(query).count()
+            ret[f"non_archived_{cls.__name__.lower()}s"] = cls.objects(
+                query & Q(system_tags__nin=[EntityVisibility.archived.value])
+            ).count()
+        ret["reports"] = Task.objects(
+            in_project_query & Q(system_tags__in=[reports_tag])
+        ).count()
+        ret["non_archived_reports"] = Task.objects(
+            in_project_query
+            & Q(
+                system_tags__in=[reports_tag],
+                system_tags__nin=[EntityVisibility.archived.value],
+            )
+        ).count()
+    else:
+        for cls in (Task, Model):
+            ret[f"{cls.__name__.lower()}s"] = 0
+            ret[f"non_archived_{cls.__name__.lower()}s"] = 0
+        ret["reports"] = 0
+        ret["non_archived_reports"] = 0
 
     return ret
 
@@ -65,7 +128,7 @@ def delete_project(
     project_id: str,
     force: bool,
     delete_contents: bool,
-    delete_external_artifacts=True,
+    delete_external_artifacts: bool,
 ) -> Tuple[DeleteProjectResult, Set[str]]:
     project = Project.get_for_writing(
         company=company, id=project_id, _only=("id", "path", "system_tags")
@@ -74,39 +137,58 @@ def delete_project(
         raise errors.bad_request.InvalidProjectId(id=project_id)
 
     delete_external_artifacts = delete_external_artifacts and config.get(
-        "services.async_urls_delete.enabled", False
+        "services.async_urls_delete.enabled", True
     )
-    is_pipeline = "pipeline" in (project.system_tags or [])
-    project_ids = _ids_with_children([project_id])
+    project_ids, pipeline_ids, dataset_ids = _get_child_project_ids(project_id)
     if not force:
-        query = dict(
-            project__in=project_ids, system_tags__nin=[EntityVisibility.archived.value]
-        )
-        if not is_pipeline:
+        if pipeline_ids:
+            active_controllers = Task.objects(
+                project__in=pipeline_ids,
+                type=TaskType.controller,
+                system_tags__nin=[EntityVisibility.archived.value],
+            ).only("id")
+            if active_controllers:
+                raise errors.bad_request.ProjectHasPipelines(
+                    "please archive all the controllers or use force=true",
+                    id=project_id,
+                )
+        if dataset_ids:
+            datasets_with_data = Task.objects(
+                project__in=dataset_ids,
+                system_tags__nin=[EntityVisibility.archived.value],
+            ).only("id")
+            if datasets_with_data:
+                raise errors.bad_request.ProjectHasDatasets(
+                    "please delete all the dataset versions or use force=true",
+                    id=project_id,
+                )
+
+        regular_projects = list(set(project_ids) - set(pipeline_ids) - set(dataset_ids))
+        if regular_projects:
             for cls, error in (
                 (Task, errors.bad_request.ProjectHasTasks),
                 (Model, errors.bad_request.ProjectHasModels),
             ):
-                non_archived = cls.objects(**query).only("id")
+                non_archived = cls.objects(
+                    project__in=regular_projects,
+                    system_tags__nin=[EntityVisibility.archived.value],
+                ).only("id")
                 if non_archived:
-                    raise error("use force=true to delete", id=project_id)
-        else:
-            non_archived = Task.objects(**query, type=TaskType.controller).only("id")
-            if non_archived:
-                raise errors.bad_request.ProjectHasTasks(
-                    "please archive all the runs inside the project", id=project_id
-                )
+                    raise error("use force=true", id=project_id)
 
     if not delete_contents:
-        for cls in (Model, Task):
-            updated_count = cls.objects(project__in=project_ids).update(project=None)
-        res = DeleteProjectResult(disassociated_tasks=updated_count)
+        disassociated = defaultdict(int)
+        for cls in ProjectBLL.child_classes:
+            disassociated[cls] = cls.objects(project__in=project_ids).update(
+                project=None
+            )
+        res = DeleteProjectResult(disassociated_tasks=disassociated[Task])
     else:
         deleted_models, model_event_urls, model_urls = _delete_models(
-            company=company, projects=project_ids
+            company=company, user=user, projects=project_ids
         )
         deleted_tasks, task_event_urls, artifact_urls = _delete_tasks(
-            company=company, projects=project_ids
+            company=company, user=user, projects=project_ids
         )
         event_urls = task_event_urls | model_event_urls
         if delete_external_artifacts:
@@ -135,7 +217,9 @@ def delete_project(
     return res, affected
 
 
-def _delete_tasks(company: str, projects: Sequence[str]) -> Tuple[int, Set, Set]:
+def _delete_tasks(
+    company: str, user: str, projects: Sequence[str]
+) -> Tuple[int, Set, Set]:
     """
     Delete only the task themselves and their non published version.
     Child models under the same project are deleted separately.
@@ -146,14 +230,24 @@ def _delete_tasks(company: str, projects: Sequence[str]) -> Tuple[int, Set, Set]
     if not tasks:
         return 0, set(), set()
 
-    task_ids = {t.id for t in tasks}
-    Task.objects(parent__in=task_ids, project__nin=projects).update(parent=None)
-    Model.objects(task__in=task_ids, project__nin=projects).update(task=None)
+    task_ids = list({t.id for t in tasks})
+    now = datetime.utcnow()
+    Task.objects(parent__in=task_ids, project__nin=projects).update(
+        parent=None,
+        last_change=now,
+        last_changed_by=user,
+    )
+    Model.objects(task__in=task_ids, project__nin=projects).update(
+        task=None,
+        last_change=now,
+        last_changed_by=user,
+    )
 
-    event_urls, artifact_urls = set(), set()
+    event_urls = collect_debug_image_urls(company, task_ids) | collect_plot_image_urls(
+        company, task_ids
+    )
+    artifact_urls = set()
     for task in tasks:
-        event_urls.update(collect_debug_image_urls(company, task.id))
-        event_urls.update(collect_plot_image_urls(company, task.id))
         if task.execution and task.execution.artifacts:
             artifact_urls.update(
                 {
@@ -163,15 +257,13 @@ def _delete_tasks(company: str, projects: Sequence[str]) -> Tuple[int, Set, Set]
                 }
             )
 
-    event_bll.delete_multi_task_events(
-        company, list(task_ids), async_delete=async_events_delete
-    )
+    event_bll.delete_multi_task_events(company, task_ids)
     deleted = tasks.delete()
     return deleted, event_urls, artifact_urls
 
 
 def _delete_models(
-    company: str, projects: Sequence[str]
+    company: str, user: str, projects: Sequence[str]
 ) -> Tuple[int, Set[str], Set[str]]:
     """
     Delete project models and update the tasks from other projects
@@ -182,39 +274,54 @@ def _delete_models(
         return 0, set(), set()
 
     model_ids = list({m.id for m in models})
-
+    deleted = "__DELETED__"
     Task._get_collection().update_many(
         filter={
             "project": {"$nin": projects},
             "models.input.model": {"$in": model_ids},
         },
-        update={"$set": {"models.input.$[elem].model": None}},
+        update={"$set": {"models.input.$[elem].model": deleted}},
         array_filters=[{"elem.model": {"$in": model_ids}}],
         upsert=False,
     )
 
     model_tasks = list({m.task for m in models if m.task})
     if model_tasks:
+        now = datetime.utcnow()
+        # update published tasks
         Task._get_collection().update_many(
             filter={
                 "_id": {"$in": model_tasks},
                 "project": {"$nin": projects},
                 "models.output.model": {"$in": model_ids},
+                "status": TaskStatus.published,
+            },
+            update={
+                "$set": {
+                    "models.output.$[elem].model": deleted,
+                    "last_change": now,
+                    "last_changed_by": user,
+                }
             },
-            update={"$set": {"models.output.$[elem].model": None}},
             array_filters=[{"elem.model": {"$in": model_ids}}],
             upsert=False,
         )
+        # update unpublished tasks
+        Task.objects(
+            id__in=model_tasks,
+            project__nin=projects,
+            status__ne=TaskStatus.published,
+        ).update(
+            pull__models__output__model__in=model_ids,
+            set__last_change=now,
+            set__last_changed_by=user,
+        )
 
-    event_urls, model_urls = set(), set()
-    for m in models:
-        event_urls.update(collect_debug_image_urls(company, m.id))
-        event_urls.update(collect_plot_image_urls(company, m.id))
-        if m.uri:
-            model_urls.add(m.uri)
-
-    event_bll.delete_multi_task_events(
-        company, model_ids, async_delete=async_events_delete
+    event_urls = collect_debug_image_urls(company, model_ids) | collect_plot_image_urls(
+        company, model_ids
     )
+    model_urls = {m.uri for m in models if m.uri}
+
+    event_bll.delete_multi_task_events(company, model_ids, model=True)
     deleted = models.delete()
     return deleted, event_urls, model_urls

apiserver/bll/project/project_queries.py

@@ -140,7 +140,12 @@ class ProjectQueries:
         name: str,
         include_subprojects: bool,
         allow_public: bool = True,
+        pattern: str = None,
+        page: int = 0,
+        page_size: int = 500,
     ) -> ParamValues:
+        page = max(0, page)
+        page_size = max(1, page_size)
         company_constraint = self._get_company_constraint(company_id, allow_public)
         project_constraint = self._get_project_constraint(
             project_ids, include_subprojects
@@ -160,7 +165,20 @@ class ProjectQueries:
         if not last_updated_task:
             return 0, []
 
-        redis_key = f"hyperparam_values_{company_id}_{'_'.join(project_ids)}_{section}_{name}_{allow_public}"
+        redis_key = "_".join(
+            str(part)
+            for part in (
+                "hyperparam_values",
+                company_id,
+                "_".join(project_ids),
+                section,
+                name,
+                allow_public,
+                pattern,
+                page,
+                page_size,
+            )
+        )
         last_update = last_updated_task.last_update or datetime.utcnow()
         cached_res = self._get_cached_param_values(
             key=redis_key,
@@ -172,19 +190,27 @@ class ProjectQueries:
         if cached_res:
             return cached_res
 
-        max_values = config.get("services.tasks.hyperparam_values.max_count", 100)
-        pipeline = [
-            {
-                "$match": {
-                    **company_constraint,
-                    **project_constraint,
-                    key_path: {"$exists": True},
+        match_condition = {
+            **company_constraint,
+            **project_constraint,
+            key_path: {"$exists": True},
+        }
+        if pattern:
+            match_condition["$expr"] = {
+                "$regexMatch": {
+                    "input": f"${key_path}.value",
+                    "regex": pattern,
+                    "options": "i",
                 }
-            },
+            }
+
+        pipeline = [
+            {"$match": match_condition},
             {"$project": {"value": f"${key_path}.value"}},
             {"$group": {"_id": "$value"}},
             {"$sort": {"_id": 1}},
-            {"$limit": max_values},
+            {"$skip": page * page_size},
+            {"$limit": page_size},
             {
                 "$group": {
                     "_id": 1,
@@ -209,13 +235,19 @@ class ProjectQueries:
 
     @classmethod
     def get_unique_metric_variants(
-        cls, company_id, project_ids: Sequence[str], include_subprojects: bool
+        cls,
+        company_id,
+        project_ids: Sequence[str],
+        include_subprojects: bool,
+        ids: Sequence[str],
+        model_metrics: bool = False,
     ):
         pipeline = [
             {
                 "$match": {
                     **cls._get_company_constraint(company_id),
                     **cls._get_project_constraint(project_ids, include_subprojects),
+                    **({"_id": {"$in": ids}} if ids else {}),
                 }
             },
             {"$project": {"metrics": {"$objectToArray": "$last_metrics"}}},
@@ -246,7 +278,8 @@ class ProjectQueries:
             {"$sort": OrderedDict({"_id.metric": 1, "_id.variant": 1})},
         ]
 
-        result = Task.aggregate(pipeline)
+        entity_cls = Model if model_metrics else Task
+        result = entity_cls.aggregate(pipeline)
         return [r["metrics"][0] for r in result]
 
     @classmethod
@@ -306,7 +339,11 @@ class ProjectQueries:
         key: str,
         include_subprojects: bool,
         allow_public: bool = True,
+        page: int = 0,
+        page_size: int = 500,
     ) -> ParamValues:
+        page = max(0, page)
+        page_size = max(1, page_size)
         company_constraint = self._get_company_constraint(company_id, allow_public)
         project_constraint = self._get_project_constraint(
             project_ids, include_subprojects
@@ -326,7 +363,7 @@ class ProjectQueries:
         if not last_updated_model:
             return 0, []
 
-        redis_key = f"modelmetadata_values_{company_id}_{'_'.join(project_ids)}_{key}_{allow_public}"
+        redis_key = f"modelmetadata_values_{company_id}_{'_'.join(project_ids)}_{key}_{allow_public}_{page}_{page_size}"
         last_update = last_updated_model.last_update or datetime.utcnow()
         cached_res = self._get_cached_param_values(
             key=redis_key, last_update=last_update
@@ -334,7 +371,6 @@ class ProjectQueries:
         if cached_res:
             return cached_res
 
-        max_values = config.get("services.models.metadata_values.max_count", 100)
         pipeline = [
             {
                 "$match": {
@@ -346,7 +382,8 @@ class ProjectQueries:
             {"$project": {"value": f"${key_path}.value"}},
             {"$group": {"_id": "$value"}},
             {"$sort": {"_id": 1}},
-            {"$limit": max_values},
+            {"$skip": page * page_size},
+            {"$limit": page_size},
             {
                 "$group": {
                     "_id": 1,

apiserver/bll/project/sub_projects.py

@@ -14,14 +14,16 @@ def _get_project_depth(project_name: str) -> int:
     return len(list(filter(None, project_name.split(name_separator))))
 
 
-def _validate_project_name(project_name: str) -> Tuple[str, str]:
+def _validate_project_name(project_name: str, raise_if_empty=True) -> Tuple[str, str]:
     """
     Remove redundant '/' characters. Ensure that the project name is not empty
     Return the cleaned up project name and location
     """
-    name_parts = list(filter(None, project_name.split(name_separator)))
+    name_parts = [p.strip() for p in project_name.split(name_separator) if p]
     if not name_parts:
-        raise errors.bad_request.InvalidProjectName(name=project_name)
+        if raise_if_empty:
+            raise errors.bad_request.InvalidProjectName(name=project_name)
+        return "", ""
 
     return name_separator.join(name_parts), name_separator.join(name_parts[:-1])
 
@@ -34,7 +36,7 @@ def _ensure_project(
     If needed auto-create the project and all the missing projects in the path to it
     Return the project
     """
-    name = name.strip(name_separator)
+    name, location = _validate_project_name(name, raise_if_empty=False)
     if not name:
         return None
 
@@ -43,7 +45,6 @@ def _ensure_project(
         return project
 
     now = datetime.utcnow()
-    name, location = _validate_project_name(name)
     project = Project(
         id=database.utils.id(),
         user=user,
@@ -101,12 +102,15 @@ def _get_writable_project_from_name(
     return qs.first()
 
 
+ProjectsChildren = Mapping[str, Sequence[Project]]
+
+
 def _get_sub_projects(
     project_ids: Sequence[str],
     _only: Sequence[str] = ("id", "path"),
     search_hidden=True,
     allowed_ids: Sequence[str] = None,
-) -> Mapping[str, Sequence[Project]]:
+) -> ProjectsChildren:
     """
     Return the list of child projects of all the levels for the parent project ids
     """
@@ -140,8 +144,8 @@ def _ids_with_children(project_ids: Sequence[str]) -> Sequence[str]:
     """
     Return project ids with the ids of all the subprojects
     """
-    subprojects = Project.objects(path__in=project_ids).only("id")
-    return list({*project_ids, *(child.id for child in subprojects)})
+    children_ids = Project.objects(path__in=project_ids).scalar("id")
+    return list({*project_ids, *children_ids})
 
 
 def _update_subproject_names(
@@ -156,13 +160,17 @@ def _update_subproject_names(
     Optionally update the paths
     """
     updated = 0
+    now = datetime.utcnow()
     for child in children:
         child_suffix = name_separator.join(
-            child.name.split(name_separator)[len(old_name.split(name_separator)) :]
+            child.name.split(name_separator)[len(old_name.split(name_separator)):]
         )
-        updates = {"name": name_separator.join((project.name, child_suffix))}
+        updates = {
+            "name": name_separator.join((project.name, child_suffix)),
+            "last_update": now,
+        }
         if update_path:
-            updates["path"] = project.path + child.path[len(old_path) :]
+            updates["path"] = project.path + child.path[len(old_path):]
         updated += child.update(upsert=False, **updates)
 
     return updated
@@ -177,6 +185,7 @@ def _reposition_project_with_children(
     project.name = name_separator.join(
         filter(None, (new_location, project.name.split(name_separator)[-1]))
     )
+    project.last_update = datetime.utcnow()
     _save_under_parent(project, parent=parent)
 
     moved = 1 + _update_subproject_names(

apiserver/bll/queue/queue_bll.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from datetime import datetime
-from typing import Callable, Sequence, Optional, Tuple
+from typing import Sequence, Optional, Tuple, Union
 
 from elasticsearch import Elasticsearch
 from mongoengine import Q
@@ -16,6 +16,8 @@ from apiserver.database.errors import translate_errors_context
 from apiserver.database.model.queue import Queue, Entry
 
 log = config.logger(__file__)
+MOVE_FIRST = "first"
+MOVE_LAST = "last"
 
 
 class QueueBLL(object):
@@ -133,7 +135,7 @@ class QueueBLL(object):
             self.get_by_id(company_id=company_id, queue_id=queue_id, only=("id",))
             return Queue.safe_update(company_id, queue_id, update_fields)
 
-    def delete(self, company_id: str, queue_id: str, force: bool) -> None:
+    def delete(self, company_id: str, user_id: str, queue_id: str, force: bool) -> None:
         """
         Delete the queue
         :raise errors.bad_request.InvalidQueueId: if the queue is not found
@@ -150,10 +152,16 @@ class QueueBLL(object):
 
                 for item in queue.entries:
                     try:
-                        task = Task.get_for_writing(
+                        task = Task.get(
                             company=company_id,
                             id=item.task,
-                            _only=["id", "status", "enqueue_status", "project"],
+                            _only=[
+                                "id",
+                                "company",
+                                "status",
+                                "enqueue_status",
+                                "project",
+                            ],
                         )
                         if not task:
                             continue
@@ -163,6 +171,8 @@ class QueueBLL(object):
                             new_status=task.enqueue_status or TaskStatus.created,
                             status_reason="Queue was deleted",
                             status_message="",
+                            user_id=user_id,
+                            force=True,
                         ).execute(enqueue_status=None)
                     except Exception as ex:
                         log.exception(
@@ -233,6 +243,7 @@ class QueueBLL(object):
                     {
                         "name": w.id,
                         "ip": w.ip,
+                        "key": w.key,
                         "task": w.task.to_struct() if w.task else None,
                     }
                     for w in queue_workers.get(item["id"], [])
@@ -318,46 +329,131 @@ class QueueBLL(object):
             return len(entries_to_remove) if res else 0
 
     def reposition_task(
-        self,
-        company_id: str,
-        queue_id: str,
-        task_id: str,
-        pos_func: Callable[[int], int],
+        self, company_id: str, queue_id: str, task_id: str, move_count: Union[int, str],
     ) -> int:
         """
         Moves the task in the queue to the position calculated by pos_func
         Returns the updated task position in the queue
         """
-        with translate_errors_context():
-            queue = self.get_queue_with_task(
+
+        def get_queue_and_task_position():
+            q = self.get_queue_with_task(
                 company_id=company_id, queue_id=queue_id, task_id=task_id
             )
+            return q, next(i for i, e in enumerate(q.entries) if e.task == task_id)
 
-            position = next(i for i, e in enumerate(queue.entries) if e.task == task_id)
-            new_position = pos_func(position)
+        with translate_errors_context():
+            queue, position = get_queue_and_task_position()
+            if move_count == MOVE_FIRST:
+                new_position = 0
+            elif move_count == MOVE_LAST:
+                new_position = len(queue.entries) - 1
+            else:
+                new_position = position + move_count
+            if new_position == position:
+                return new_position
 
-            if new_position != position:
-                entry = queue.entries[position]
-                query = dict(id=queue_id, company=company_id)
-                updated = Queue.objects(entries__task=task_id, **query).update_one(
-                    pull__entries=entry, last_update=datetime.utcnow()
-                )
-                if not updated:
-                    raise errors.bad_request.RemovedDuringReposition(
-                        task=task_id, **query
-                    )
-                inst = {"$push": {"entries": {"$each": [entry.to_proper_dict()]}}}
-                if new_position >= 0:
-                    inst["$push"]["entries"]["$position"] = new_position
-                res = Queue.objects(entries__task__ne=task_id, **query).update_one(
-                    __raw__=inst
-                )
-                if not res:
-                    raise errors.bad_request.FailedAddingDuringReposition(
-                        task=task_id, **query
-                    )
+            without_entry = {
+                "$filter": {
+                    "input": "$entries",
+                    "as": "entry",
+                    "cond": {"$ne": ["$$entry.task", task_id]},
+                }
+            }
+            task_entry = {
+                "$filter": {
+                    "input": "$entries",
+                    "as": "entry",
+                    "cond": {"$eq": ["$$entry.task", task_id]},
+                }
+            }
+            if move_count == MOVE_FIRST:
+                operations = [
+                    {
+                        "$set": {
+                            "entries": {"$concatArrays": [task_entry, without_entry]}
+                        }
+                    }
+                ]
+            elif move_count == MOVE_LAST:
+                operations = [
+                    {
+                        "$set": {
+                            "entries": {"$concatArrays": [without_entry, task_entry]}
+                        }
+                    }
+                ]
+            else:
+                operations = [
+                    {
+                        "$set": {
+                            "new_pos": {
+                                "$add": [
+                                    {"$indexOfArray": ["$entries.task", task_id]},
+                                    move_count,
+                                ]
+                            },
+                            "without_entry": without_entry,
+                            "task_entry": task_entry,
+                        }
+                    },
+                    {
+                        "$set": {
+                            "entries": {
+                                "$switch": {
+                                    "branches": [
+                                        {
+                                            "case": {"$lte": ["$new_pos", 0]},
+                                            "then": {
+                                                "$concatArrays": [
+                                                    "$task_entry",
+                                                    "$without_entry",
+                                                ]
+                                            },
+                                        },
+                                        {
+                                            "case": {
+                                                "$gte": [
+                                                    "$new_pos",
+                                                    {"$size": "$without_entry"},
+                                                ]
+                                            },
+                                            "then": {
+                                                "$concatArrays": [
+                                                    "$without_entry",
+                                                    "$task_entry",
+                                                ]
+                                            },
+                                        },
+                                    ],
+                                    "default": {
+                                        "$concatArrays": [
+                                            {"$slice": ["$without_entry", "$new_pos"]},
+                                            "$task_entry",
+                                            {
+                                                "$slice": [
+                                                    "$without_entry",
+                                                    "$new_pos",
+                                                    {"$size": "$without_entry"},
+                                                ]
+                                            },
+                                        ]
+                                    },
+                                }
+                            }
+                        }
+                    },
+                    {"$unset": ["new_pos", "without_entry", "task_entry"]},
+                ]
 
-            return new_position
+            updated = Queue.objects(
+                id=queue_id, company=company_id, entries__task=task_id
+            ).update_one(__raw__=operations)
+
+            if not updated:
+                raise errors.bad_request.FailedAddingDuringReposition(task=task_id)
+
+            return get_queue_and_task_position()[1]
 
     def count_entries(self, company: str, queue_id: str) -> Optional[int]:
         res = next(

apiserver/bll/queue/queue_metrics.py

@@ -80,7 +80,7 @@ class QueueMetrics:
         logged = 0
         for q in queues:
             queue_doc = make_doc(q)
-            self.es.index(index=es_index, body=queue_doc)
+            self.es.index(index=es_index, document=queue_doc)
             redis_key = _queue_metrics_key_pattern.format(queue=q.id)
             redis.set(redis_key, json.dumps(queue_doc))
             logged += 1

apiserver/bll/statistics/stats_reporter.py

@@ -8,8 +8,7 @@ from typing import Sequence, Optional
 
 import dpath
 import requests
-from requests.adapters import HTTPAdapter
-from requests.packages.urllib3.util.retry import Retry
+from requests.adapters import HTTPAdapter, Retry
 
 from apiserver.bll.query import Builder as QueryBuilder
 from apiserver.bll.util import get_server_uuid
@@ -19,7 +18,7 @@ from apiserver.config.info import get_deployment_type
 from apiserver.database.model import Company, User
 from apiserver.database.model.queue import Queue
 from apiserver.database.model.task.task import Task
-from apiserver.tools import safe_get
+from apiserver.utilities.dicts import nested_get
 from apiserver.utilities.json import dumps
 from apiserver.version import __version__ as current_version
 from .resource_monitor import ResourceMonitor, stat_threads
@@ -163,7 +162,7 @@ class StatisticsReporter:
         def _get_cardinality_fields(categories: Sequence[dict]) -> dict:
             names = {"cpu": "num_cores"}
             return {
-                names[c["key"]]: safe_get(c, "count/value")
+                names[c["key"]]: nested_get(c, ("count", "value"))
                 for c in categories
                 if c["key"] in names
             }
@@ -176,21 +175,21 @@ class StatisticsReporter:
             }
             return {
                 names[m["key"]]: {
-                    "min": safe_get(m, "min/value"),
-                    "max": safe_get(m, "max/value"),
-                    "avg": safe_get(m, "avg/value"),
+                    "min": nested_get(m, ("min", "value")),
+                    "max": nested_get(m, ("max", "value")),
+                    "avg": nested_get(m, ("avg", "value")),
                 }
                 for m in metrics
                 if m["key"] in names
             }
 
-        buckets = safe_get(res, "aggregations/workers/buckets", default=[])
+        buckets = nested_get(res, ("aggregations", "workers", "buckets"), default=[])
         return {
             b["key"]: {
                 key: {
                     "interval_sec": agent_resource_threshold_sec,
-                    **_get_cardinality_fields(safe_get(b, "categories/buckets", [])),
-                    **_get_metric_fields(safe_get(b, "metrics/buckets", [])),
+                    **_get_cardinality_fields(nested_get(b, ("categories", "buckets"), [])),
+                    **_get_metric_fields(nested_get(b, ("metrics", "buckets"), [])),
                 }
             }
             for b in buckets
@@ -228,7 +227,7 @@ class StatisticsReporter:
             },
         }
         res = cls._run_worker_stats_query(company_id, es_req)
-        buckets = safe_get(res, "aggregations/workers/buckets", default=[])
+        buckets = nested_get(res, ("aggregations", "workers", "buckets"), default=[])
         return {
             b["key"]: {"last_activity_time": b["last_activity_time"]["value"]}
             for b in buckets
@@ -255,6 +254,14 @@ class StatisticsReporter:
                     **({"last_worker": {"$in": workers}} if workers else {}),
                 }
             },
+            {
+                "$project": {
+                    "last_worker": 1,
+                    "last_update": 1,
+                    "started": 1,
+                    "last_iteration": 1,
+                }
+            },
             {
                 "$group": {
                     "_id": "$last_worker" if workers else None,

apiserver/bll/storage/__init__.py

@@ -0,0 +1,48 @@
+from copy import copy
+
+from boltons.cacheutils import cachedproperty
+from clearml.backend_config.bucket_config import (
+    S3BucketConfigurations,
+    AzureContainerConfigurations,
+    GSBucketConfigurations,
+)
+
+from apiserver.config_repo import config
+
+
+log = config.logger(__file__)
+
+
+class StorageBLL:
+    default_aws_configs: S3BucketConfigurations = None
+    conf = config.get("services.storage_credentials")
+
+    @cachedproperty
+    def _default_aws_configs(self) -> S3BucketConfigurations:
+        return S3BucketConfigurations.from_config(self.conf.get("aws.s3"))
+
+    @cachedproperty
+    def _default_azure_configs(self) -> AzureContainerConfigurations:
+        return AzureContainerConfigurations.from_config(self.conf.get("azure.storage"))
+
+    @cachedproperty
+    def _default_gs_configs(self) -> GSBucketConfigurations:
+        return GSBucketConfigurations.from_config(self.conf.get("google.storage"))
+
+    def get_azure_settings_for_company(
+        self,
+        company_id: str,
+    ) -> AzureContainerConfigurations:
+        return copy(self._default_azure_configs)
+
+    def get_gs_settings_for_company(
+        self,
+        company_id: str,
+    ) -> GSBucketConfigurations:
+        return copy(self._default_gs_configs)
+
+    def get_aws_settings_for_company(
+        self,
+        company_id: str,
+    ) -> S3BucketConfigurations:
+        return copy(self._default_aws_configs)

apiserver/bll/task/__init__.py

@@ -1,6 +1,5 @@
 from .task_bll import TaskBLL
 from .utils import (
     ChangeStatusRequest,
-    update_project_time,
     validate_status_change,
 )

apiserver/bll/task/artifacts.py

@@ -5,6 +5,7 @@ from apiserver.apimodels.tasks import Artifact as ApiArtifact, ArtifactId
 from apiserver.bll.task.utils import get_task_for_update, update_task
 from apiserver.database.model.task.task import DEFAULT_ARTIFACT_MODE, Artifact
 from apiserver.database.utils import hash_field_name
+from apiserver.service_repo.auth import Identity
 from apiserver.utilities.dicts import nested_get, nested_set
 from apiserver.utilities.parameter_key_escaper import mongoengine_safe
 
@@ -48,11 +49,14 @@ class Artifacts:
     def add_or_update_artifacts(
         cls,
         company_id: str,
+        identity: Identity,
         task_id: str,
         artifacts: Sequence[ApiArtifact],
         force: bool,
     ) -> int:
-        task = get_task_for_update(company_id=company_id, task_id=task_id, force=force,)
+        task = get_task_for_update(
+            company_id=company_id, task_id=task_id, force=force, identity=identity
+        )
 
         artifacts = {
             get_artifact_id(a): Artifact(**a)
@@ -63,17 +67,20 @@ class Artifacts:
             f"set__execution__artifacts__{mongoengine_safe(name)}": value
             for name, value in artifacts.items()
         }
-        return update_task(task, update_cmds=update_cmds)
+        return update_task(task, user_id=identity.user, update_cmds=update_cmds)
 
     @classmethod
     def delete_artifacts(
         cls,
         company_id: str,
+        identity: Identity,
         task_id: str,
         artifact_ids: Sequence[ArtifactId],
         force: bool,
     ) -> int:
-        task = get_task_for_update(company_id=company_id, task_id=task_id, force=force,)
+        task = get_task_for_update(
+            company_id=company_id, task_id=task_id, force=force, identity=identity
+        )
 
         artifact_ids = [
             get_artifact_id(a)
@@ -83,4 +90,4 @@ class Artifacts:
             f"unset__execution__artifacts__{id_}": 1 for id_ in set(artifact_ids)
         }
 
-        return update_task(task, update_cmds=delete_cmds)
+        return update_task(task, user_id=identity.user, update_cmds=delete_cmds)

apiserver/bll/task/hyperparams.py

@@ -15,6 +15,7 @@ from apiserver.bll.task import TaskBLL
 from apiserver.bll.task.utils import get_task_for_update, update_task
 from apiserver.config_repo import config
 from apiserver.database.model.task.task import ParamsItem, Task, ConfigurationItem
+from apiserver.service_repo.auth import Identity
 from apiserver.utilities.parameter_key_escaper import (
     ParameterKeyEscaper,
     mongoengine_safe,
@@ -31,7 +32,10 @@ class HyperParams:
     def get_params(cls, company_id: str, task_ids: Sequence[str]) -> Dict[str, dict]:
         only = ("id", "hyperparams")
         tasks = task_bll.assert_exists(
-            company_id=company_id, task_ids=task_ids, only=only, allow_public=True,
+            company_id=company_id,
+            task_ids=task_ids,
+            only=only,
+            allow_public=True,
         )
 
         return {
@@ -63,6 +67,7 @@ class HyperParams:
     def delete_params(
         cls,
         company_id: str,
+        identity: Identity,
         task_id: str,
         hyperparams: Sequence[HyperParamKey],
         force: bool,
@@ -73,6 +78,7 @@ class HyperParams:
             task_id=task_id,
             allow_all_statuses=properties_only,
             force=force,
+            identity=identity,
         )
 
         with_param, without_param = iterutils.partition(
@@ -94,13 +100,17 @@ class HyperParams:
             delete_cmds[f"unset__hyperparams__{section}__{name}"] = 1
 
         return update_task(
-            task, update_cmds=delete_cmds, set_last_update=not properties_only
+            task,
+            user_id=identity.user,
+            update_cmds=delete_cmds,
+            set_last_update=not properties_only,
         )
 
     @classmethod
     def edit_params(
         cls,
         company_id: str,
+        identity: Identity,
         task_id: str,
         hyperparams: Sequence[HyperParamItem],
         replace_hyperparams: str,
@@ -112,6 +122,7 @@ class HyperParams:
             task_id=task_id,
             allow_all_statuses=properties_only,
             force=force,
+            identity=identity,
         )
 
         update_cmds = dict()
@@ -129,7 +140,10 @@ class HyperParams:
                     ] = value
 
         return update_task(
-            task, update_cmds=update_cmds, set_last_update=not properties_only
+            task,
+            user_id=identity.user,
+            update_cmds=update_cmds,
+            set_last_update=not properties_only,
         )
 
     @classmethod
@@ -155,7 +169,10 @@ class HyperParams:
         else:
             only.append("configuration")
         tasks = task_bll.assert_exists(
-            company_id=company_id, task_ids=task_ids, only=only, allow_public=True,
+            company_id=company_id,
+            task_ids=task_ids,
+            only=only,
+            allow_public=True,
         )
 
         return {
@@ -201,12 +218,15 @@ class HyperParams:
     def edit_configuration(
         cls,
         company_id: str,
+        identity: Identity,
         task_id: str,
         configuration: Sequence[Configuration],
         replace_configuration: bool,
         force: bool,
     ) -> int:
-        task = get_task_for_update(company_id=company_id, task_id=task_id, force=force)
+        task = get_task_for_update(
+            company_id=company_id, task_id=task_id, force=force, identity=identity
+        )
 
         update_cmds = dict()
         configuration = {
@@ -219,17 +239,24 @@ class HyperParams:
             for name, value in configuration.items():
                 update_cmds[f"set__configuration__{mongoengine_safe(name)}"] = value
 
-        return update_task(task, update_cmds=update_cmds)
+        return update_task(task, user_id=identity.user, update_cmds=update_cmds)
 
     @classmethod
     def delete_configuration(
-        cls, company_id: str, task_id: str, configuration: Sequence[str], force: bool
+        cls,
+        company_id: str,
+        identity: Identity,
+        task_id: str,
+        configuration: Sequence[str],
+        force: bool,
     ) -> int:
-        task = get_task_for_update(company_id=company_id, task_id=task_id, force=force)
+        task = get_task_for_update(
+            company_id=company_id, task_id=task_id, force=force, identity=identity
+        )
 
         delete_cmds = {
             f"unset__configuration__{ParameterKeyEscaper.escape(name)}": 1
             for name in set(configuration)
         }
 
-        return update_task(task, update_cmds=delete_cmds)
+        return update_task(task, user_id=identity.user, update_cmds=delete_cmds)

apiserver/bll/task/non_responsive_tasks_watchdog.py

@@ -1,7 +1,7 @@
 from datetime import timedelta, datetime
 from time import sleep
 
-from apiserver.bll.task import update_project_time
+from apiserver.bll.util import update_project_time
 from apiserver.config_repo import config
 from apiserver.database.model.task.task import TaskStatus, Task
 from apiserver.utilities.threads_manager import ThreadsManager
@@ -85,6 +85,7 @@ class NonResponsiveTasksWatchdog:
                     status_changed=now,
                     last_update=now,
                     last_change=now,
+                    last_changed_by="__apiserver__",
                 )
                 if updated:
                     project_ids.add(task.project)

apiserver/bll/task/task_bll.py

@@ -7,11 +7,12 @@ from redis import StrictRedis
 from six import string_types
 
 import apiserver.database.utils as dbutils
-from apiserver.apierrors import errors
+from apiserver.apierrors import errors, APIError
 from apiserver.apimodels.tasks import TaskInputModel
 from apiserver.bll.queue import QueueBLL
 from apiserver.bll.organization import OrgBLL, Tags
 from apiserver.bll.project import ProjectBLL
+from apiserver.bll.util import update_project_time
 from apiserver.config_repo import config
 from apiserver.database.errors import translate_errors_context
 from apiserver.database.model.model import Model
@@ -30,17 +31,20 @@ from apiserver.database.model.task.task import (
     TaskModelTypes,
 )
 from apiserver.database.model import EntityVisibility
-from apiserver.database.utils import get_company_or_none_constraint, id as create_id
+from apiserver.database.model.queue import Queue
+from apiserver.database.utils import (
+    get_company_or_none_constraint,
+    id as create_id,
+)
 from apiserver.es_factory import es_factory
 from apiserver.redis_manager import redman
-from apiserver.service_repo import APICall
 from apiserver.services.utils import validate_tags, escape_dict_field, escape_dict
 from .artifacts import artifacts_prepare_for_save
 from .param_utils import params_prepare_for_save
 from .utils import (
     ChangeStatusRequest,
-    update_project_time,
     deleted_prefix,
+    get_last_metric_updates,
 )
 
 log = config.logger(__file__)
@@ -54,30 +58,13 @@ class TaskBLL:
         self.events_es = events_es or es_factory.connect("events")
         self.redis: StrictRedis = redis or redman.connection("apiserver")
 
-    @staticmethod
-    def get_task_with_access(
-        task_id, company_id, only=None, allow_public=False, requires_write_access=False
-    ) -> Task:
-        """
-        Gets a task that has a required write access
-        :except errors.bad_request.InvalidTaskId: if the task is not found
-        :except errors.forbidden.NoWritePermission: if write_access was required and the task cannot be modified
-        """
-        with translate_errors_context():
-            query = dict(id=task_id, company=company_id)
-            if requires_write_access:
-                task = Task.get_for_writing(_only=only, **query)
-            else:
-                task = Task.get(_only=only, **query, include_public=allow_public)
-
-            if not task:
-                raise errors.bad_request.InvalidTaskId(**query)
-
-            return task
-
     @staticmethod
     def get_by_id(
-        company_id, task_id, required_status=None, only_fields=None, allow_public=False,
+        company_id,
+        task_id,
+        required_status=None,
+        only_fields=None,
+        allow_public=False,
     ):
         if only_fields:
             if isinstance(only_fields, string_types):
@@ -128,16 +115,16 @@ class TaskBLL:
                 return list(q)
 
     @staticmethod
-    def create(call: APICall, fields: dict):
-        identity = call.identity
+    def create(company: str, user: str, fields: dict):
         now = datetime.utcnow()
         return Task(
             id=create_id(),
-            user=identity.user,
-            company=identity.company,
+            user=user,
+            company=company,
             created=now,
             last_update=now,
             last_change=now,
+            last_changed_by=user,
             **fields,
         )
 
@@ -257,6 +244,16 @@ class TaskBLL:
                 not in [TaskSystemTags.development, EntityVisibility.archived.value]
             ]
 
+        def ensure_int_labels(execution: dict) -> dict:
+            if not execution:
+                return execution
+
+            model_labels = execution.get("model_labels")
+            if model_labels:
+                execution["model_labels"] = {k: int(v) for k, v in model_labels.items()}
+
+            return execution
+
         parent_task = (
             task.parent
             if task.parent and not task.parent.startswith(deleted_prefix)
@@ -269,6 +266,7 @@ class TaskBLL:
             created=now,
             last_update=now,
             last_change=now,
+            last_changed_by=user_id,
             name=name or task.name,
             comment=comment or task.comment,
             parent=parent or parent_task,
@@ -280,7 +278,7 @@ class TaskBLL:
             output=Output(destination=task.output.destination) if task.output else None,
             models=Models(input=input_models or task.models.input),
             container=escape_dict(container) or task.container,
-            execution=execution_dict,
+            execution=ensure_int_labels(execution_dict),
             configuration=params_dict.get("configuration") or task.configuration,
             hyperparams=params_dict.get("hyperparams") or task.hyperparams,
         )
@@ -301,7 +299,7 @@ class TaskBLL:
         org_bll.update_tags(
             company_id,
             Tags.Task,
-            project=new_task.project,
+            projects=[new_task.project],
             tags=updated_tags,
             system_tags=updated_system_tags,
         )
@@ -344,6 +342,7 @@ class TaskBLL:
     def set_last_update(
         task_ids: Collection[str],
         company_id: str,
+        user_id: str,
         last_update: datetime,
         **extra_updates,
     ):
@@ -364,6 +363,7 @@ class TaskBLL:
                 upsert=False,
                 last_update=last_update,
                 last_change=last_update,
+                last_changed_by=user_id,
                 **updates,
             )
         return count
@@ -372,6 +372,7 @@ class TaskBLL:
     def update_statistics(
         task_id: str,
         company_id: str,
+        user_id: str,
         last_update: datetime = None,
         last_iteration: int = None,
         last_iteration_max: int = None,
@@ -400,50 +401,21 @@ class TaskBLL:
         elif last_iteration_max is not None:
             extra_updates.update(max__last_iteration=last_iteration_max)
 
+        raw_updates = {}
         if last_scalar_events is not None:
-            max_values = config.get("services.tasks.max_last_metrics", 2000)
-            total_metrics = set()
-            if max_values:
-                query = dict(id=task_id)
-                to_add = sum(len(v) for m, v in last_scalar_events.items())
-                if to_add <= max_values:
-                    query[f"unique_metrics__{max_values-to_add}__exists"] = True
-                task = Task.objects(**query).only("unique_metrics").first()
-                if task and task.unique_metrics:
-                    total_metrics = set(task.unique_metrics)
-
-            new_metrics = []
-            for metric_key, metric_data in last_scalar_events.items():
-                for variant_key, variant_data in metric_data.items():
-                    metric = (
-                        f"{variant_data.get('metric')}/{variant_data.get('variant')}"
-                    )
-                    if max_values:
-                        if (
-                            len(total_metrics) >= max_values
-                            and metric not in total_metrics
-                        ):
-                            continue
-                        total_metrics.add(metric)
-
-                    new_metrics.append(metric)
-                    path = f"last_metrics__{metric_key}__{variant_key}"
-                    for key, value in variant_data.items():
-                        if key == "min_value":
-                            extra_updates[f"min__{path}__min_value"] = value
-                        elif key == "max_value":
-                            extra_updates[f"max__{path}__max_value"] = value
-                        elif key in ("metric", "variant", "value"):
-                            extra_updates[f"set__{path}__{key}"] = value
-            if new_metrics:
-                extra_updates["add_to_set__unique_metrics"] = new_metrics
+            get_last_metric_updates(
+                task_id=task_id,
+                last_scalar_events=last_scalar_events,
+                raw_updates=raw_updates,
+                extra_updates=extra_updates,
+            )
 
         if last_events is not None:
 
-            def events_per_type(metric_data: Dict[str, dict]) -> Dict[str, EventStats]:
+            def events_per_type(metric_data_: Dict[str, dict]) -> Dict[str, EventStats]:
                 return {
                     event_type: EventStats(last_update=event["timestamp"])
-                    for event_type, event in metric_data.items()
+                    for event_type, event in metric_data_.items()
                 }
 
             metric_stats = {
@@ -454,28 +426,54 @@ class TaskBLL:
             }
             extra_updates["metric_stats"] = metric_stats
 
-        return TaskBLL.set_last_update(
+        ret = TaskBLL.set_last_update(
             task_ids=[task_id],
             company_id=company_id,
+            user_id=user_id,
             last_update=last_update,
             **extra_updates,
         )
+        if ret and raw_updates:
+            Task.objects(id=task_id).update_one(__raw__=[{"$set": raw_updates}])
+
+        return ret
+
+    @staticmethod
+    def remove_task_from_all_queues(company_id: str, task_id: str) -> int:
+        return Queue.objects(company=company_id, entries__task=task_id).update(
+            pull__entries__task=task_id, last_update=datetime.utcnow()
+        )
 
     @classmethod
     def dequeue_and_change_status(
-        cls, task: Task, company_id: str, status_message: str, status_reason: str,
+        cls,
+        task: Task,
+        company_id: str,
+        user_id: str,
+        status_message: str,
+        status_reason: str,
+        remove_from_all_queues=False,
+        new_status=None,
     ):
         try:
-            cls.dequeue(task, company_id)
-        except errors.bad_request.InvalidQueueOrTaskNotQueued:
+            cls.dequeue(task, company_id, silent_fail=True)
+        except APIError:
             # dequeue may fail if the queue was deleted
             pass
 
+        if remove_from_all_queues:
+            cls.remove_task_from_all_queues(company_id=company_id, task_id=task.id)
+
+        if task.status not in [TaskStatus.queued, TaskStatus.in_progress]:
+            return {"updated": 0}
+
         return ChangeStatusRequest(
             task=task,
-            new_status=task.enqueue_status or TaskStatus.created,
+            new_status=new_status or task.enqueue_status or TaskStatus.created,
             status_reason=status_reason,
             status_message=status_message,
+            user_id=user_id,
+            force=True,
         ).execute(enqueue_status=None)
 
     @classmethod

apiserver/bll/task/task_cleanup.py

@@ -1,10 +1,11 @@
 from datetime import datetime
 from itertools import chain
 from operator import attrgetter
-from typing import Sequence, Set, Tuple
+from typing import Sequence, Set, Tuple, Union
 
 import attr
-from boltons.iterutils import partition, bucketize, first
+from boltons.iterutils import partition, bucketize, first, chunked_iter
+from furl import furl
 from mongoengine import NotUniqueError
 from pymongo.errors import DuplicateKeyError
 
@@ -25,7 +26,6 @@ from apiserver.database.utils import id as db_id
 
 log = config.logger(__file__)
 event_bll = EventBLL()
-async_events_delete = config.get("services.tasks.async_events_delete", False)
 
 
 @attr.s(auto_attribs=True)
@@ -68,49 +68,74 @@ class CleanupResult:
         )
 
 
-def collect_plot_image_urls(company: str, task_or_model: str) -> Set[str]:
+def collect_plot_image_urls(
+    company: str, task_or_model: Union[str, Sequence[str]]
+) -> Set[str]:
     urls = set()
-    next_scroll_id = None
-    while True:
-        events, next_scroll_id = event_bll.get_plot_image_urls(
-            company_id=company, task_id=task_or_model, scroll_id=next_scroll_id
-        )
-        if not events:
-            break
-        for event in events:
-            event_urls = event.get(PlotFields.source_urls)
-            if event_urls:
-                urls.update(set(event_urls))
+    task_ids = task_or_model if isinstance(task_or_model, list) else [task_or_model]
+    for tasks in chunked_iter(task_ids, 100):
+        next_scroll_id = None
+        while True:
+            events, next_scroll_id = event_bll.get_plot_image_urls(
+                company_id=company, task_ids=tasks, scroll_id=next_scroll_id
+            )
+            if not events:
+                break
+            for event in events:
+                event_urls = event.get(PlotFields.source_urls)
+                if event_urls:
+                    urls.update(set(event_urls))
 
     return urls
 
 
-def collect_debug_image_urls(company: str, task_or_model: str) -> Set[str]:
+def collect_debug_image_urls(
+    company: str, task_or_model: Union[str, Sequence[str]]
+) -> Set[str]:
     """
     Return the set of unique image urls
     Uses DebugImagesIterator to make sure that we do not retrieve recycled urls
     """
-    after_key = None
     urls = set()
-    while True:
-        res, after_key = event_bll.get_debug_image_urls(
-            company_id=company, task_id=task_or_model, after_key=after_key,
-        )
-        urls.update(res)
-        if not after_key:
-            break
+    task_ids = task_or_model if isinstance(task_or_model, list) else [task_or_model]
+    for tasks in chunked_iter(task_ids, 100):
+        after_key = None
+        while True:
+            res, after_key = event_bll.get_debug_image_urls(
+                company_id=company,
+                task_ids=tasks,
+                after_key=after_key,
+            )
+            urls.update(res)
+            if not after_key:
+                break
 
     return urls
 
 
 supported_storage_types = {
-    "https://": StorageType.fileserver,
-    "http://": StorageType.fileserver,
+    "s3://": StorageType.s3,
+    "azure://": StorageType.azure,
+    "gs://": StorageType.gs,
 }
 
+supported_storage_types.update(
+    {
+        p: StorageType.fileserver
+        for p in config.get(
+            "services.async_urls_delete.fileserver.url_prefixes",
+            ["https://", "http://"],
+        )
+    }
+)
+
 
 def _schedule_for_delete(
-    company: str, user: str, task_id: str, urls: Set[str], can_delete_folders: bool,
+    company: str,
+    user: str,
+    task_id: str,
+    urls: Set[str],
+    can_delete_folders: bool,
 ) -> Set[str]:
     urls_per_storage = bucketize(
         urls,
@@ -129,7 +154,14 @@ def _schedule_for_delete(
         for url in storage_urls:
             folder = None
             if delete_folders:
-                folder, _, _ = url.rpartition("/")
+                try:
+                    parsed = furl(url)
+                    if parsed.path and len(parsed.path.segments) > 1:
+                        folder = parsed.remove(
+                            args=True, fragment=True, path=parsed.path.segments[-1]
+                        ).url.rstrip("/")
+                except Exception as ex:
+                    pass
 
             to_delete = folder or url
             if to_delete in scheduled_to_delete:
@@ -185,7 +217,7 @@ def cleanup_task(
         task, force
     )
     delete_external_artifacts = delete_external_artifacts and config.get(
-        "services.async_urls_delete.enabled", False
+        "services.async_urls_delete.enabled", True
     )
     event_urls, artifact_urls, model_urls = set(), set(), set()
     if return_file_urls or delete_external_artifacts:
@@ -203,8 +235,13 @@ def cleanup_task(
 
     deleted_task_id = f"{deleted_prefix}{task.id}"
     updated_children = 0
+    now = datetime.utcnow()
     if update_children:
-        updated_children = Task.objects(parent=task.id).update(parent=deleted_task_id)
+        updated_children = Task.objects(parent=task.id).update(
+            parent=deleted_task_id,
+            last_change=now,
+            last_changed_by=user,
+        )
 
     deleted_models = 0
     updated_models = 0
@@ -212,37 +249,41 @@ def cleanup_task(
         if not models:
             continue
         if delete_output_models and allow_delete:
-            model_ids = set(m.id for m in models if m.id not in in_use_model_ids)
-            for m_id in model_ids:
+            model_ids = list({m.id for m in models if m.id not in in_use_model_ids})
+            if model_ids:
                 if return_file_urls or delete_external_artifacts:
-                    event_urls.update(collect_debug_image_urls(task.company, m_id))
-                    event_urls.update(collect_plot_image_urls(task.company, m_id))
-                try:
-                    event_bll.delete_task_events(
-                        task.company,
-                        m_id,
-                        allow_locked=True,
-                        model=True,
-                        async_delete=async_events_delete,
-                    )
-                except errors.bad_request.InvalidModelId as ex:
-                    log.info(f"Error deleting events for the model {m_id}: {str(ex)}")
+                    event_urls.update(collect_debug_image_urls(task.company, model_ids))
+                    event_urls.update(collect_plot_image_urls(task.company, model_ids))
+
+                event_bll.delete_multi_task_events(
+                    task.company,
+                    model_ids,
+                    model=True,
+                )
+                deleted_models += Model.objects(id__in=model_ids).delete()
 
-            deleted_models += Model.objects(id__in=list(model_ids)).delete()
             if in_use_model_ids:
-                Model.objects(id__in=list(in_use_model_ids)).update(unset__task=1)
+                Model.objects(id__in=list(in_use_model_ids)).update(
+                    unset__task=1,
+                    set__last_change=now,
+                    set__last_changed_by=user,
+                )
             continue
 
         if update_children:
             updated_models += Model.objects(id__in=[m.id for m in models]).update(
-                task=deleted_task_id
+                task=deleted_task_id,
+                last_change=now,
+                last_changed_by=user,
             )
         else:
-            Model.objects(id__in=[m.id for m in models]).update(unset__task=1)
+            Model.objects(id__in=[m.id for m in models]).update(
+                unset__task=1,
+                set__last_change=now,
+                set__last_changed_by=user,
+            )
 
-    event_bll.delete_task_events(
-        task.company, task.id, allow_locked=force, async_delete=async_events_delete
-    )
+    event_bll.delete_task_events(task.company, task.id, allow_locked=force)
 
     if delete_external_artifacts:
         scheduled = _schedule_for_delete(
@@ -285,7 +326,8 @@ def verify_task_children_and_ouptuts(
 
     model_fields = ["id", "ready", "uri"]
     published_models, draft_models = partition(
-        Model.objects(task=task.id).only(*model_fields), key=attrgetter("ready"),
+        Model.objects(task=task.id).only(*model_fields),
+        key=attrgetter("ready"),
     )
     if not force and published_models:
         raise errors.bad_request.TaskCannotBeDeleted(

apiserver/bll/task/task_operations.py

@@ -7,9 +7,10 @@ from apiserver.bll.task import (
     TaskBLL,
     validate_status_change,
     ChangeStatusRequest,
-    update_project_time,
 )
 from apiserver.bll.task.task_cleanup import cleanup_task, CleanupResult
+from apiserver.bll.task.utils import get_task_with_write_access
+from apiserver.bll.util import update_project_time
 from apiserver.config_repo import config
 from apiserver.database.model import EntityVisibility
 from apiserver.database.model.model import Model
@@ -23,6 +24,8 @@ from apiserver.database.model.task.task import (
     Execution,
     DEFAULT_LAST_ITERATION,
 )
+from apiserver.database.utils import get_options
+from apiserver.service_repo.auth import Identity
 from apiserver.utilities.dicts import nested_set
 
 log = config.logger(__file__)
@@ -30,29 +33,41 @@ queue_bll = QueueBLL()
 
 
 def archive_task(
-    task: Union[str, Task], company_id: str, status_message: str, status_reason: str,
+    task: Union[str, Task],
+    company_id: str,
+    identity: Identity,
+    status_message: str,
+    status_reason: str,
 ) -> int:
     """
     Deque and archive task
     Return 1 if successful
     """
     if isinstance(task, str):
-        task = TaskBLL.get_task_with_access(
+        task = get_task_with_write_access(
             task,
             company_id=company_id,
+            identity=identity,
             only=(
                 "id",
+                "company",
                 "execution",
                 "status",
                 "project",
                 "system_tags",
                 "enqueue_status",
             ),
-            requires_write_access=True,
         )
+
+    user_id = identity.user
     try:
         TaskBLL.dequeue_and_change_status(
-            task, company_id, status_message, status_reason,
+            task,
+            company_id=company_id,
+            user_id=user_id,
+            status_message=status_message,
+            status_reason=status_reason,
+            remove_from_all_queues=True,
         )
     except APIError:
         # dequeue may fail if the task was not enqueued
@@ -63,36 +78,81 @@ def archive_task(
         status_reason=status_reason,
         add_to_set__system_tags=EntityVisibility.archived.value,
         last_change=datetime.utcnow(),
+        last_changed_by=user_id,
     )
 
 
 def unarchive_task(
-    task: str, company_id: str, status_message: str, status_reason: str,
+    task_id: str,
+    company_id: str,
+    identity: Identity,
+    status_message: str,
+    status_reason: str,
 ) -> int:
     """
     Unarchive task. Return 1 if successful
     """
-    task = TaskBLL.get_task_with_access(
-        task, company_id=company_id, only=("id",), requires_write_access=True,
+    task = get_task_with_write_access(
+        task_id,
+        company_id=company_id,
+        identity=identity,
+        only=("id",),
     )
     return task.update(
         status_message=status_message,
         status_reason=status_reason,
         pull__system_tags=EntityVisibility.archived.value,
         last_change=datetime.utcnow(),
+        last_changed_by=identity.user,
     )
 
 
 def dequeue_task(
-    task_id: str, company_id: str, status_message: str, status_reason: str,
+    task_id: str,
+    company_id: str,
+    identity: Identity,
+    status_message: str,
+    status_reason: str,
+    remove_from_all_queues: bool = False,
+    new_status=None,
 ) -> Tuple[int, dict]:
-    query = dict(id=task_id, company=company_id)
-    task = Task.get_for_writing(**query)
+    if new_status and new_status not in get_options(TaskStatus):
+        raise errors.bad_request.ValidationError(f"Invalid task status: {new_status}")
+
+    # get the task without write access to make sure that it actually exists
+    task = Task.get(
+        id=task_id,
+        company=company_id,
+        _only=("id",),
+        include_public=True,
+    )
     if not task:
-        raise errors.bad_request.InvalidTaskId(**query)
+        TaskBLL.remove_task_from_all_queues(company_id, task_id=task_id)
+        return 1, {"updated": 0}
+
+    user_id = identity.user
+    task = get_task_with_write_access(
+        task_id,
+        company_id=company_id,
+        identity=identity,
+        only=(
+            "id",
+            "company",
+            "execution",
+            "status",
+            "project",
+            "enqueue_status",
+        ),
+    )
 
     res = TaskBLL.dequeue_and_change_status(
-        task, company_id, status_message=status_message, status_reason=status_reason,
+        task,
+        company_id=company_id,
+        user_id=user_id,
+        status_message=status_message,
+        status_reason=status_reason,
+        remove_from_all_queues=remove_from_all_queues,
+        new_status=new_status,
     )
     return 1, res
 
@@ -100,6 +160,7 @@ def dequeue_task(
 def enqueue_task(
     task_id: str,
     company_id: str,
+    identity: Identity,
     queue_id: str,
     status_message: str,
     status_reason: str,
@@ -124,11 +185,11 @@ def enqueue_task(
         # try to get default queue
         queue_id = queue_bll.get_default(company_id).id
 
-    query = dict(id=task_id, company=company_id)
-    task = Task.get_for_writing(**query)
-    if not task:
-        raise errors.bad_request.InvalidTaskId(**query)
+    task = get_task_with_write_access(
+        task_id=task_id, company_id=company_id, identity=identity
+    )
 
+    user_id = identity.user
     if validate:
         TaskBLL.validate(task)
 
@@ -139,6 +200,7 @@ def enqueue_task(
         status_message=status_message,
         allow_same_state_transition=False,
         force=force,
+        user_id=user_id,
     ).execute(enqueue_status=task.status)
 
     try:
@@ -151,14 +213,15 @@ def enqueue_task(
             new_status=task.status,
             force=True,
             status_reason="failed enqueueing",
+            user_id=user_id,
         ).execute(enqueue_status=None)
         raise
 
     # set the current queue ID in the task
     if task.execution:
-        Task.objects(**query).update(execution__queue=queue_id, multi=False)
+        Task.objects(id=task_id).update(execution__queue=queue_id, multi=False)
     else:
-        Task.objects(**query).update(execution=Execution(queue=queue_id), multi=False)
+        Task.objects(id=task_id).update(execution=Execution(queue=queue_id), multi=False)
 
     nested_set(res, ("fields", "execution.queue"), queue_id)
     return 1, res
@@ -191,7 +254,7 @@ def move_tasks_to_trash(tasks: Sequence[str]) -> int:
 def delete_task(
     task_id: str,
     company_id: str,
-    user_id: str,
+    identity: Identity,
     move_to_trash: bool,
     force: bool,
     return_file_urls: bool,
@@ -200,8 +263,9 @@ def delete_task(
     status_reason: str,
     delete_external_artifacts: bool,
 ) -> Tuple[int, Task, CleanupResult]:
-    task = TaskBLL.get_task_with_access(
-        task_id, company_id=company_id, requires_write_access=True
+    user_id = identity.user
+    task = get_task_with_write_access(
+        task_id, company_id=company_id, identity=identity
     )
 
     if (
@@ -220,8 +284,10 @@ def delete_task(
         TaskBLL.dequeue_and_change_status(
             task,
             company_id=company_id,
+            user_id=user_id,
             status_message=status_message,
             status_reason=status_reason,
+            remove_from_all_queues=True,
         )
     except APIError:
         # dequeue may fail if the task was not enqueued
@@ -240,6 +306,7 @@ def delete_task(
     if move_to_trash:
         # make sure that whatever changes were done to the task are saved
         # the task itself will be deleted later in the move_tasks_to_trash operation
+        task.last_update = datetime.utcnow()
         task.save()
     else:
         task.delete()
@@ -251,15 +318,16 @@ def delete_task(
 def reset_task(
     task_id: str,
     company_id: str,
-    user_id: str,
+    identity: Identity,
     force: bool,
     return_file_urls: bool,
     delete_output_models: bool,
     clear_all: bool,
     delete_external_artifacts: bool,
 ) -> Tuple[dict, CleanupResult, dict]:
-    task = TaskBLL.get_task_with_access(
-        task_id, company_id=company_id, requires_write_access=True
+    user_id = identity.user
+    task = get_task_with_write_access(
+        task_id, company_id=company_id, identity=identity
     )
 
     if not force and task.status == TaskStatus.published:
@@ -274,6 +342,8 @@ def reset_task(
         # dequeue may fail if the task was not enqueued
         pass
 
+    TaskBLL.remove_task_from_all_queues(company_id=company_id, task_id=task.id)
+
     cleaned_up = cleanup_task(
         company=company_id,
         user=user_id,
@@ -296,11 +366,17 @@ def reset_task(
         unset__output__error=1,
         unset__last_worker=1,
         unset__last_worker_report=1,
+        unset__started=1,
+        unset__completed=1,
+        unset__published=1,
+        unset__active_duration=1,
+        unset__enqueue_status=1,
     )
 
     if clear_all:
         updates.update(
-            set__execution=Execution(), unset__script=1,
+            set__execution=Execution(),
+            unset__script=1,
         )
     else:
         updates.update(unset__execution__queue=1)
@@ -319,12 +395,8 @@ def reset_task(
         force=force,
         status_reason="reset",
         status_message="reset",
+        user_id=user_id,
     ).execute(
-        started=None,
-        completed=None,
-        published=None,
-        active_duration=None,
-        enqueue_status=None,
         **updates,
     )
 
@@ -334,13 +406,15 @@ def reset_task(
 def publish_task(
     task_id: str,
     company_id: str,
+    identity: Identity,
     force: bool,
-    publish_model_func: Callable[[str, str], Any] = None,
+    publish_model_func: Callable[[str, str, Identity], Any] = None,
     status_message: str = "",
     status_reason: str = "",
 ) -> dict:
-    task = TaskBLL.get_task_with_access(
-        task_id, company_id=company_id, requires_write_access=True
+    user_id = identity.user
+    task = get_task_with_write_access(
+        task_id, company_id=company_id, identity=identity
     )
     if not force:
         validate_status_change(task.status, TaskStatus.published)
@@ -363,7 +437,7 @@ def publish_task(
                 .first()
             )
             if model and not model.ready:
-                publish_model_func(model.id, company_id)
+                publish_model_func(model.id, company_id, identity)
 
         # set task status to published, and update (or set) it's new output (view and models)
         return ChangeStatusRequest(
@@ -372,6 +446,7 @@ def publish_task(
             force=force,
             status_reason=status_reason,
             status_message=status_message,
+            user_id=user_id,
         ).execute(published=datetime.utcnow(), output=output)
 
     except Exception as ex:
@@ -384,7 +459,12 @@ def publish_task(
 
 
 def stop_task(
-    task_id: str, company_id: str, user_name: str, status_reason: str, force: bool,
+    task_id: str,
+    company_id: str,
+    identity: Identity,
+    user_name: str,
+    status_reason: str,
+    force: bool,
 ) -> dict:
     """
     Stop a running task. Requires task status 'in_progress' and
@@ -394,10 +474,11 @@ def stop_task(
     is set to 'stopping' to allow the worker to stop the task and report by itself
     :return: updated task fields
     """
-
-    task = TaskBLL.get_task_with_access(
+    user_id = identity.user
+    task = get_task_with_write_access(
         task_id,
         company_id=company_id,
+        identity=identity,
         only=(
             "status",
             "project",
@@ -407,7 +488,6 @@ def stop_task(
             "last_update",
             "execution.queue",
         ),
-        requires_write_access=True,
     )
 
     def is_run_by_worker(t: Task) -> bool:
@@ -446,4 +526,5 @@ def stop_task(
         status_reason=status_reason,
         status_message=status_message,
         force=force,
+        user_id=user_id,
     ).execute()

apiserver/bll/task/utils.py

@@ -1,14 +1,18 @@
 from datetime import datetime
-from typing import Sequence, Union
+from typing import Sequence
 
 import attr
 import six
+from mongoengine import Q
 
 from apiserver.apierrors import errors
+from apiserver.bll.util import update_project_time
+from apiserver.config_repo import config
 from apiserver.database.errors import translate_errors_context
-from apiserver.database.model.project import Project
+from apiserver.database.model.model import Model
 from apiserver.database.model.task.task import Task, TaskStatus, TaskSystemTags
 from apiserver.database.utils import get_options
+from apiserver.service_repo.auth import Identity
 from apiserver.utilities.attrs import typed_attrs
 
 valid_statuses = get_options(TaskStatus)
@@ -26,6 +30,7 @@ class ChangeStatusRequest(object):
     force = attr.ib(type=bool, default=False)
     allow_same_state_transition = attr.ib(type=bool, default=True)
     current_status_override = attr.ib(default=None)
+    user_id = attr.ib(type=str, default=None)
 
     def execute(self, **kwargs):
         current_status = self.current_status_override or self.task.status
@@ -44,6 +49,7 @@ class ChangeStatusRequest(object):
             status_changed=now,
             last_update=now,
             last_change=now,
+            last_changed_by=self.user_id,
         )
 
         if self.new_status == TaskStatus.queued:
@@ -154,25 +160,78 @@ def get_possible_status_changes(current_status):
     return possible
 
 
-def update_project_time(project_ids: Union[str, Sequence[str]]):
-    if not project_ids:
-        return
+def get_many_tasks_for_writing(
+    company_id: str,
+    identity: Identity,
+    query: Q = None,
+    only: Sequence = None,
+    throw_on_forbidden: bool = True,
+) -> Sequence[Task]:
+    if only:
+        missing = [f for f in ("company", ) if f not in only]
+        if missing:
+            only = [*only, *missing]
 
-    if isinstance(project_ids, str):
-        project_ids = [project_ids]
+    result = list(
+        Task.get_many(
+            company=company_id,
+            query=query,
+            override_projection=only,
+            allow_public=True,
+            return_dicts=False,
+        )
+    )
 
-    return Project.objects(id__in=project_ids).update(last_update=datetime.utcnow())
+    if not company_id:
+        return result
+
+    forbidden_tasks = {task.id for task in result if not task.company}
+    if forbidden_tasks:
+        if throw_on_forbidden:
+            raise errors.forbidden.NoWritePermission(
+                f"cannot modify public task(s), ids={tuple(forbidden_tasks)}"
+            )
+        result = [task for task in result if task.id not in forbidden_tasks]
+
+    return result
+
+
+def get_task_with_write_access(
+    task_id: str,
+    company_id: str,
+    identity: Identity,
+    only=None,
+) -> Task:
+    """
+    Gets a task that has a required write access
+    :except errors.bad_request.InvalidTaskId: if the task is not found
+    :except errors.forbidden.NoWritePermission: if write_access was required and the task cannot be modified
+    """
+    query = dict(id=task_id, company=company_id)
+
+    task = Task.get_for_writing(_only=only, **query)
+    if not task:
+        raise errors.bad_request.InvalidTaskId(**query)
+
+    return task
 
 
 def get_task_for_update(
-    company_id: str, task_id: str, allow_all_statuses: bool = False, force: bool = False
+    company_id: str,
+    task_id: str,
+    identity: Identity,
+    allow_all_statuses: bool = False,
+    force: bool = False
 ) -> Task:
     """
     Loads only task id and return the task only if it is updatable (status == 'created')
     """
-    task = Task.get_for_writing(company=company_id, id=task_id, _only=("id", "status"))
-    if not task:
-        raise errors.bad_request.InvalidTaskId(id=task_id)
+    task = get_task_with_write_access(
+        task_id=task_id,
+        company_id=company_id,
+        only=("id", "status"),
+        identity=identity,
+    )
 
     if allow_all_statuses:
         return task
@@ -187,9 +246,88 @@ def get_task_for_update(
     return task
 
 
-def update_task(task: Task, update_cmds: dict, set_last_update: bool = True):
+def update_task(
+    task: Task, user_id: str, update_cmds: dict, set_last_update: bool = True
+):
     now = datetime.utcnow()
-    last_updates = dict(last_change=now)
+    last_updates = dict(last_change=now, last_changed_by=user_id)
     if set_last_update:
         last_updates.update(last_update=now)
     return task.update(**update_cmds, **last_updates)
+
+
+def get_last_metric_updates(
+    task_id: str,
+    last_scalar_events: dict,
+    raw_updates: dict,
+    extra_updates: dict,
+    model_events: bool = False,
+):
+    max_values = config.get("services.tasks.max_last_metrics", 2000)
+    total_metrics = set()
+    if max_values:
+        query = dict(id=task_id)
+        to_add = sum(len(v) for m, v in last_scalar_events.items())
+        if to_add <= max_values:
+            query[f"unique_metrics__{max_values - to_add}__exists"] = True
+        db_cls = Model if model_events else Task
+        task = db_cls.objects(**query).only("unique_metrics").first()
+        if task and task.unique_metrics:
+            total_metrics = set(task.unique_metrics)
+
+    new_metrics = []
+
+    def add_last_metric_conditional_update(
+        metric_path: str, metric_value, iter_value: int, is_min: bool
+    ):
+        """
+        Build an aggregation for an atomic update of the min or max value and the corresponding iteration
+        """
+        if is_min:
+            field_prefix = "min"
+            op = "$gt"
+        else:
+            field_prefix = "max"
+            op = "$lt"
+
+        value_field = f"{metric_path}__{field_prefix}_value".replace("__", ".")
+        condition = {
+            "$or": [
+                {"$lte": [f"${value_field}", None]},
+                {op: [f"${value_field}", metric_value]},
+            ]
+        }
+        raw_updates[value_field] = {
+            "$cond": [condition, metric_value, f"${value_field}"]
+        }
+
+        value_iteration_field = f"{metric_path}__{field_prefix}_value_iteration".replace(
+            "__", "."
+        )
+        raw_updates[value_iteration_field] = {
+            "$cond": [condition, iter_value, f"${value_iteration_field}"]
+        }
+
+    for metric_key, metric_data in last_scalar_events.items():
+        for variant_key, variant_data in metric_data.items():
+            metric = f"{variant_data.get('metric')}/{variant_data.get('variant')}"
+            if max_values:
+                if len(total_metrics) >= max_values and metric not in total_metrics:
+                    continue
+                total_metrics.add(metric)
+
+            new_metrics.append(metric)
+            path = f"last_metrics__{metric_key}__{variant_key}"
+            for key, value in variant_data.items():
+                if key in ("min_value", "max_value"):
+                    add_last_metric_conditional_update(
+                        metric_path=path,
+                        metric_value=value,
+                        iter_value=variant_data.get(f"{key}_iter", 0),
+                        is_min=(key == "min_value"),
+                    )
+                elif key in ("metric", "variant", "value"):
+                    extra_updates[f"set__{path}__{key}"] = value
+
+    if new_metrics:
+        extra_updates["add_to_set__unique_metrics"] = new_metrics

apiserver/bll/util.py

@@ -1,76 +1,24 @@
 import functools
 import itertools
 from concurrent.futures.thread import ThreadPoolExecutor
+from datetime import datetime
 from typing import (
     Optional,
     Callable,
-    Dict,
-    Any,
-    Set,
     Iterable,
     Tuple,
     Sequence,
     TypeVar,
+    Union,
 )
 
 from boltons import iterutils
 
 from apiserver.apierrors import APIError
-from apiserver.database.model import AttributedDocument
+from apiserver.database.model.project import Project
 from apiserver.database.model.settings import Settings
 
 
-class SetFieldsResolver:
-    """
-    The class receives set fields dictionary
-    and for the set fields that require 'min' or 'max'
-    operation replace them with a simple set in case the
-    DB document does not have these fields set
-    """
-
-    SET_MODIFIERS = ("min", "max")
-
-    def __init__(self, set_fields: Dict[str, Any]):
-        self.orig_fields = {}
-        self.fields = {}
-        self.add_fields(**set_fields)
-
-    def add_fields(self, **set_fields: Any):
-        self.orig_fields.update(set_fields)
-        self.fields.update(
-            {
-                f: fname
-                for f, modifier, dunder, fname in (
-                    (f,) + f.partition("__") for f in set_fields.keys()
-                )
-                if dunder and modifier in self.SET_MODIFIERS
-            }
-        )
-
-    def _get_updated_name(self, doc: AttributedDocument, name: str) -> str:
-        if name in self.fields and doc.get_field_value(self.fields[name]) is None:
-            return self.fields[name]
-        return name
-
-    def get_fields(self, doc: AttributedDocument):
-        """
-        For the given document return the set fields instructions
-        with min/max operations replaced with a single set in case
-        the document does not have the field set
-        """
-        return {
-            self._get_updated_name(doc, name): value
-            for name, value in self.orig_fields.items()
-        }
-
-    def get_names(self) -> Set[str]:
-        """
-        Returns the names of the fields that had min/max modifiers
-        in the format suitable for projection (dot separated)
-        """
-        return set(name.replace("__", ".") for name in self.fields.values())
-
-
 @functools.lru_cache()
 def get_server_uuid() -> Optional[str]:
     return Settings.get_by_key("server.uuid")
@@ -132,3 +80,13 @@ def run_batch_operation(
                 }
             )
     return results, failures
+
+
+def update_project_time(project_ids: Union[str, Sequence[str]]):
+    if not project_ids:
+        return
+
+    if isinstance(project_ids, str):
+        project_ids = [project_ids]
+
+    return Project.objects(id__in=project_ids).update(last_update=datetime.utcnow())

apiserver/bll/workers/__init__.py

@@ -5,13 +5,13 @@ from typing import Sequence, Set, Optional
 
 import attr
 import elasticsearch.helpers
-from boltons.iterutils import partition
+from boltons.iterutils import partition, chunked_iter
+from pyhocon import ConfigTree
 
 from apiserver.es_factory import es_factory
 from apiserver.apierrors import APIError
 from apiserver.apierrors.errors import bad_request, server_error
 from apiserver.apimodels.workers import (
-    DEFAULT_TIMEOUT,
     IdNameEntry,
     WorkerEntry,
     StatusReportRequest,
@@ -27,7 +27,7 @@ from apiserver.database.model.project import Project
 from apiserver.database.model.queue import Queue
 from apiserver.database.model.task.task import Task
 from apiserver.redis_manager import redman
-from apiserver.tools import safe_get
+from apiserver.utilities.dicts import nested_get
 from .stats import WorkerStats
 
 log = config.logger(__file__)
@@ -36,6 +36,7 @@ log = config.logger(__file__)
 class WorkerBLL:
     def __init__(self, es=None, redis=None):
         self.es_client = es or es_factory.connect("workers")
+        self.config = config.get("services.workers", ConfigTree())
         self.redis = redis or redman.connection("workers")
         self._stats = WorkerStats(self.es_client)
 
@@ -68,7 +69,7 @@ class WorkerBLL:
         """
         key = WorkerBLL._get_worker_key(company_id, user_id, worker)
 
-        timeout = timeout or DEFAULT_TIMEOUT
+        timeout = timeout or int(self.config.get("default_worker_timeout_sec", 10 * 60))
         queues = queues or []
 
         with translate_errors_context():
@@ -141,8 +142,6 @@ class WorkerBLL:
 
         try:
             entry.ip = ip
-            now = datetime.utcnow()
-            entry.last_activity_time = now
 
             if tags is not None:
                 entry.tags = tags
@@ -150,15 +149,16 @@ class WorkerBLL:
                 entry.system_tags = system_tags
 
             if report.machine_stats:
-                self._log_stats_to_es(
+                self.log_stats_to_es(
                     company_id=company_id,
-                    company_name=entry.company.name,
-                    worker=entry.key,
+                    worker_id=report.worker,
                     timestamp=report.timestamp,
                     task=report.task,
                     machine_stats=report.machine_stats,
                 )
 
+            now = datetime.utcnow()
+            entry.last_activity_time = now
             entry.queue = report.queue
 
             if report.queues:
@@ -175,6 +175,7 @@ class WorkerBLL:
                         last_worker_report=now,
                         last_update=now,
                         last_change=now,
+                        last_changed_by=user_id,
                     )
                     # modify(new=True, ...) returns the modified object
                     task = Task.objects(**query).modify(new=True, **update)
@@ -200,6 +201,24 @@ class WorkerBLL:
         finally:
             self._save_worker(entry)
 
+    def get_count(
+        self,
+        company_id: str,
+        last_seen: Optional[int] = None,
+        tags: Sequence[str] = None,
+        system_tags: Sequence[str] = None,
+    ):
+        if not last_seen:
+            return len(
+                self._get_keys(company_id, user_tags=tags, system_tags=system_tags)
+            )
+
+        return len(
+            self.get_all(
+                company_id, last_seen=last_seen, tags=tags, system_tags=system_tags
+            )
+        )
+
     def get_all(
         self,
         company_id: str,
@@ -235,18 +254,15 @@ class WorkerBLL:
         tags: Sequence[str] = None,
         system_tags: Sequence[str] = None,
     ) -> Sequence[WorkerResponseEntry]:
-
-        helpers = list(
-            map(
-                WorkerConversionHelper.from_worker_entry,
-                self.get_all(
-                    company_id=company_id,
-                    last_seen=last_seen,
-                    tags=tags,
-                    system_tags=system_tags,
-                ),
+        helpers = [
+            WorkerConversionHelper.from_worker_entry(entry)
+            for entry in self.get_all(
+                company_id=company_id,
+                last_seen=last_seen,
+                tags=tags,
+                system_tags=system_tags,
             )
-        )
+        ]
 
         task_ids = set(filter(None, (helper.task_id for helper in helpers)))
         all_queues = set(
@@ -265,14 +281,12 @@ class WorkerBLL:
                     }
                 },
             ]
-            queues_info = {
-                res["_id"]: res for res in Queue.objects.aggregate(projection)
-            }
+            queues_info = {res["_id"]: res for res in Queue.aggregate(projection)}
             task_ids = task_ids.union(
                 filter(
                     None,
                     (
-                        safe_get(info, "next_entry/task")
+                        nested_get(info, ("next_entry", "task"))
                         for info in queues_info.values()
                     ),
                 )
@@ -296,7 +310,7 @@ class WorkerBLL:
                     continue
                 entry.name = info.get("name", None)
                 entry.num_tasks = info.get("num_entries", 0)
-                task_id = safe_get(info, "next_entry/task")
+                task_id = nested_get(info, ("next_entry", "task"))
                 if task_id:
                     task = tasks_info.get(task_id, None)
                     entry.next_task = IdNameEntry(
@@ -396,15 +410,16 @@ class WorkerBLL:
             msg = "Failed saving worker entry"
             log.exception(msg)
 
-    def _get(
+    def _get_keys(
         self,
         company: str,
         user: str = "*",
-        worker_id: str = "*",
         user_tags: Sequence[str] = None,
         system_tags: Sequence[str] = None,
-    ) -> Sequence[WorkerEntry]:
-        """Get worker entries matching the company and user, worker patterns"""
+    ) -> Sequence[bytes]:
+        if not (user_tags or system_tags):
+            match = self._get_worker_key(company, user, "*")
+            return list(self.redis.scan_iter(match))
 
         def filter_by_user(in_keys: Set[bytes]) -> Set[bytes]:
             if user == "*":
@@ -412,67 +427,79 @@ class WorkerBLL:
             user_bytes = user.encode()
             return {k for k in in_keys if user_bytes in k}
 
-        if user_tags or system_tags:
-            worker_keys = set()
-            for tags, tags_field in (
-                (user_tags, "tags"),
-                (system_tags, "systemtags"),
-            ):
-                if not tags:
-                    continue
-                timestamp = int(time())
-                include, exclude = partition(tags, key=lambda x: x[0] != "-")
-                if include:
-                    tagged_workers = set()
-                    for tag in include:
-                        tagged_workers_key = self._get_tagged_workers_key(
-                            company, tags_field, tag
-                        )
-                        self.redis.zremrangebyscore(
-                            tagged_workers_key, min=0, max=timestamp
-                        )
-                        tagged_workers.update(
-                            self.redis.zrange(tagged_workers_key, 0, -1)
-                        )
-                    tagged_workers = filter_by_user(tagged_workers)
-                    worker_keys = (
-                        worker_keys.intersection(tagged_workers)
-                        if worker_keys
-                        else tagged_workers
+        worker_keys = set()
+        for tags, tags_field in (
+            (user_tags, "tags"),
+            (system_tags, "systemtags"),
+        ):
+            if not tags:
+                continue
+
+            timestamp = int(time())
+            include, exclude = partition(tags, key=lambda x: x[0] != "-")
+            if include:
+                tagged_workers = set()
+                for tag in include:
+                    tagged_workers_key = self._get_tagged_workers_key(
+                        company, tags_field, tag
+                    )
+                    self.redis.zremrangebyscore(
+                        tagged_workers_key, min=0, max=timestamp
+                    )
+                    tagged_workers.update(self.redis.zrange(tagged_workers_key, 0, -1))
+
+                tagged_workers = filter_by_user(tagged_workers)
+                worker_keys = (
+                    worker_keys.intersection(tagged_workers)
+                    if worker_keys
+                    else tagged_workers
+                )
+                if not worker_keys:
+                    return []
+
+            if exclude:
+                if not worker_keys:
+                    all_workers_key = self._get_all_workers_key(company)
+                    self.redis.zremrangebyscore(all_workers_key, min=0, max=timestamp)
+                    worker_keys.update(self.redis.zrange(all_workers_key, 0, -1))
+                    worker_keys = filter_by_user(worker_keys)
+                    if not worker_keys:
+                        return []
+
+                for tag in exclude:
+                    tagged_workers_key = self._get_tagged_workers_key(
+                        company, tags_field, tag[1:]
+                    )
+                    self.redis.zremrangebyscore(
+                        tagged_workers_key, min=0, max=timestamp
+                    )
+                    worker_keys.difference_update(
+                        self.redis.zrange(tagged_workers_key, 0, -1)
                     )
                     if not worker_keys:
                         return []
-                if exclude:
-                    if not worker_keys:
-                        all_workers_key = self._get_all_workers_key(company)
-                        self.redis.zremrangebyscore(
-                            all_workers_key, min=0, max=timestamp
-                        )
-                        worker_keys.update(self.redis.zrange(all_workers_key, 0, -1))
-                        worker_keys = filter_by_user(worker_keys)
-                        if not worker_keys:
-                            return []
-                    for tag in exclude:
-                        tagged_workers_key = self._get_tagged_workers_key(
-                            company, tags_field, tag[1:]
-                        )
-                        self.redis.zremrangebyscore(
-                            tagged_workers_key, min=0, max=timestamp
-                        )
-                        worker_keys.difference_update(
-                            self.redis.zrange(tagged_workers_key, 0, -1)
-                        )
-                        if not worker_keys:
-                            return []
-        else:
-            match = self._get_worker_key(company, user, "*")
-            worker_keys = self.redis.scan_iter(match)
+
+        return list(worker_keys)
+
+    def _get(
+        self,
+        company: str,
+        user: str = "*",
+        user_tags: Sequence[str] = None,
+        system_tags: Sequence[str] = None,
+    ) -> Sequence[WorkerEntry]:
+        """Get worker entries matching the company and user, worker patterns"""
 
         entries = []
-        for key in worker_keys:
-            data = self.redis.get(key)
+        for keys in chunked_iter(
+            self._get_keys(
+                company, user=user, user_tags=user_tags, system_tags=system_tags
+            ),
+            1000,
+        ):
+            data = self.redis.mget(keys)
             if data:
-                entries.append(WorkerEntry.from_json(data))
+                entries.extend(WorkerEntry.from_json(d) for d in data if d)
 
         return entries
 
@@ -481,18 +508,17 @@ class WorkerBLL:
         """Get the index name suffix for storing current month data"""
         return datetime.utcnow().strftime("%Y-%m")
 
-    def _log_stats_to_es(
+    def log_stats_to_es(
         self,
         company_id: str,
-        company_name: str,
-        worker: str,
+        worker_id: str,
         timestamp: int,
         task: str,
         machine_stats: MachineStats,
-    ) -> bool:
+    ) -> int:
         """
         Actually writing the worker statistics to Elastic
-        :return: True if successful, False otherwise
+        :return: The amount of logged documents
         """
         es_index = (
             f"{self._stats.worker_stats_prefix_for_company(company_id)}"
@@ -504,8 +530,7 @@ class WorkerBLL:
                 _index=es_index,
                 _source=dict(
                     timestamp=timestamp,
-                    worker=worker,
-                    company=company_name,
+                    worker=worker_id,
                     task=task,
                     category=category,
                     metric=metric,
@@ -530,7 +555,7 @@ class WorkerBLL:
 
         es_res = elasticsearch.helpers.bulk(self.es_client, actions)
         added, errors = es_res[:2]
-        return (added == len(actions)) and not errors
+        return added
 
 
 @attr.s(auto_attribs=True)

apiserver/bll/workers/stats.py

@@ -215,6 +215,10 @@ class WorkerStats:
                     "date_histogram": {
                         "field": "timestamp",
                         "fixed_interval": f"{interval}s",
+                        "extended_bounds": {
+                          "min": int(from_date) * 1000,
+                          "max": int(to_date) * 1000,
+                        }
                     },
                     "aggs": {"workers_count": {"cardinality": {"field": "worker"}}},
                 }

apiserver/config/basic.py

@@ -6,7 +6,7 @@ from functools import reduce
 from os import getenv
 from os.path import expandvars
 from pathlib import Path
-from typing import List, Any, TypeVar, Sequence
+from typing import List, Any, TypeVar, Sequence, Set
 
 from boltons.iterutils import first
 from pyhocon import ConfigTree, ConfigFactory, ConfigValues
@@ -35,6 +35,7 @@ class BasicConfig:
         folder: str = None,
         verbose: bool = True,
         prefix: Sequence[str] = DEFAULT_PREFIXES,
+        exclude_files_from_base_folder: Sequence[str] = None,
     ):
         folder = (
             Path(folder)
@@ -44,6 +45,11 @@ class BasicConfig:
         if not folder.is_dir():
             raise ValueError("Invalid configuration folder")
 
+        self.exclude_files_from_base_folder = (
+            set(exclude_files_from_base_folder)
+            if exclude_files_from_base_folder
+            else set()
+        )
         self.verbose = verbose
 
         self.extra_config_path_override_var = [
@@ -85,7 +91,7 @@ class BasicConfig:
         return logging.getLogger(path)
 
     def _read_extra_env_config_values(self) -> ConfigTree:
-        """ Loads extra configuration from environment-injected values """
+        """Loads extra configuration from environment-injected values"""
         result = ConfigTree()
 
         for prefix in self.extra_config_values_env_key_prefix:
@@ -125,12 +131,18 @@ class BasicConfig:
     def _reload(self) -> ConfigTree:
         extra_config_values = self._read_extra_env_config_values()
 
-        configs = [self._read_recursive(path) for path in self._paths]
+        configs = [
+            self._read_recursive(
+                path,
+                exclude_files=(
+                    self.exclude_files_from_base_folder if idx == 0 else None
+                ),
+            )
+            for idx, path in enumerate(self._paths)
+        ]
 
         return reduce(
-            lambda last, config: self._merge_configs(
-                last, config, copy_trees=True
-            ),
+            lambda last, config: self._merge_configs(last, config, copy_trees=True),
             configs + [extra_config_values],
             ConfigTree(),
         )
@@ -141,9 +153,14 @@ class BasicConfig:
         for key, value in b.items():
             override = key.startswith(override_prefix)
             if override:
-                key = key[len(override_prefix):]
+                key = key[len(override_prefix) :]
             # if key is in both a and b and both values are dictionary then merge it otherwise override it
-            if not override and key in a and isinstance(a[key], ConfigTree) and isinstance(b[key], ConfigTree):
+            if (
+                not override
+                and key in a
+                and isinstance(a[key], ConfigTree)
+                and isinstance(b[key], ConfigTree)
+            ):
                 if copy_trees:
                     a[key] = a[key].copy()
                 cls._merge_configs(a[key], b[key], copy_trees=copy_trees)
@@ -156,13 +173,15 @@ class BasicConfig:
                 a[key] = value
                 if a.root:
                     if b.root:
-                        a.history[key] = a.history.get(key, []) + b.history.get(key, [value])
+                        a.history[key] = a.history.get(key, []) + b.history.get(
+                            key, [value]
+                        )
                     else:
                         a.history[key] = a.history.get(key, []) + [value]
 
         return a
 
-    def _read_recursive(self, conf_root) -> ConfigTree:
+    def _read_recursive(self, conf_root, exclude_files: Set[str]) -> ConfigTree:
         conf = ConfigTree()
 
         if not conf_root:
@@ -180,6 +199,8 @@ class BasicConfig:
             print(f"Loading config from {conf_root}")
 
         for file in conf_root.rglob("*.conf"):
+            if exclude_files and file.name in exclude_files:
+                continue
             key = ".".join(file.relative_to(conf_root).with_suffix("").parts)
             conf.put(key, self._read_single_file(file))
 

apiserver/config/default/apiserver.conf

@@ -41,10 +41,6 @@
         # controls whether FieldDoesNotExist exception will be raised for any extra attribute existing in stored data
         # but not declared in a data model
         strict: false
-
-        aggregate {
-            allow_disk_use: true
-        }
     }
 
     elastic {
@@ -62,6 +58,9 @@
         # verify user tokens
         verify_user_tokens: false
 
+        # If set then users that were created from secure credentials or fixed user settings and are no longer in these settings will be deleted on startup
+        delete_missing_autocreated_users: true
+
         # max token expiration timeout in seconds (1 year)
         max_expiration_sec: 31536000
 
@@ -76,6 +75,7 @@
             httponly: true  # allow only http to access the cookies (no JS etc)
             secure: false   # not using HTTPS
             domain: null    # Limit to localhost is not supported
+            samesite: Lax
             max_age: 99999999999
         }
 
@@ -117,6 +117,10 @@
         # Timeout in seconds on task status update. If exceeded
         # then task can be stopped without communicating to the worker
         task_update_timeout: 600
+
+        # Timeout in seconds for worker registration (or status report). If a worker did not report for this long,
+        # it is discarded from the server's table
+        default_timeout: 600
     }
 
     check_for_updates {

apiserver/config/default/hosts.conf

@@ -2,10 +2,9 @@ fileserver = "http://localhost:8081"
 
 elastic {
   events {
-    hosts: [{host: "127.0.0.1", port: 9200}]
+    hosts: [{host: "127.0.0.1", port: 9200, scheme: http}]
     args {
       timeout: 60
-      dead_timeout: 10
       max_retries: 3
       retry_on_timeout: true
     }
@@ -13,10 +12,9 @@ elastic {
   }
 
   workers {
-    hosts: [{host:"127.0.0.1", port:9200}]
+    hosts: [{host:"127.0.0.1", port:9200, scheme: http}]
     args {
       timeout: 60
-      dead_timeout: 10
       max_retries: 3
       retry_on_timeout: true
     }

apiserver/config/default/secure.conf

@@ -23,6 +23,11 @@
             user_secret: "yfc8KQo*GMXb*9p((qcYC7ByFIpF7I&4VH3BfUYXH%o9vX1ZUZQEEw1Inc)S"
             revoke_in_fixed_mode: true
         }
+        services_agent {
+            role: "admin"
+            user_key: "P4BMJA7RK3TKBXGSY8OAA1FA8TOD11"
+            user_secret: "9LsgSfa0SYz0zli1_c500ZcLqanre2xkWOpepyt1w-BKK3_DKPHrtoj3JSHvyy8bIi0"
+        }
         tests {
             role: "user"
             display_name: "Default User"

apiserver/config/default/services/_mongo.conf

@@ -2,3 +2,8 @@ max_page_size: 500
 
 # expiration time in seconds for the redis scroll states in get_many family of apis
 scroll_state_expiration_seconds: 600
+
+allow_disk_use {
+    sort: true
+    aggregate: true
+}

apiserver/config/default/services/async_urls_delete.conf

@@ -1,6 +1,6 @@
-# if set to True then on task delete/reset external file urls for know storage types are scheduled for async delete
+# if set to true then on task delete/reset external file urls for known storage types are scheduled for async delete
 # otherwise they are returned to a client for the client side delete
-enabled: false
+enabled: true
 max_retries: 3
 retry_timeout_sec: 60
 
@@ -9,4 +9,4 @@ fileserver {
     # Can be in the form <schema>://host:port/path or /path
     url_prefixes: ["https://files.community-master.hosted.allegro.ai/"]
     timeout_sec: 300
-}
+}

apiserver/config/default/services/events.conf

@@ -32,6 +32,8 @@ events_retrieval {
     max_raw_scalars_size: 200000
 
     scroll_id_key: "cTN5VEtWEC6QrHvUl0FTx9kNyO0CcCK1p57akxma"
+
+    multi_plots_batch_size: 1000
 }
 
 # if set then plot str will be checked for the valid json on plot add

apiserver/config/default/services/models.conf

@@ -1,7 +1,4 @@
 metadata_values {
-    # maximal amount of distinct model values to retrieve
-    max_count: 100
-
     # cache ttl sec
     cache_ttl_sec: 86400
 }

apiserver/config/default/services/organization.conf

@@ -1,3 +1,9 @@
 tags_cache {
   expiration_seconds: 3600
+}
+download {
+    redis_timeout_sec: 300
+    batch_size: 500
+    max_download_items: 50000
+    max_project_name_length: 60
 }

apiserver/config/default/services/storage_credentials.conf

@@ -0,0 +1,54 @@
+aws {
+    s3 {
+        # S3 credentials, used for read/write access by various SDK elements
+        # default, used for any bucket not specified below
+        key: ""
+        secret: ""
+        region: ""
+        use_credentials_chain: false
+        # Additional ExtraArgs passed to boto3 when uploading files. Can also be set per-bucket under "credentials".
+        extra_args: {}
+        credentials: [
+            # specifies key/secret credentials to use when handling s3 urls (read or write)
+            # {
+            #     bucket: "my-bucket-name"
+            #     key: "my-access-key"
+            #     secret: "my-secret-key"
+            # },
+            {
+                # This will apply to all buckets in this host (unless key/value is specifically provided for a given bucket)
+                host: "localhost:9000"
+                key: "minioadmin"
+                secret: "minioadmin"
+                # region: my-server
+                multipart: false
+                secure: false
+            }
+        ]
+    }
+}
+google.storage {
+    # Default project and credentials file
+    # Will be used when no bucket configuration is found
+//    project: "clearml"
+//    credentials_json: "/path/to/credentials.json"
+//
+//    # Specific credentials per bucket and sub directory
+//    credentials = [
+//        {
+//            bucket: "my-bucket"
+//            subdir: "path/in/bucket" # Not required
+//            project: "clearml"
+//            credentials_json: "/path/to/credentials.json"
+//        },
+//    ]
+}
+azure.storage {
+    # containers: [
+    #     {
+    #         account_name: "clearml"
+    #         account_key: "secret"
+    #         # container_name:
+    #     }
+    # ]
+}

apiserver/config/default/services/tasks.conf

@@ -11,9 +11,6 @@ non_responsive_tasks_watchdog {
 multi_task_histogram_limit: 100
 
 hyperparam_values {
-    # maximal amount of distinct hyperparam values to retrieve
-    max_count: 100
-
     # max allowed outdate time for the cashed result
     cache_allowed_outdate_sec: 60
 
@@ -26,4 +23,6 @@ hyperparam_values {
 max_last_metrics: 2000
 
 # if set then call to tasks.delete/cleanup does not wait for ES events deletion
-async_events_delete: false
+async_events_delete: true
+# do not use async_delete if the deleted task has amount of events lower than this threshold
+async_events_delete_threshold: 100000

apiserver/database/errors.py

@@ -5,7 +5,7 @@ from textwrap import shorten
 
 import dpath
 from dpath.exceptions import InvalidKeyName
-from elasticsearch import ElasticsearchException
+from elastic_transport import TransportError, ApiError
 from elasticsearch.helpers import BulkIndexError
 from jsonmodels.errors import ValidationError as JsonschemaValidationError
 from mongoengine.errors import (
@@ -16,7 +16,7 @@ from mongoengine.errors import (
     LookUpError,
     InvalidQueryError,
 )
-from pymongo.errors import PyMongoError, NotMasterError
+from pymongo.errors import PyMongoError, NotPrimaryError
 
 from apiserver.apierrors import errors
 
@@ -198,7 +198,7 @@ def translate_errors_context(message=None, **kwargs):
         MongoEngineErrorsHandler.invalid_query_error(e, message, **kwargs)
     except PyMongoError as e:
         raise errors.server_error.InternalError(message, err=str(e))
-    except NotMasterError as e:
+    except NotPrimaryError as e:
         raise errors.server_error.InternalError(message, err=str(e))
     except MakeGetAllQueryError as e:
         raise errors.bad_request.ValidationError(e.error, field=e.field)
@@ -210,9 +210,9 @@ def translate_errors_context(message=None, **kwargs):
         raise errors.bad_request.ValidationError(e.args[0])
     except BulkIndexError as e:
         ElasticErrorsHandler.bulk_error(e, message, **kwargs)
-    except ElasticsearchException as e:
+    except (TransportError, ApiError) as e:
         raise errors.server_error.DataError(e, message, **kwargs)
     except InvalidKeyName:
         raise errors.server_error.DataError("invalid empty key encountered in data")
-    except Exception as ex:
+    except Exception:
         raise

apiserver/database/model/auth.py

@@ -4,6 +4,7 @@ from mongoengine import (
     EmbeddedDocumentListField,
     EmailField,
     DateTimeField,
+    BooleanField,
 )
 
 from apiserver.database import Database, strict
@@ -76,3 +77,6 @@ class User(DbModelMixin, AuthDocument):
 
     email = EmailField(unique=True, sparse=True)
     """ Email uniquely identifying the user """
+
+    autocreated = BooleanField(default=False)
+    """ Set to true if the user was auto created based on config settings"""

apiserver/database/model/base.py

@@ -1,5 +1,6 @@
 import re
-from collections import namedtuple
+from collections import namedtuple, defaultdict
+from datetime import datetime
 from functools import reduce, partial
 from typing import (
     Collection,
@@ -11,17 +12,18 @@ from typing import (
     Mapping,
     Any,
     Callable,
-    Dict,
-    List,
+    Generator,
 )
 
+import attr
 from boltons.iterutils import first, partition
 from dateutil.parser import parse as parse_datetime
-from mongoengine import Q, Document, ListField, StringField, IntField
+from mongoengine import Q, Document, ListField, StringField, IntField, QuerySet
 from pymongo.command_cursor import CommandCursor
 
-from apiserver.apierrors import errors
+from apiserver.apierrors import errors, APIError
 from apiserver.apierrors.base import BaseError
+from apiserver.apierrors.errors.bad_request import FieldsValueError
 from apiserver.bll.redis_cache_manager import RedisCacheManager
 from apiserver.config_repo import config
 from apiserver.database import Database
@@ -39,7 +41,7 @@ from apiserver.redis_manager import redman
 from apiserver.utilities.dicts import project_dict, exclude_fields_from_dict
 
 log = config.logger("dbmodel")
-
+mongo_conf = config.get("services._mongo")
 ACCESS_REGEX = re.compile(r"^(?P<prefix>>=|>|<=|<)?(?P<value>.*)$")
 ACCESS_MODIFIER = {">=": "gte", ">": "gt", "<=": "lte", "<": "lt"}
 
@@ -132,84 +134,134 @@ class GetMixin(PropsMixin):
             self.range_fields = range_fields
             self.pattern_fields = pattern_fields
 
-    class ListFieldBucketHelper:
+    class NewListFieldBucketHelper:
         op_prefix = "__$"
-        _legacy_exclude_prefix = "-"
-        _legacy_exclude_mongo_op = "nin"
-
-        default_mongo_op = "in"
-        _ops = {
-            # op -> (mongo_op, sticky)
-            "not": ("nin", False),
-            "nop": (default_mongo_op, False),
-            "all": ("all", True),
-            "and": ("all", True),
-            "any": (default_mongo_op, True),
-            "or": (default_mongo_op, True),
+        _unary_operators = {
+            "__$not": False,
+        }
+        _reset_operator = "__$nop"
+        _operators = {
+            "__$all": Q.AND,
+            "__$and": Q.AND,
+            "__$any": Q.OR,
+            "__$or": Q.OR,
+        }
+        default_global_operator = Q.AND
+        default_context = Q.OR
+        # not_all modifier currently not supported due to the backwards compatibility
+        mongo_modifiers = {
+            Q.AND: {True: "all", False: "nin"},
+            Q.OR: {True: "in", False: "nin"},
         }
 
-        def __init__(self, legacy=False):
-            self._current_op = None
-            self._sticky = False
-            self._support_legacy = legacy
+        @attr.s(auto_attribs=True)
+        class Term:
+            operator: str = None
+            reset: bool = False
+            include: bool = True
+            value: str = None
+
+        def __init__(self, field: str, data: Sequence[str], legacy=False):
+            self._field = field
             self.allow_empty = False
+            self.global_operator = None
+            self.actions = defaultdict(list)
 
-        def _get_op(self, v: str, translate: bool = False) -> Optional[str]:
-            op = (
-                v[len(self.op_prefix) :] if v and v.startswith(self.op_prefix) else None
-            )
-            if translate:
-                tup = self._ops.get(op, None)
-                return tup[0] if tup else None
-            return op
-
-        def _key(self, v) -> Optional[Union[str, bool]]:
-            if v is None:
-                self.allow_empty = True
-                return None
-
-            op = self._get_op(v)
-            if op is not None:
-                # operator - set state and return None
-                self._current_op, self._sticky = self._ops.get(
-                    op, (self.default_mongo_op, self._sticky)
-                )
-                return None
-            elif self._current_op:
-                current_op = self._current_op
-                if not self._sticky:
-                    self._current_op = None
-                return current_op
-            elif self._support_legacy and v.startswith(self._legacy_exclude_prefix):
-                self._current_op = None
-                return False
-
-            return self.default_mongo_op
-
-        def get_global_op(self, data: Sequence[str]) -> int:
-            op_to_res = {
-                "in": Q.OR,
-                "all": Q.AND,
-            }
-            data = (x for x in data if x is not None)
-            first_op = (
-                self._get_op(next(data, ""), translate=True) or self.default_mongo_op
-            )
-            return op_to_res.get(first_op, self.default_mongo_op)
-
-        def get_actions(self, data: Sequence[str]) -> Dict[str, List[Union[str, None]]]:
-            actions = {}
-
-            for val in data:
-                key = self._key(val)
-                if key is None:
+            self._support_legacy = legacy
+            current_context = self.default_context
+            for d in self._get_next_term(data):
+                if d.operator is not None:
+                    current_context = d.operator
+                    self._support_legacy = False
+                    if self.global_operator is None:
+                        self.global_operator = d.operator
                     continue
-                elif self._support_legacy and key is False:
-                    key = self._legacy_exclude_mongo_op
-                    val = val[len(self._legacy_exclude_prefix) :]
-                actions.setdefault(key, []).append(val)
 
-            return actions
+                if self.global_operator is None:
+                    self.global_operator = self.default_global_operator
+
+                if d.reset:
+                    current_context = self.default_context
+                    self._support_legacy = legacy
+                    continue
+
+                if d.value is None:
+                    self.allow_empty = True
+                    continue
+
+                self.actions[self.mongo_modifiers[current_context][d.include]].append(
+                    d.value
+                )
+
+            if self.global_operator is None:
+                self.global_operator = self.default_global_operator
+
+        def _get_next_term(self, data: Sequence[str]) -> Generator[Term, None, None]:
+            unary_operator = None
+            for value in data:
+                if value is None:
+                    unary_operator = None
+                    yield self.Term()
+                    continue
+
+                if not isinstance(value, str):
+                    raise FieldsValueError(
+                        "invalid value type, string expected",
+                        field=self._field,
+                        value=str(value),
+                    )
+
+                if value == self._reset_operator:
+                    unary_operator = None
+                    yield self.Term(reset=True)
+                    continue
+
+                if value.startswith(self.op_prefix):
+                    if unary_operator:
+                        raise FieldsValueError(
+                            "Value is expected after",
+                            field=self._field,
+                            operator=unary_operator,
+                        )
+                    if value in self._unary_operators:
+                        unary_operator = value
+                        continue
+
+                    operator = self._operators.get(value)
+                    if operator is None:
+                        raise FieldsValueError(
+                            "Unsupported operator",
+                            field=self._field,
+                            operator=value,
+                        )
+                    yield self.Term(operator=operator)
+                    continue
+
+                if (
+                    not unary_operator
+                    and self._support_legacy
+                    and value.startswith("-")
+                ):
+                    value = value[1:]
+                    if not value:
+                        raise FieldsValueError(
+                            "Missing value after the exclude prefix -",
+                            field=self._field,
+                            value=value,
+                        )
+                    yield self.Term(value=value, include=False)
+                    continue
+
+                term = self.Term(value=value)
+                if unary_operator:
+                    term.include = self._unary_operators[unary_operator]
+                    unary_operator = None
+                yield term
+
+            if unary_operator:
+                raise FieldsValueError(
+                    "Value is expected after", operator=unary_operator
+                )
 
     get_all_query_options = QueryParameterOptions()
 
@@ -227,8 +279,8 @@ class GetMixin(PropsMixin):
             cls._cache_manager = RedisCacheManager(
                 state_class=cls.GetManyScrollState,
                 redis=redman.connection("apiserver"),
-                expiration_interval=config.get(
-                    "services._mongo.scroll_state_expiration_seconds", 600
+                expiration_interval=mongo_conf.get(
+                    "scroll_state_expiration_seconds", 600
                 ),
             )
 
@@ -347,97 +399,121 @@ class GetMixin(PropsMixin):
         parameters_options = parameters_options or cls.get_all_query_options
         dict_query = {}
         query = RegexQ()
-        if parameters:
-            parameters = {
-                k: cls._get_fixed_field_value(k, v) for k, v in parameters.items()
-            }
-            opts = parameters_options
-            for field in opts.pattern_fields:
-                pattern = parameters.pop(field, None)
-                if pattern:
-                    dict_query[field] = RegexWrapper(pattern)
+        field = None
+        # noinspection PyBroadException
+        try:
+            if parameters:
+                parameters = {
+                    k: cls._get_fixed_field_value(k, v) for k, v in parameters.items()
+                }
+                filters = parameters.pop("filters", {})
+                if not isinstance(filters, dict):
+                    raise FieldsValueError(
+                        "invalid value type, string expected",
+                        field=filters,
+                        value=str(filters),
+                    )
+                opts = parameters_options
+                for field in opts.pattern_fields:
+                    pattern = parameters.pop(field, None)
+                    if pattern:
+                        dict_query[field] = RegexWrapper(pattern)
 
-            for field, data in cls._pop_matching_params(
-                patterns=opts.list_fields, parameters=parameters
-            ).items():
-                query &= cls.get_list_field_query(field, data)
+                for field, data in cls._pop_matching_params(
+                    patterns=opts.list_fields, parameters=filters
+                ).items():
+                    query &= cls.get_list_filter_query(field, data)
+                    parameters.pop(field, None)
 
-            for field, data in cls._pop_matching_params(
-                patterns=opts.range_fields, parameters=parameters
-            ).items():
-                query &= cls.get_range_field_query(field, data)
+                for field, data in cls._pop_matching_params(
+                    patterns=opts.list_fields, parameters=parameters
+                ).items():
+                    query &= cls.get_list_field_query(field, data)
 
-            for field, data in cls._pop_matching_params(
-                patterns=opts.fields or [], parameters=parameters
-            ).items():
-                if "._" in field or "_." in field:
-                    query &= RegexQ(__raw__={field: data})
-                else:
-                    dict_query[field.replace(".", "__")] = data
+                for field, data in cls._pop_matching_params(
+                    patterns=opts.range_fields, parameters=parameters
+                ).items():
+                    query &= cls.get_range_field_query(field, data)
 
-            for field in opts.datetime_fields or []:
-                data = parameters.pop(field, None)
-                if data is not None:
-                    if not isinstance(data, list):
-                        data = [data]
-                    # date time fields also support simplified range queries. Check if this is the case
-                    if len(data) == 2 and not any(
-                        d.startswith(mod)
-                        for d in data
-                        if d is not None
-                        for mod in ACCESS_MODIFIER
-                    ):
-                        query &= cls.get_range_field_query(field, data)
+                for field, data in cls._pop_matching_params(
+                    patterns=opts.fields or [], parameters=parameters
+                ).items():
+                    if "._" in field or "_." in field:
+                        query &= RegexQ(__raw__={field: data})
                     else:
-                        for d in data:  # type: str
-                            m = ACCESS_REGEX.match(d)
-                            if not m:
-                                continue
-                            try:
-                                value = parse_datetime(m.group("value"))
-                                prefix = m.group("prefix")
-                                modifier = ACCESS_MODIFIER.get(prefix)
-                                f = (
-                                    field
-                                    if not modifier
-                                    else "__".join((field, modifier))
-                                )
-                                dict_query[f] = value
-                            except (ValueError, OverflowError):
-                                pass
+                        dict_query[field.replace(".", "__")] = data
 
-            for field, value in parameters.items():
-                for keys, func in cls._multi_field_param_prefix.items():
-                    if field not in keys:
-                        continue
-                    try:
-                        data = cls.MultiFieldParameters(**value)
-                    except Exception:
-                        raise MakeGetAllQueryError("incorrect field format", field)
-                    if not data.fields:
-                        break
-                    if any("._" in f for f in data.fields):
-                        q = reduce(
-                            lambda a, x: func(
-                                a,
-                                RegexQ(
-                                    __raw__={
-                                        x: {"$regex": data.pattern, "$options": "i"}
-                                    }
+                for field in opts.datetime_fields or []:
+                    data = parameters.pop(field, None)
+                    if data is not None:
+                        if not isinstance(data, list):
+                            data = [data]
+                        # date time fields also support simplified range queries. Check if this is the case
+                        if len(data) == 2 and not any(
+                            d.startswith(mod)
+                            for d in data
+                            if d is not None
+                            for mod in ACCESS_MODIFIER
+                        ):
+                            query &= cls.get_range_field_query(field, data)
+                        else:
+                            for d in data:  # type: str
+                                m = ACCESS_REGEX.match(d)
+                                if not m:
+                                    continue
+                                try:
+                                    value = parse_datetime(m.group("value"))
+                                    prefix = m.group("prefix")
+                                    modifier = ACCESS_MODIFIER.get(prefix)
+                                    f = (
+                                        field
+                                        if not modifier
+                                        else "__".join((field, modifier))
+                                    )
+                                    dict_query[f] = value
+                                except (ValueError, OverflowError):
+                                    pass
+
+                for field, value in parameters.items():
+                    for keys, func in cls._multi_field_param_prefix.items():
+                        if field not in keys:
+                            continue
+                        try:
+                            data = cls.MultiFieldParameters(**value)
+                        except Exception:
+                            raise MakeGetAllQueryError("incorrect field format", field)
+                        if not data.fields:
+                            break
+                        if any("._" in f for f in data.fields):
+                            q = reduce(
+                                lambda a, x: func(
+                                    a,
+                                    RegexQ(
+                                        __raw__={
+                                            x: {"$regex": data.pattern, "$options": "i"}
+                                        }
+                                    ),
                                 ),
-                            ),
-                            data.fields,
-                            RegexQ(),
-                        )
-                    else:
-                        regex = RegexWrapper(data.pattern, flags=re.IGNORECASE)
-                        sep_fields = [f.replace(".", "__") for f in data.fields]
-                        q = reduce(
-                            lambda a, x: func(a, RegexQ(**{x: regex})),
-                            sep_fields,
-                            RegexQ(),
-                        )
-                    query = query & q
+                                data.fields,
+                                RegexQ(),
+                            )
+                        else:
+                            regex = RegexWrapper(data.pattern, flags=re.IGNORECASE)
+                            sep_fields = [f.replace(".", "__") for f in data.fields]
+                            q = reduce(
+                                lambda a, x: func(a, RegexQ(**{x: regex})),
+                                sep_fields,
+                                RegexQ(),
+                            )
+                        query = query & q
+        except APIError:
+            raise
+        except Exception as ex:
+            raise errors.bad_request.FieldsValueError(
+                "failed parsing query field",
+                error=str(ex),
+                **({"field": field} if field else {}),
+            )
 
         return query & RegexQ(**dict_query)
 
@@ -472,6 +548,149 @@ class GetMixin(PropsMixin):
 
         return q
 
+    @attr.s(auto_attribs=True)
+    class ListQueryFilter:
+        """
+        Deserialize filters data and build db_query object that represents it with the corresponding
+        mongo engine operations
+        Each part has include and exclude lists that map to mongoengine operations as following:
+        "any"
+          - include -> 'in'
+          - exclude -> 'not_all'
+          - combined by 'or' operation
+        "all"
+          - include -> 'all'
+          - exclude -> 'nin'
+          - combined by 'and' operation
+        "op" optional parameter for combining "and" and "all" parts. Can be "and" or "or". The default is "and"
+        """
+
+        _and_op = "and"
+        _or_op = "or"
+        _allowed_op = [_and_op, _or_op]
+        _db_modifiers: Mapping = {
+            (Q.OR, True): "in",
+            (Q.OR, False): "not__all",
+            (Q.AND, True): "all",
+            (Q.AND, False): "nin",
+        }
+
+        @attr.s(auto_attribs=True)
+        class ListFilter:
+            include: Sequence[str] = []
+            exclude: Sequence[str] = []
+
+            @classmethod
+            def from_dict(cls, d: Mapping):
+                if d is None:
+                    return None
+                return cls(**d)
+
+        any: ListFilter = attr.ib(converter=ListFilter.from_dict, default=None)
+        all: ListFilter = attr.ib(converter=ListFilter.from_dict, default=None)
+        op: str = attr.ib(default="and")
+        db_query: dict = attr.ib(init=False)
+
+        # noinspection PyUnresolvedReferences
+        @op.validator
+        def op_validator(self, _, value):
+            if value not in self._allowed_op:
+                raise ValueError(
+                    f"Invalid list query filter operator: {value}. "
+                    f"Should be one of {str(self._allowed_op)}"
+                )
+
+        @property
+        def and_op(self) -> bool:
+            return self.op == self._and_op
+
+        def __attrs_post_init__(self):
+            self.db_query = {}
+            for op, conditions in ((Q.OR, self.any), (Q.AND, self.all)):
+                if not conditions:
+                    continue
+
+                operations = {}
+                for vals, include in (
+                    (conditions.include, True),
+                    (conditions.exclude, False),
+                ):
+                    if not vals:
+                        continue
+
+                    unique = set(vals)
+                    if None in unique:
+                        # noinspection PyTypeChecker
+                        unique.remove(None)
+                        if include:
+                            operations["size"] = 0
+                        else:
+                            operations["not__size"] = 0
+
+                    if not unique:
+                        continue
+
+                    operations[self._db_modifiers[(op, include)]] = list(unique)
+
+                self.db_query[op] = operations
+
+        @classmethod
+        def from_data(cls, field, data: Mapping):
+            if not isinstance(data, dict):
+                raise errors.bad_request.ValidationError(
+                    "invalid filter for field, dictionary expected",
+                    field=field,
+                    value=str(data),
+                )
+
+            try:
+                return cls(**data)
+            except Exception as ex:
+                raise errors.bad_request.ValidationError(
+                    field=field,
+                    value=str(ex),
+                )
+
+    @classmethod
+    def get_list_filter_query(
+        cls, field: str, data: Mapping
+    ) -> Union[RegexQ, RegexQCombination]:
+        if not data:
+            return RegexQ()
+
+        filter_ = cls.ListQueryFilter.from_data(field, data)
+
+        mongoengine_field = field.replace(".", "__")
+        queries = []
+        for op, actions in filter_.db_query.items():
+            if not actions:
+                continue
+
+            ops = []
+            for action, vals in actions.items():
+                # cannot just check vals here since 0 is acceptable value
+                if vals is None or vals == []:
+                    continue
+
+                ops.append(RegexQ(**{f"{mongoengine_field}__{action}": vals}))
+
+            if not ops:
+                continue
+
+            if len(ops) == 1:
+                queries.extend(ops)
+                continue
+
+            queries.append(RegexQCombination(operation=op, children=ops))
+
+        if not queries:
+            return RegexQ()
+        if len(queries) == 1:
+            return queries[0]
+
+        operation = Q.AND if filter_.and_op else Q.OR
+        return RegexQCombination(operation=operation, children=queries)
+
     @classmethod
     def get_list_field_query(cls, field: str, data: Sequence[Optional[str]]) -> RegexQ:
         """
@@ -486,15 +705,15 @@ class GetMixin(PropsMixin):
         if not isinstance(data, (list, tuple)):
             data = [data]
 
-        helper = cls.ListFieldBucketHelper(legacy=True)
-        global_op = helper.get_global_op(data)
-        actions = helper.get_actions(data)
+        helper = cls.NewListFieldBucketHelper(field, data=data, legacy=True)
+        global_op = helper.global_operator
+        actions = helper.actions
 
         mongoengine_field = field.replace(".", "__")
 
         queries = [
-            RegexQ(**{f"{mongoengine_field}__{action}": list(set(actions[action]))})
-            for action in filter(None, actions)
+            RegexQ(**{f"{mongoengine_field}__{action}": list(set(values))})
+            for action, values in actions.items()
         ]
 
         if not queries:
@@ -555,7 +774,7 @@ class GetMixin(PropsMixin):
         if start is not None:
             return start, cls.validate_scroll_size(parameters)
 
-        max_page_size = config.get("services._mongo.max_page_size", 500)
+        max_page_size = mongo_conf.get("max_page_size", 500)
         page = parameters.get("page", default_page)
         if page is not None and page < 0:
             raise errors.bad_request.ValidationError("page must be >=0", field="page")
@@ -580,7 +799,7 @@ class GetMixin(PropsMixin):
 
     @classmethod
     def get_projection(cls, parameters, override_projection=None, **__):
-        """ Extract a projection list from the provided dictionary. Supports an override projection. """
+        """Extract a projection list from the provided dictionary. Supports an override projection."""
         if override_projection is not None:
             return override_projection
         if not parameters:
@@ -594,7 +813,8 @@ class GetMixin(PropsMixin):
         """Return include and exclude lists based on passed projection and class definition"""
         if projection:
             include, exclude = partition(
-                projection, key=lambda x: x[0] != ProjectionHelper.exclusion_prefix,
+                projection,
+                key=lambda x: x[0] != ProjectionHelper.exclusion_prefix,
             )
         else:
             include, exclude = [], []
@@ -733,7 +953,9 @@ class GetMixin(PropsMixin):
     @classmethod
     def _get_collation_override(cls, field: str) -> Optional[dict]:
         return first(
-            v for k, v in cls._field_collation_overrides.items() if field.startswith(k)
+            v
+            for k, v in cls._field_collation_overrides.items()
+            if field.startswith(k) or field.startswith(f"-{k}")
         )
 
     @classmethod
@@ -839,7 +1061,9 @@ class GetMixin(PropsMixin):
                 projection_fields=projection_fields,
             )
             return cls.get_data_with_scroll_support(
-                query_dict=query_dict, data_getter=data_getter, ret_params=ret_params,
+                query_dict=query_dict,
+                data_getter=data_getter,
+                ret_params=ret_params,
             )
 
         return cls._get_many_no_company(
@@ -852,7 +1076,9 @@ class GetMixin(PropsMixin):
 
     @classmethod
     def get_many_public(
-        cls, query: Q = None, projection: Collection[str] = None,
+        cls,
+        query: Q = None,
+        projection: Collection[str] = None,
     ):
         """
         Fetch all public documents matching a provided query.
@@ -865,6 +1091,13 @@ class GetMixin(PropsMixin):
 
         return cls._get_many_no_company(query=_query, override_projection=projection)
 
+    @staticmethod
+    def _get_qs_with_ordering(qs: QuerySet, order_by: Sequence):
+        disk_use_setting = mongo_conf.get("allow_disk_use.sort", None)
+        if disk_use_setting is not None:
+            qs = qs.allow_disk_use(disk_use_setting)
+        return qs.order_by(*order_by)
+
     @classmethod
     def _get_many_no_company(
         cls: Union["GetMixin", Document],
@@ -906,7 +1139,7 @@ class GetMixin(PropsMixin):
             qs = qs.search_text(search_text)
         if order_by:
             # add ordering
-            qs = qs.order_by(*order_by)
+            qs = cls._get_qs_with_ordering(qs, order_by)
 
         if include:
             # add projection
@@ -998,7 +1231,7 @@ class GetMixin(PropsMixin):
             res = cls._get_queries_for_order_field(query, order_field)
             if res:
                 query_sets = [cls.objects(q) for q in res]
-            query_sets = [qs.order_by(*order_by) for qs in query_sets]
+            query_sets = [cls._get_qs_with_ordering(qs, order_by) for qs in query_sets]
             if order_field and not override_collation:
                 override_collation = cls._get_collation_override(order_field)
 
@@ -1063,22 +1296,6 @@ class GetMixin(PropsMixin):
             )
         return result
 
-    @classmethod
-    def get_many_for_writing(cls, company, *args, **kwargs):
-        result = cls.get_many(
-            company=company,
-            *args,
-            **dict(return_dicts=False, **kwargs),
-            allow_public=True,
-        )
-        forbidden_objects = {obj.id for obj in result if not obj.company}
-        if forbidden_objects:
-            object_name = cls.__name__.lower()
-            raise errors.forbidden.NoWritePermission(
-                f"cannot modify public {object_name}(s), ids={tuple(forbidden_objects)}"
-            )
-        return result
-
 
 class UpdateMixin(object):
     __user_set_allowed_fields = None
@@ -1138,7 +1355,7 @@ class UpdateMixin(object):
 
 
 class DbModelMixin(GetMixin, ProperDictMixin, UpdateMixin):
-    """ Provide convenience methods for a subclass of mongoengine.Document """
+    """Provide convenience methods for a subclass of mongoengine.Document"""
 
     @classmethod
     def aggregate(
@@ -1158,7 +1375,7 @@ class DbModelMixin(GetMixin, ProperDictMixin, UpdateMixin):
         kwargs.update(
             allowDiskUse=allow_disk_use
             if allow_disk_use is not None
-            else config.get("apiserver.mongo.aggregate.allow_disk_use", True)
+            else mongo_conf.get("allow_disk_use.aggregate", True)
         )
         return cls.objects.aggregate(pipeline, **kwargs)
 
@@ -1166,25 +1383,31 @@ class DbModelMixin(GetMixin, ProperDictMixin, UpdateMixin):
     def set_public(
         cls: Type[Document],
         company_id: str,
+        user_id: str,
         ids: Sequence[str],
         invalid_cls: Type[BaseError],
         enabled: bool = True,
     ):
         if enabled:
             items = list(cls.objects(id__in=ids, company=company_id).only("id"))
-            update = dict(set__company_origin=company_id, set__company="")
+            update: dict = dict(set__company_origin=company_id, set__company="")
         else:
             items = list(
                 cls.objects(
                     id__in=ids, company__in=(None, ""), company_origin=company_id
                 ).only("id")
             )
-            update = dict(set__company=company_id, unset__company_origin=1)
+            update: dict = dict(set__company=company_id, unset__company_origin=1)
 
         if len(items) < len(ids):
             missing = tuple(set(ids).difference(i.id for i in items))
             raise invalid_cls(ids=missing)
 
+        if hasattr(cls, "last_change"):
+            update["set__last_change"] = datetime.utcnow()
+        if hasattr(cls, "last_changed_by"):
+            update["set__last_changed_by"] = user_id
+
         return {"updated": cls.objects(id__in=ids).update(**update)}
 
 

apiserver/database/model/model.py

@@ -3,6 +3,8 @@ from mongoengine import (
     DateTimeField,
     BooleanField,
     EmbeddedDocumentField,
+    IntField,
+    ListField,
 )
 
 from apiserver.database import Database, strict
@@ -17,12 +19,14 @@ from apiserver.database.model.base import GetMixin
 from apiserver.database.model.metadata import MetadataItem
 from apiserver.database.model.model_labels import ModelLabels
 from apiserver.database.model.project import Project
+from apiserver.database.model.task.metrics import MetricEvent
 from apiserver.database.model.task.task import Task
 
 
 class Model(AttributedDocument):
     _field_collation_overrides = {
         "metadata.": AttributedDocument._numeric_locale,
+        "last_metrics.": AttributedDocument._numeric_locale,
     }
 
     meta = {
@@ -67,6 +71,7 @@ class Model(AttributedDocument):
             "parent",
             "metadata.*",
         ),
+        range_fields=("last_metrics.*", "last_iteration"),
         datetime_fields=("last_update",),
     )
 
@@ -85,6 +90,8 @@ class Model(AttributedDocument):
     labels = ModelLabels()
     ready = BooleanField(required=True)
     last_update = DateTimeField()
+    last_change = DateTimeField()
+    last_changed_by = StringField()
     ui_cache = SafeDictField(
         default=dict, user_set_allowed=True, exclude_by_default=True
     )
@@ -92,6 +99,9 @@ class Model(AttributedDocument):
     metadata = SafeMapField(
         field=EmbeddedDocumentField(MetadataItem), user_set_allowed=True
     )
+    last_iteration = IntField(default=0)
+    last_metrics = SafeMapField(field=SafeMapField(EmbeddedDocumentField(MetricEvent)))
+    unique_metrics = ListField(StringField(required=True), exclude_by_default=True)
 
     def get_index_company(self) -> str:
         return self.company or self.company_origin or ""

apiserver/database/model/task/metrics.py

@@ -4,6 +4,7 @@ from mongoengine import (
     DynamicField,
     LongField,
     EmbeddedDocumentField,
+    IntField,
 )
 
 from apiserver.database.fields import SafeMapField
@@ -19,7 +20,9 @@ class MetricEvent(EmbeddedDocument):
     variant = StringField(required=True)
     value = DynamicField(required=True)
     min_value = DynamicField()  # for backwards compatibility reasons
+    min_value_iteration = IntField()
     max_value = DynamicField()  # for backwards compatibility reasons
+    max_value_iteration = IntField()
 
 
 class EventStats(EmbeddedDocument):

apiserver/database/model/task/task.py

@@ -19,6 +19,7 @@ from apiserver.database.fields import (
     SafeSortedListField,
     EmbeddedDocumentListField,
     NullableStringField,
+    NoneType,
 )
 from apiserver.database.model import AttributedDocument
 from apiserver.database.model.base import ProperDictMixin, GetMixin
@@ -89,7 +90,9 @@ class Artifact(EmbeddedDocument):
     content_size = LongField()
     timestamp = LongField()
     type_data = EmbeddedDocumentField(ArtifactTypeData)
-    display_data = SafeSortedListField(ListField(UnionField((int, float, str))))
+    display_data = SafeSortedListField(
+        ListField(UnionField((int, float, str, NoneType)))
+    )
 
 
 class ParamsItem(EmbeddedDocument, ProperDictMixin):
@@ -149,6 +152,7 @@ class TaskType(object):
     application = "application"
     monitor = "monitor"
     controller = "controller"
+    report = "report"
     optimizer = "optimizer"
     service = "service"
     qc = "qc"
@@ -195,6 +199,7 @@ class Task(AttributedDocument):
                     "$name",
                     "$id",
                     "$comment",
+                    "$report",
                     "$models.input.model",
                     "$models.output.model",
                     "$script.repository",
@@ -205,6 +210,7 @@ class Task(AttributedDocument):
                     "name": 10,
                     "id": 10,
                     "comment": 10,
+                    "report": 10,
                     "models.output.model": 2,
                     "models.input.model": 2,
                     "script.repository": 1,
@@ -224,10 +230,13 @@ class Task(AttributedDocument):
             "project",
             "parent",
             "hyperparams.*",
+            "execution.queue",
+            "models.input.model",
         ),
         range_fields=("started", "active_duration", "last_metrics.*", "last_iteration"),
         datetime_fields=("status_changed", "last_update"),
-        pattern_fields=("name", "comment"),
+        pattern_fields=("name", "comment", "report"),
+        fields=("runtime.*",),
     )
 
     id = StringField(primary_key=True)
@@ -241,6 +250,8 @@ class Task(AttributedDocument):
     status_message = StringField(user_set_allowed=True)
     status_changed = DateTimeField()
     comment = StringField(user_set_allowed=True)
+    report = StringField()
+    report_assets = ListField(StringField())
     created = DateTimeField(required=True, user_set_allowed=True)
     started = DateTimeField()
     completed = DateTimeField()
@@ -262,7 +273,7 @@ class Task(AttributedDocument):
     unique_metrics = ListField(StringField(required=True), exclude_by_default=True)
     metric_stats = SafeMapField(field=EmbeddedDocumentField(MetricEventStats))
     company_origin = StringField(exclude_by_default=True)
-    duration = IntField()  # task duration in seconds
+    duration = IntField()  # obsolete, do not use
     hyperparams = SafeMapField(field=SafeMapField(EmbeddedDocumentField(ParamsItem)))
     configuration = SafeMapField(field=EmbeddedDocumentField(ConfigurationItem))
     runtime = SafeDictField(default=dict)
@@ -271,6 +282,7 @@ class Task(AttributedDocument):
     enqueue_status = StringField(
         choices=get_options(TaskStatus), exclude_by_default=True
     )
+    last_changed_by = StringField()
 
     def get_index_company(self) -> str:
         """

apiserver/database/model/url_to_delete.py

@@ -8,6 +8,9 @@ from apiserver.database.model import AttributedDocument
 
 class StorageType(str, Enum):
     fileserver = "fileserver"
+    s3 = "s3"
+    azure = "azure"
+    gs = "gs"
     unknown = "unknown"
 
 
@@ -32,10 +35,8 @@ class UrlToDelete(AttributedDocument):
         "strict": strict,
         "indexes": [
             ("company", "user", "task"),
-            "storage_type",
-            "created",
-            "retry_count",
-            "type",
+            ("company", "storage_type", "url"),
+            ("status", "retry_count", "storage_type"),
         ],
     }
 

apiserver/database/projection.py

@@ -3,10 +3,14 @@ from concurrent.futures import ThreadPoolExecutor
 from itertools import groupby, chain
 from typing import Sequence, Dict, Callable
 
+from boltons import iterutils
+
 from apiserver.apierrors import errors
+from apiserver.config_repo import config
 from apiserver.database.props import PropsMixin
 
 SEP = "."
+max_items_per_fetch = config.get("services._mongo.max_page_size", 500)
 
 
 class _ReferenceProxy(dict):
@@ -278,10 +282,11 @@ class ProjectionHelper(object):
                     doc_only = list(filter(None, data["only"]))
                     doc_only = list({"id"} | set(doc_only)) if doc_only else None
 
-                    for res in projection_func(
-                        doc_type=doc_type, projection=doc_only, ids=ids
-                    ):
-                        self._proxy_manager.update(res)
+                    for ids_chunk in iterutils.chunked_iter(ids, max_items_per_fetch):
+                        for res in projection_func(
+                            doc_type=doc_type, projection=doc_only, ids=ids_chunk
+                        ):
+                            self._proxy_manager.update(res)
 
                 if len(ref_projection) == 1:
                     do_projection(items[0])

apiserver/documentation/api_versions.md

@@ -0,0 +1,19 @@
+### Supported api versions
+
+| Release | ApiVersion |
+|---------|------------|
+| v1.13   | 2.27       |
+| v1.12   | 2.26       |
+| v1.11   | 2.25       |
+| v1.10   | 2.24       |
+| v1.9    | 2.23       |
+| v1.8    | 2.22       |
+| v1.7    | 2.21       |
+| v1.6    | 2.20       |
+| v1.5    | 2.19       |
+| v1.4    | 2.18       |
+| v1.3    | 2.17       |
+| v1.2    | 2.16       |
+| v1.1    | 2.15       |
+| v1.0    | 2.14       |
+| v0.17   | 2.13       |

apiserver/elastic/apply_mappings.py

@@ -4,34 +4,89 @@ Apply elasticsearch mappings to given hosts.
 """
 import argparse
 import json
+import logging
 from pathlib import Path
 from typing import Optional, Sequence, Tuple
 
-from elasticsearch import Elasticsearch
+from elasticsearch import Elasticsearch, exceptions
 
 HERE = Path(__file__).resolve().parent
+logging.getLogger("elasticsearch").setLevel(logging.WARNING)
+logging.getLogger("elastic_transport").setLevel(logging.WARNING)
 
 
 def apply_mappings_to_cluster(
-    hosts: Sequence, key: Optional[str] = None, es_args: dict = None, http_auth: Tuple = None
+    hosts: Sequence,
+    key: Optional[str] = None,
+    es_args: dict = None,
+    http_auth: Tuple = None,
 ):
     """Hosts maybe a sequence of strings or dicts in the form {"host": <host>, "port": <port>}"""
 
-    def _send_template(f):
-        with f.open() as json_data:
-            data = json.load(json_data)
-            template_name = f.stem
-            res = es.indices.put_template(template_name, body=data)
-            return {"mapping": template_name, "result": res}
+    def _send_component_template(ct_file):
+        with ct_file.open() as json_data:
+            body = json.load(json_data)
+            template_name = f"{ct_file.stem}"
+            res = es.cluster.put_component_template(name=template_name, body=body)
+            return {"component_template": template_name, "result": res}
 
-    p = HERE / "mappings"
-    if key:
-        files = (p / key).glob("*.json")
-    else:
-        files = p.glob("**/*.json")
+    def _send_index_template(it_file):
+        with it_file.open() as json_data:
+            body = json.load(json_data)
+            template_name = f"{it_file.stem}"
+            res = es.indices.put_index_template(name=template_name, body=body)
+            return {"index_template": template_name, "result": res}
+
+    # def _send_legacy_template(f):
+    #     with f.open() as json_data:
+    #         data = json.load(json_data)
+    #         template_name = f.stem
+    #         res = es.indices.put_template(name=template_name, body=data)
+    #         return {"mapping": template_name, "result": res}
+
+    def _delete_legacy_templates(legacy_folder):
+        res_list = []
+        for lt in legacy_folder.glob("*.json"):
+            template_name = lt.stem
+            try:
+                if not es.indices.get_template(name=template_name):
+                    continue
+                res = es.indices.delete_template(name=template_name)
+            except exceptions.NotFoundError:
+                continue
+            res_list.append({"deleted legacy mapping": template_name, "result": res})
+
+        return res_list
 
     es = Elasticsearch(hosts=hosts, http_auth=http_auth, **(es_args or {}))
-    return [_send_template(f) for f in files]
+    root = HERE / "index_templates"
+    if key:
+        folders = [root / key]
+    else:
+        folders = [f for f in root.iterdir() if f.is_dir()]
+
+    ret = []
+    for f in folders:
+        for ct in (f / "component_templates").glob("*.json"):
+            ret.append(_send_component_template(ct))
+        for it in f.glob("*.json"):
+            ret.append(_send_index_template(it))
+
+    legacy_root = HERE / "mappings"
+    for f in folders:
+        legacy_f = legacy_root / f.stem
+        if not legacy_f.exists() or not legacy_f.is_dir():
+            continue
+        ret.extend(_delete_legacy_templates(legacy_f))
+
+    return ret
+    # p = HERE / "mappings"
+    # if key:
+    #     files = (p / key).glob("*.json")
+    # else:
+    #     files = p.glob("**/*.json")
+    #
+    # return [_send_template(f) for f in files]
 
 
 def parse_args():

apiserver/elastic/index_templates/events/component_templates/events_common.json

@@ -0,0 +1,48 @@
+{
+  "template": {
+    "settings": {
+      "number_of_replicas": 0,
+      "number_of_shards": 1
+    },
+    "mappings": {
+      "_source": {
+        "enabled": true
+      },
+      "properties": {
+        "@timestamp": {
+          "type": "date"
+        },
+        "task": {
+          "type": "keyword"
+        },
+        "type": {
+          "type": "keyword"
+        },
+        "worker": {
+          "type": "keyword"
+        },
+        "timestamp": {
+          "type": "date"
+        },
+        "iter": {
+          "type": "long"
+        },
+        "metric": {
+          "type": "keyword"
+        },
+        "variant": {
+          "type": "keyword"
+        },
+        "value": {
+          "type": "float"
+        },
+        "company_id": {
+          "type": "keyword"
+        },
+        "model_event": {
+          "type": "boolean"
+        }
+      }
+    }
+  }
+}

apiserver/elastic/index_templates/events/events_log.json

@@ -0,0 +1,18 @@
+{
+  "index_patterns": "events-log-*",
+  "template": {
+    "mappings": {
+      "properties": {
+        "msg": {
+          "type": "text",
+          "index": false
+        },
+        "level": {
+          "type": "keyword"
+        }
+      }
+    }
+  },
+  "priority": 500,
+  "composed_of": ["events_common"]
+}

apiserver/elastic/index_templates/events/events_plot.json

@@ -0,0 +1,18 @@
+{
+  "index_patterns": "events-plot-*",
+  "template": {
+    "mappings": {
+      "properties": {
+        "plot_str": {
+          "type": "text",
+          "index": false
+        },
+        "plot_data": {
+          "type": "binary"
+        }
+      }
+    }
+  },
+  "priority": 500,
+  "composed_of": ["events_common"]
+}

apiserver/elastic/index_templates/events/events_training_debug_image.json

@@ -0,0 +1,17 @@
+{
+  "index_patterns": "events-training_debug_image-*",
+  "template": {
+    "mappings": {
+      "properties": {
+        "key": {
+          "type": "keyword"
+        },
+        "url": {
+          "type": "keyword"
+        }
+      }
+    }
+  },
+  "priority": 500,
+  "composed_of": ["events_common"]
+}

apiserver/elastic/index_templates/events/events_training_stats_scalar.json

@@ -0,0 +1,5 @@
+{
+  "index_patterns": "events-training_stats_scalar-*",
+  "priority": 500,
+  "composed_of": ["events_common"]
+}

apiserver/elastic/index_templates/workers/queue_metrics.json

@@ -0,0 +1,31 @@
+{
+  "index_patterns": "queue_metrics_*",
+  "template": {
+    "settings": {
+      "number_of_replicas": 0,
+      "number_of_shards": 1
+    },
+    "mappings": {
+      "_source": {
+        "enabled": true
+      },
+      "properties": {
+        "timestamp": {
+          "type": "date"
+        },
+        "queue": {
+          "type": "keyword"
+        },
+        "average_waiting_time": {
+          "type": "float"
+        },
+        "queue_length": {
+          "type": "integer"
+        },
+        "company_id": {
+          "type": "keyword"
+        }
+      }
+    }
+  }
+}

apiserver/elastic/index_templates/workers/worker_stats.json

@@ -0,0 +1,43 @@
+{
+  "index_patterns": "worker_stats_*",
+  "template": {
+    "settings": {
+      "number_of_replicas": 0,
+      "number_of_shards": 1
+    },
+    "mappings": {
+      "_source": {
+        "enabled": true
+      },
+      "properties": {
+        "timestamp": {
+          "type": "date"
+        },
+        "worker": {
+          "type": "keyword"
+        },
+        "category": {
+          "type": "keyword"
+        },
+        "metric": {
+          "type": "keyword"
+        },
+        "variant": {
+          "type": "keyword"
+        },
+        "value": {
+          "type": "float"
+        },
+        "unit": {
+          "type": "keyword"
+        },
+        "task": {
+          "type": "keyword"
+        },
+        "company_id": {
+          "type": "keyword"
+        }
+      }
+    }
+  }
+}

apiserver/elastic/initialize.py

@@ -10,6 +10,8 @@ from apiserver.config_repo import config
 from apiserver.elastic.apply_mappings import apply_mappings_to_cluster
 
 log = config.logger(__file__)
+logging.getLogger("elasticsearch").setLevel(logging.WARNING)
+logging.getLogger("elastic_transport").setLevel(logging.WARNING)
 
 
 class MissingElasticConfiguration(Exception):
@@ -78,6 +80,18 @@ def check_elastic_empty() -> bool:
         err_type=urllib3.exceptions.NewConnectionError, args_prefix=("GET",)
     )
 
+    def events_legacy_template():
+        try:
+            return es.indices.get_template(name="events*")
+        except exceptions.NotFoundError:
+            return False
+
+    def events_template():
+        try:
+            return es.indices.get_index_template(name="events*")
+        except exceptions.NotFoundError:
+            return False
+
     try:
         es_logger.addFilter(log_filter)
         for retry in range(max_retries):
@@ -85,12 +99,9 @@ def check_elastic_empty() -> bool:
                 es = Elasticsearch(
                     hosts=cluster_conf.get("hosts", None),
                     http_auth=es_factory.get_credentials("events", cluster_conf),
-                    **cluster_conf.get("args", {})
+                    **cluster_conf.get("args", {}),
                 )
-                return not es.indices.get_template(name="events*")
-            except exceptions.NotFoundError as ex:
-                log.error(ex)
-                return True
+                return not (events_template() or events_legacy_template())
             except exceptions.ConnectionError as ex:
                 if retry >= max_retries - 1:
                     raise ElasticConnectionError(
@@ -115,5 +126,7 @@ def init_es_data():
         args = cluster_conf.get("args", {})
         http_auth = es_factory.get_credentials(name)
 
-        res = apply_mappings_to_cluster(hosts_config, name, es_args=args, http_auth=http_auth)
+        res = apply_mappings_to_cluster(
+            hosts_config, name, es_args=args, http_auth=http_auth
+        )
         log.info(res)

apiserver/elastic/mappings/events/events.json

@@ -1,8 +1,8 @@
 {
   "index_patterns": "events-*",
   "settings": {
-    "number_of_shards": 1,
-    "number_of_replicas": 0
+    "number_of_replicas": 0,
+    "number_of_shards": 1
   },
   "mappings": {
     "_source": {

apiserver/elastic/mappings/workers/queue_metrics.json

@@ -1,8 +1,8 @@
 {
   "index_patterns": "queue_metrics_*",
   "settings": {
-    "number_of_shards": 1,
-    "number_of_replicas": 0
+    "number_of_replicas": 0,
+    "number_of_shards": 1
   },
   "mappings": {
     "_source": {
@@ -20,6 +20,9 @@
       },
       "queue_length": {
         "type": "integer"
+      },
+      "company_id": {
+        "type": "keyword"
       }
     }
   }

apiserver/elastic/mappings/workers/worker_stats.json

@@ -1,8 +1,8 @@
 {
   "index_patterns": "worker_stats_*",
   "settings": {
-    "number_of_shards": 1,
-    "number_of_replicas": 0
+    "number_of_replicas": 0,
+    "number_of_shards": 1
   },
   "mappings": {
     "_source": {
@@ -32,6 +32,9 @@
       },
       "task": {
         "type": "keyword"
+      },
+      "company_id": {
+        "type": "keyword"
       }
     }
   }

apiserver/es_factory.py

@@ -1,3 +1,4 @@
+import logging
 from datetime import datetime
 from functools import lru_cache
 from os import getenv
@@ -9,6 +10,8 @@ from elasticsearch import Elasticsearch
 from apiserver.config_repo import config
 
 log = config.logger(__file__)
+logging.getLogger('elasticsearch').setLevel(logging.WARNING)
+logging.getLogger('elastic_transport').setLevel(logging.WARNING)
 
 OVERRIDE_HOST_ENV_KEY = (
     "CLEARML_ELASTIC_SERVICE_HOST",
@@ -32,6 +35,7 @@ if OVERRIDE_HOST:
 
 OVERRIDE_PORT = first(filter(None, map(getenv, OVERRIDE_PORT_ENV_KEY)))
 if OVERRIDE_PORT:
+    OVERRIDE_PORT = int(OVERRIDE_PORT)
     log.info(f"Using override elastic port {OVERRIDE_PORT}")
 
 OVERRIDE_USERNAME = first(filter(None, map(getenv, OVERRIDE_USERNAME_ENV_KEY)))
@@ -67,7 +71,7 @@ class MissingPasswordForElasticUser(Exception):
 
 class ESFactory:
     @classmethod
-    def connect(cls, cluster_name):
+    def connect(cls, cluster_name) -> Elasticsearch:
         """
         Returns the es client for the cluster.
         Connects to the cluster if did not connect previously

apiserver/jobs/async_urls_delete.py

@@ -1,3 +1,5 @@
+import os
+from abc import ABC, ABCMeta, abstractmethod
 from argparse import ArgumentParser
 from collections import defaultdict
 from datetime import datetime, timedelta
@@ -5,38 +7,28 @@ from functools import partial
 from itertools import chain
 from pathlib import Path
 from time import sleep
-from typing import Sequence, Tuple
+from typing import Sequence, Optional, Tuple, Mapping, TypeVar, Hashable, Generic
+from urllib.parse import urlparse
 
+import boto3
 import requests
+from azure.storage.blob import ContainerClient, PartialBatchErrorException
+from boltons.iterutils import bucketize, chunked_iter
 from furl import furl
+from google.cloud import storage as google_storage
 from mongoengine import Q
+from mypy_boto3_s3.service_resource import Bucket as AWSBucket
 
+from apiserver.bll.storage import StorageBLL
 from apiserver.config_repo import config
 from apiserver.database import db
-from apiserver.database.model.url_to_delete import (
-    UrlToDelete,
-    DeletionStatus,
-    StorageType,
-)
+from apiserver.database.model.url_to_delete import UrlToDelete, StorageType, DeletionStatus
 
 log = config.logger(f"JOB-{Path(__file__).name}")
 conf = config.get("services.async_urls_delete")
 max_retries = conf.get("max_retries", 3)
 retry_timeout = timedelta(seconds=conf.get("retry_timeout_sec", 60))
-fileserver_timeout = conf.get("fileserver.timeout_sec", 300)
-UrlPrefix = Tuple[str, str]
-
-
-def validate_fileserver_access(fileserver_host: str) -> str:
-    fileserver_host = fileserver_host or config.get("hosts.fileserver", None)
-    if not fileserver_host:
-        log.error(f"Fileserver host not configured")
-        exit(1)
-
-    res = requests.get(url=fileserver_host)
-    res.raise_for_status()
-
-    return fileserver_host
+storage_bll = StorageBLL()
 
 
 def mark_retry_failed(ids: Sequence[str], reason: str):
@@ -58,112 +50,518 @@ def mark_failed(query: Q, reason: str):
     )
 
 
-def delete_fileserver_urls(
-    urls_query: Q, fileserver_host: str, url_prefixes: Sequence[UrlPrefix]
-):
-    to_delete = list(UrlToDelete.objects(urls_query).limit(10000))
+def scheme_prefix(scheme: str) -> str:
+    return str(furl(scheme=scheme, netloc=""))
+
+
+T = TypeVar("T", bound=Hashable)
+
+
+class Storage(Generic[T], metaclass=ABCMeta):
+    class Client(ABC):
+        @property
+        @abstractmethod
+        def chunk_size(self) -> int:
+            pass
+
+        def get_path(self, url: UrlToDelete) -> str:
+            pass
+
+        def delete_many(
+            self, paths: Sequence[str]
+        ) -> Tuple[Sequence[str], Mapping[str, Sequence[str]]]:
+            pass
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    def group_urls(
+        self, urls: Sequence[UrlToDelete]
+    ) -> Mapping[T, Sequence[UrlToDelete]]:
+        pass
+
+    def get_client(self, base: T, urls: Sequence[UrlToDelete]) -> Client:
+        pass
+
+
+def delete_urls(urls_query: Q, storage: Storage):
+    to_delete = list(UrlToDelete.objects(urls_query).order_by("url").limit(10000))
     if not to_delete:
         return
 
-    def resolve_path(url_: UrlToDelete) -> str:
-        parsed = furl(url_.url)
-        url_host = f"{parsed.scheme}://{parsed.netloc}" if parsed.scheme else None
-        url_path = str(parsed.path)
+    grouped_urls = storage.group_urls(to_delete)
+    for base, urls in grouped_urls.items():
+        if not base:
+            msg = f"Invalid {storage.name} url or missing {storage.name} configuration for account"
+            mark_failed(
+                Q(id__in=[url.id for url in urls]), msg,
+            )
+            log.warning(
+                f"Failed to delete {len(urls)} files from {storage.name} due to: {msg}"
+            )
+            continue
 
-        for host, path_prefix in url_prefixes:
+        try:
+            client = storage.get_client(base, urls)
+        except Exception as ex:
+            failed = [url.id for url in urls]
+            mark_retry_failed(failed, reason=str(ex))
+            log.warning(
+                f"Failed to delete {len(failed)} files from {storage.name} due to: {str(ex)}"
+            )
+            continue
+
+        for chunk in chunked_iter(urls, client.chunk_size):
+            paths = []
+            path_to_id_mapping = defaultdict(list)
+            ids_to_delete = set()
+            for url in chunk:
+                try:
+                    path = client.get_path(url)
+                except Exception as ex:
+                    err = str(ex)
+                    mark_failed(Q(id=url.id), err)
+                    log.warning(f"Error getting path for {url.url}: {err}")
+                    continue
+
+                paths.append(path)
+                path_to_id_mapping[path].append(url.id)
+                ids_to_delete.add(url.id)
+
+            if not paths:
+                continue
+
+            try:
+                deleted_paths, errors = client.delete_many(paths)
+            except Exception as ex:
+                mark_retry_failed([url.id for url in urls], str(ex))
+                log.warning(
+                    f"Error deleting {len(paths)} files from {storage.name}: {str(ex)}"
+                )
+                continue
+
+            failed_ids = set()
+            for reason, err_paths in errors.items():
+                error_ids = set(
+                    chain.from_iterable(
+                        path_to_id_mapping.get(p, []) for p in err_paths
+                    )
+                )
+                mark_retry_failed(list(error_ids), reason)
+                log.warning(
+                    f"Failed to delete {len(error_ids)} files from {storage.name} storage due to: {reason}"
+                )
+                failed_ids.update(error_ids)
+
+            deleted_ids = set(
+                chain.from_iterable(
+                    path_to_id_mapping.get(p, []) for p in deleted_paths
+                )
+            )
+            if deleted_ids:
+                UrlToDelete.objects(id__in=list(deleted_ids)).delete()
+                log.info(
+                    f"{len(deleted_ids)} files deleted from {storage.name} storage"
+                )
+
+            missing_ids = ids_to_delete - deleted_ids - failed_ids
+            if missing_ids:
+                mark_retry_failed(list(missing_ids), "Not succeeded")
+
+
+class FileserverStorage(Storage):
+    class Client(Storage.Client):
+        timeout = conf.get("fileserver.timeout_sec", 300)
+
+        def __init__(self, session: requests.Session, host: str):
+            self.session = session
+            self.delete_url = furl(host).add(path="delete_many").url
+
+        @property
+        def chunk_size(self) -> int:
+            return 10000
+
+        def get_path(self, url: UrlToDelete) -> str:
+            path = url.url.strip("/")
+            if not path:
+                raise ValueError("Empty path")
+
+            return path
+
+        def delete_many(
+            self, paths: Sequence[str]
+        ) -> Tuple[Sequence[str], Mapping[str, Sequence[str]]]:
+            res = self.session.post(
+                url=self.delete_url, json={"files": list(paths)}, timeout=self.timeout
+            )
+            res.raise_for_status()
+            res_data = res.json()
+            return list(res_data.get("deleted", {})), res_data.get("errors", {})
+
+    def __init__(self, company: str, fileserver_host: str = None):
+        fileserver_host = fileserver_host or config.get("hosts.fileserver", None)
+        self.host = fileserver_host.rstrip("/")
+        if not self.host:
+            log.warning(f"Fileserver host not configured")
+
+        def _parse_url_prefix(prefix) -> Tuple[str, str]:
+            url = furl(prefix)
+            host = f"{url.scheme}://{url.netloc}" if url.scheme else None
+            return host, str(url.path).rstrip("/")
+
+        url_prefixes = [
+            _parse_url_prefix(p) for p in conf.get("fileserver.url_prefixes", [])
+        ]
+        if not any(self.host == host for host, _ in url_prefixes):
+            url_prefixes.append((self.host, ""))
+        self.url_prefixes = url_prefixes
+
+        self.company = company
+
+    # @classmethod
+    # def validate_fileserver_access(cls, fileserver_host: str):
+    #     res = requests.get(
+    #         url=fileserver_host
+    #     )
+    #     res.raise_for_status()
+
+    @property
+    def name(self) -> str:
+        return "Fileserver"
+
+    def _resolve_base_url(self, url: UrlToDelete) -> Optional[str]:
+        """
+        For the url return the base_url containing schema, optional host and bucket name
+        """
+        if not url.url:
+            return None
+
+        try:
+            parsed = furl(url.url)
+            url_host = f"{parsed.scheme}://{parsed.netloc}" if parsed.scheme else None
+            url_path = str(parsed.path)
+        except Exception:
+            return None
+
+        for host, path_prefix in self.url_prefixes:
             if host and url_host != host:
                 continue
             if path_prefix and not url_path.startswith(path_prefix + "/"):
                 continue
-            return url_path[len(path_prefix or ""):]
+            url.url = url_path[len(path_prefix or "") :]
+            return self.host
 
-        raise ValueError("could not map path")
+    def group_urls(
+        self, urls: Sequence[UrlToDelete]
+    ) -> Mapping[str, Sequence[UrlToDelete]]:
+        return bucketize(urls, key=self._resolve_base_url)
 
-    paths = set()
-    path_to_id_mapping = defaultdict(list)
-    for url in to_delete:
-        try:
-            path = resolve_path(url)
-            path = path.strip("/")
-            if not path:
-                raise ValueError("Empty path")
-        except Exception as ex:
-            err = str(ex)
-            log.warn(f"Error getting path for {url.url}: {err}")
-            mark_failed(Q(id=url.id), err)
-            continue
-
-        paths.add(path)
-        path_to_id_mapping[path].append(url.id)
-
-    if not paths:
-        return
-
-    ids_to_delete = set(chain.from_iterable(path_to_id_mapping.values()))
-    try:
-        res = requests.post(
-            url=furl(fileserver_host).add(path="delete_many").url,
-            json={"files": list(paths)},
-            timeout=fileserver_timeout,
-        )
+    def get_client(self, base: str, urls: Sequence[UrlToDelete]) -> Client:
+        host = base
+        session = requests.session()
+        res = session.get(url=host, timeout=self.Client.timeout)
         res.raise_for_status()
-    except Exception as ex:
-        err = str(ex)
-        log.warn(f"Error deleting {len(paths)} files from fileserver: {err}")
-        mark_retry_failed(list(ids_to_delete), err)
-        return
 
-    res_data = res.json()
-    deleted_ids = set(
-        chain.from_iterable(
-            path_to_id_mapping.get(path, [])
-            for path in list(res_data.get("deleted", {}))
+        return self.Client(session, host)
+
+
+class AzureStorage(Storage):
+    class Client(Storage.Client):
+        def __init__(self, container: ContainerClient):
+            self.container = container
+
+        @property
+        def chunk_size(self) -> int:
+            return 256
+
+        def get_path(self, url: UrlToDelete) -> str:
+            parsed = furl(url.url)
+            if (
+                not parsed.path
+                or not parsed.path.segments
+                or len(parsed.path.segments) <= 1
+            ):
+                raise ValueError("No path found following container name")
+
+            return os.path.join(*parsed.path.segments[1:])
+
+        @staticmethod
+        def _path_from_request_url(request_url: str) -> str:
+            try:
+                return furl(request_url).path.segments[-1]
+            except Exception:
+                return request_url
+
+        def delete_many(
+            self, paths: Sequence[str]
+        ) -> Tuple[Sequence[str], Mapping[str, Sequence[str]]]:
+            try:
+                res = self.container.delete_blobs(*paths)
+            except PartialBatchErrorException as pex:
+                deleted = []
+                errors = defaultdict(list)
+                for part in pex.parts:
+                    if 300 >= part.status_code >= 200:
+                        deleted.append(self._path_from_request_url(part.request.url))
+                    else:
+                        errors[part.reason].append(
+                            self._path_from_request_url(part.request.url)
+                        )
+                return deleted, errors
+
+            return [self._path_from_request_url(part.request.url) for part in res], {}
+
+    def __init__(self, company: str):
+        self.configs = storage_bll.get_azure_settings_for_company(company)
+        self.scheme = "azure"
+
+    @property
+    def name(self) -> str:
+        return "Azure"
+
+    def _resolve_base_url(self, url: UrlToDelete) -> Optional[Tuple]:
+        """
+        For the url return the base_url containing schema, optional host and bucket name
+        """
+        try:
+            parsed = urlparse(url.url)
+            if parsed.scheme != self.scheme:
+                return None
+
+            azure_conf = self.configs.get_config_by_uri(url.url)
+            if azure_conf is None:
+                return None
+
+            account_url = parsed.netloc
+            return account_url, azure_conf.container_name
+        except Exception as ex:
+            log.warning(f"Error resolving base url for {url.url}: " + str(ex))
+            return None
+
+    def group_urls(
+        self, urls: Sequence[UrlToDelete]
+    ) -> Mapping[Tuple, Sequence[UrlToDelete]]:
+        return bucketize(urls, key=self._resolve_base_url)
+
+    def get_client(self, base: Tuple, urls: Sequence[UrlToDelete]) -> Client:
+        account_url, container_name = base
+        sample_url = urls[0].url
+        cfg = self.configs.get_config_by_uri(sample_url)
+        if not cfg or not cfg.account_name or not cfg.account_key:
+            raise ValueError(
+                f"Missing account name or key for Azure Blob Storage "
+                f"account: {account_url}, container: {container_name}"
+            )
+
+        return self.Client(
+            ContainerClient(
+                account_url=account_url,
+                container_name=cfg.container_name,
+                credential={
+                    "account_name": cfg.account_name,
+                    "account_key": cfg.account_key,
+                },
+            )
         )
-    )
-    if deleted_ids:
-        UrlToDelete.objects(id__in=list(deleted_ids)).delete()
-        log.info(f"{len(deleted_ids)} files deleted from the fileserver")
 
-    failed_ids = set()
-    for err, error_ids in res_data.get("errors", {}).items():
-        error_ids = list(
-            chain.from_iterable(path_to_id_mapping.get(path, []) for path in error_ids)
+
+class AWSStorage(Storage):
+    class Client(Storage.Client):
+        def __init__(self, base_url: str, container: AWSBucket):
+            self.container = container
+            self.base_url = base_url
+
+        @property
+        def chunk_size(self) -> int:
+            return 1000
+
+        def get_path(self, url: UrlToDelete) -> str:
+            """ Normalize remote path. Remove any prefix that is already handled by the container """
+            path = url.url
+            if path.startswith(self.base_url):
+                path = path[len(self.base_url) :]
+            path = path.lstrip("/")
+            return path
+
+        @staticmethod
+        def _path_from_request_url(request_url: str) -> str:
+            try:
+                return furl(request_url).path.segments[-1]
+            except Exception:
+                return request_url
+
+        def delete_many(
+            self, paths: Sequence[str]
+        ) -> Tuple[Sequence[str], Mapping[str, Sequence[str]]]:
+            res = self.container.delete_objects(
+                Delete={"Objects": [{"Key": p} for p in paths]}
+            )
+            errors = defaultdict(list)
+            for err in res.get("Errors", []):
+                msg = err.get("Message", "")
+                errors[msg].append(err.get("Key"))
+
+            return [d.get("Key") for d in res.get("Deleted", [])], errors
+
+    def __init__(self, company: str):
+        self.configs = storage_bll.get_aws_settings_for_company(company)
+        self.scheme = "s3"
+
+    @property
+    def name(self) -> str:
+        return "AWS"
+
+    def _resolve_base_url(self, url: UrlToDelete) -> Optional[str]:
+        """
+        For the url return the base_url containing schema, optional host and bucket name
+        """
+        try:
+            parsed = urlparse(url.url)
+            if parsed.scheme != self.scheme:
+                return None
+
+            s3_conf = self.configs.get_config_by_uri(url.url)
+            if s3_conf is None:
+                return None
+
+            s3_bucket = s3_conf.bucket
+            if not s3_bucket:
+                parts = Path(parsed.path.strip("/")).parts
+                if parts:
+                    s3_bucket = parts[0]
+            return "/".join(filter(None, ("s3:/", s3_conf.host, s3_bucket)))
+        except Exception as ex:
+            log.warning(f"Error resolving base url for {url.url}: " + str(ex))
+            return None
+
+    def group_urls(
+        self, urls: Sequence[UrlToDelete]
+    ) -> Mapping[str, Sequence[UrlToDelete]]:
+        return bucketize(urls, key=self._resolve_base_url)
+
+    def get_client(self, base: str, urls: Sequence[UrlToDelete]) -> Client:
+        sample_url = urls[0].url
+        cfg = self.configs.get_config_by_uri(sample_url)
+        boto_kwargs = {
+            "endpoint_url": (("https://" if cfg.secure else "http://") + cfg.host)
+            if cfg.host
+            else None,
+            "use_ssl": cfg.secure,
+            "verify": cfg.verify,
+            "region_name": cfg.region or None,
+        }
+        name = base[len(scheme_prefix(self.scheme)) :]
+        bucket_name = name[len(cfg.host) + 1 :] if cfg.host else name
+        if not cfg.use_credentials_chain:
+            if not cfg.key or not cfg.secret:
+                raise ValueError(
+                    f"Missing key or secret for AWS S3 host: {cfg.host}, bucket: {str(bucket_name)}"
+                )
+
+            boto_kwargs["aws_access_key_id"] = cfg.key
+            boto_kwargs["aws_secret_access_key"] = cfg.secret
+            if cfg.token:
+                boto_kwargs["aws_session_token"] = cfg.token
+
+        return self.Client(
+            base, boto3.resource("s3", **boto_kwargs).Bucket(bucket_name)
         )
-        mark_retry_failed(error_ids, err)
-        log.warning(
-            f"Failed to delete {len(error_ids)} files from the fileserver due to: {err}"
+
+
+class GoogleCloudStorage(Storage):
+    class Client(Storage.Client):
+        def __init__(self, base_url: str, container: google_storage.Bucket):
+            self.container = container
+            self.base_url = base_url
+
+        @property
+        def chunk_size(self) -> int:
+            return 100
+
+        def get_path(self, url: UrlToDelete) -> str:
+            """ Normalize remote path. Remove any prefix that is already handled by the container """
+            path = url.url
+            if path.startswith(self.base_url):
+                path = path[len(self.base_url) :]
+            path = path.lstrip("/")
+            return path
+
+        def delete_many(
+            self, paths: Sequence[str]
+        ) -> Tuple[Sequence[str], Mapping[str, Sequence[str]]]:
+            not_found = set()
+
+            def error_callback(blob: google_storage.Blob):
+                not_found.add(blob.name)
+
+            self.container.delete_blobs(
+                [self.container.blob(p) for p in paths], on_error=error_callback,
+            )
+            errors = {"Not found": list(not_found)} if not_found else {}
+            return list(set(paths) - not_found), errors
+
+    def __init__(self, company: str):
+        self.configs = storage_bll.get_gs_settings_for_company(company)
+        self.scheme = "gs"
+
+    @property
+    def name(self) -> str:
+        return "Google Storage"
+
+    def _resolve_base_url(self, url: UrlToDelete) -> Optional[str]:
+        """
+        For the url return the base_url containing schema, optional host and bucket name
+        """
+        try:
+            parsed = urlparse(url.url)
+            if parsed.scheme != self.scheme:
+                return None
+
+            gs_conf = self.configs.get_config_by_uri(url.url)
+            if gs_conf is None:
+                return None
+
+            return str(furl(scheme=parsed.scheme, netloc=gs_conf.bucket))
+        except Exception as ex:
+            log.warning(f"Error resolving base url for {url.url}: " + str(ex))
+            return None
+
+    def group_urls(
+        self, urls: Sequence[UrlToDelete]
+    ) -> Mapping[str, Sequence[UrlToDelete]]:
+        return bucketize(urls, key=self._resolve_base_url)
+
+    def get_client(self, base: str, urls: Sequence[UrlToDelete]) -> Client:
+        sample_url = urls[0].url
+        cfg = self.configs.get_config_by_uri(sample_url)
+        if cfg.credentials_json:
+            from google.oauth2 import service_account
+
+            credentials = service_account.Credentials.from_service_account_file(
+                cfg.credentials_json
+            )
+        else:
+            credentials = None
+
+        bucket_name = base[len(scheme_prefix(self.scheme)) :]
+        return self.Client(
+            base,
+            google_storage.Client(project=cfg.project, credentials=credentials).bucket(
+                bucket_name
+            ),
         )
-        failed_ids.update(error_ids)
-
-    missing_ids = ids_to_delete - deleted_ids - failed_ids
-    if missing_ids:
-        mark_retry_failed(list(missing_ids), "Not succeeded")
-
-
-def _get_fileserver_url_prefixes(fileserver_host: str) -> Sequence[UrlPrefix]:
-    def _parse_url_prefix(prefix) -> UrlPrefix:
-        url = furl(prefix)
-        host = f"{url.scheme}://{url.netloc}" if url.scheme else None
-        return host, str(url.path).rstrip("/")
-
-    url_prefixes = [
-        _parse_url_prefix(p) for p in conf.get("fileserver.url_prefixes", [])
-    ]
-    if not any(fileserver_host == host for host, _ in url_prefixes):
-        url_prefixes.append((fileserver_host, ""))
-
-    return url_prefixes
 
 
 def run_delete_loop(fileserver_host: str):
-    fileserver_host = validate_fileserver_access(fileserver_host)
-
-    storage_delete_funcs = {
+    storage_helpers = {
         StorageType.fileserver: partial(
-            delete_fileserver_urls,
-            fileserver_host=fileserver_host,
-            url_prefixes=_get_fileserver_url_prefixes(fileserver_host),
+            FileserverStorage, fileserver_host=fileserver_host
         ),
+        StorageType.s3: AWSStorage,
+        StorageType.azure: AzureStorage,
+        StorageType.gs: GoogleCloudStorage,
     }
     while True:
         now = datetime.utcnow()
@@ -177,7 +575,7 @@ def run_delete_loop(fileserver_host: str):
         )
 
         url_to_delete: UrlToDelete = UrlToDelete.objects(
-            urls_query & Q(storage_type__in=list(storage_delete_funcs))
+            urls_query & Q(storage_type__in=list(storage_helpers))
         ).order_by("retry_count").limit(1).first()
         if not url_to_delete:
             sleep(10)
@@ -192,7 +590,10 @@ def run_delete_loop(fileserver_host: str):
         company_storage_urls_query = urls_query & Q(
             company=company, storage_type=storage_type,
         )
-        storage_delete_funcs[storage_type](urls_query=company_storage_urls_query)
+        delete_urls(
+            urls_query=company_storage_urls_query,
+            storage=storage_helpers[storage_type](company=company),
+        )
 
 
 def main():

apiserver/mongo/initialize/__init__.py

@@ -3,7 +3,7 @@ from typing import Sequence, Union
 
 from apiserver.config_repo import config
 from apiserver.config.info import get_default_company
-from apiserver.database.model.auth import Role
+from apiserver.database.model.auth import Role, User as AuthUser
 from apiserver.service_repo.auth.fixed_user import FixedUser
 from .migration import _apply_migrations, check_mongo_empty, get_last_server_version
 from .pre_populate import PrePopulate
@@ -60,14 +60,18 @@ def init_mongo_data():
 
         fixed_mode = FixedUser.enabled()
 
+        internal_user_emails = set()
         for user, credentials in config.get("secure.credentials", {}).items():
+            email = f"{user}@example.com"
             user_data = {
                 "name": user,
                 "role": credentials.role,
-                "email": f"{user}@example.com",
+                "email": email,
                 "key": credentials.user_key,
                 "secret": credentials.user_secret,
+                "autocreated": True,
             }
+            internal_user_emails.add(email.lower())
             revoke = fixed_mode and credentials.get("revoke_in_fixed_mode", False)
             user_id = _ensure_auth_user(user_data, company_id, log=log, revoke=revoke)
             if credentials.role == Role.user:
@@ -82,8 +86,20 @@ def init_mongo_data():
 
             for user in FixedUser.from_config():
                 try:
-                    ensure_fixed_user(user, log=log)
+                    ensure_fixed_user(user, log=log, emails=internal_user_emails)
                 except Exception as ex:
                     log.error(f"Failed creating fixed user {user.name}: {ex}")
+
+        if internal_user_emails and config.get(
+            f"apiserver.auth.delete_missing_autocreated_users", True
+        ):
+            for user in AuthUser.objects(
+                company=company_id, autocreated=True, email__nin=internal_user_emails
+            ):
+                log.info(
+                    f"Removing user that is no longer in configuration: {user['id']}\t{user['email']}\t{user['name']}"
+                )
+                user.delete()
+
     except Exception as ex:
-        log.exception("Failed initializing mongodb")
+        log.exception(f"Failed initializing mongodb: {str(ex)}")

apiserver/mongo/initialize/migration.py

@@ -18,9 +18,15 @@ _migration_dir = _parent_dir / _migrations
 
 
 def check_mongo_empty() -> bool:
-    return not all(
-        get_db(alias).collection_names() for alias in utils.get_options(Database)
-    )
+    for alias in utils.get_options(Database):
+        collection_names = get_db(alias).list_collection_names()
+        if collection_names and any(
+            name in collection_names
+            for name in ["company", "user", "versions"]
+        ):
+            return False
+
+    return True
 
 
 def get_last_server_version() -> Version:

apiserver/mongo/initialize/pre_populate.py

@@ -44,6 +44,7 @@ from apiserver.bll.task.param_utils import (
 from apiserver.config_repo import config
 from apiserver.config.info import get_default_company
 from apiserver.database.model import EntityVisibility, User
+from apiserver.database.model.auth import Role, User as AuthUser
 from apiserver.database.model.model import Model
 from apiserver.database.model.project import Project
 from apiserver.database.model.task.task import (
@@ -54,6 +55,7 @@ from apiserver.database.model.task.task import (
     TaskModelNames,
 )
 from apiserver.database.utils import get_options
+from apiserver.service_repo.auth import Identity
 from apiserver.utilities import json
 from apiserver.utilities.dicts import nested_get, nested_set, nested_delete
 from apiserver.utilities.parameter_key_escaper import ParameterKeyEscaper
@@ -66,6 +68,7 @@ class PrePopulate:
     export_tag_prefix = "Exported:"
     export_tag = f"{export_tag_prefix} %Y-%m-%d %H:%M:%S"
     metadata_filename = "metadata.json"
+    users_filename = "users.json"
     zip_args = dict(mode="w", compression=ZIP_BZIP2)
     artifacts_ext = ".artifacts"
     img_source_regex = re.compile(
@@ -78,6 +81,7 @@ class PrePopulate:
     project_cls: Type[Project]
     model_cls: Type[Model]
     user_cls: Type[User]
+    auth_user_cls: Type[AuthUser]
 
     # noinspection PyTypeChecker
     @classmethod
@@ -90,6 +94,8 @@ class PrePopulate:
             cls.project_cls = cls._get_entity_type("database.model.project.Project")
         if not hasattr(cls, "user_cls"):
             cls.user_cls = cls._get_entity_type("database.model.User")
+        if not hasattr(cls, "auth_user_cls"):
+            cls.auth_user_cls = cls._get_entity_type("database.model.auth.User")
 
     class JsonLinesWriter:
         def __init__(self, file: BinaryIO):
@@ -205,6 +211,8 @@ class PrePopulate:
         task_statuses: Sequence[str] = None,
         tag_exported_entities: bool = False,
         metadata: Mapping[str, Any] = None,
+        export_events: bool = True,
+        export_users: bool = False,
     ) -> Sequence[str]:
         cls._init_entity_types()
 
@@ -240,11 +248,15 @@ class PrePopulate:
         with ZipFile(file, **cls.zip_args) as zfile:
             if metadata:
                 zfile.writestr(cls.metadata_filename, meta_str)
+            if export_users:
+                cls._export_users(zfile)
             artifacts = cls._export(
                 zfile,
                 entities=entities,
                 hash_=hash_,
                 tag_entities=tag_exported_entities,
+                export_events=export_events,
+                cleanup_users=not export_users,
             )
 
         file_with_hash = file.with_name(f"{file.stem}_{hash_.hexdigest()}{file.suffix}")
@@ -265,6 +277,9 @@ class PrePopulate:
             metadata_hash=metadata_hash,
         )
 
+        if created_files:
+            print("Created files:\n" + "\n".join(file for file in created_files))
+
         return created_files
 
     @classmethod
@@ -296,18 +311,26 @@ class PrePopulate:
             except Exception:
                 pass
 
-            if not user_id:
-                user_id, user_name = "__allegroai__", "Allegro.ai"
-
             # Make sure we won't end up with an invalid company ID
             if company_id is None:
                 company_id = ""
 
+            user_mapping = cls._import_users(zfile, company_id)
+
+            if not user_id:
+                user_id, user_name = "__allegroai__", "Allegro.ai"
+
             existing_user = cls.user_cls.objects(id=user_id).only("id").first()
             if not existing_user:
                 cls.user_cls(id=user_id, name=user_name, company=company_id).save()
 
-            cls._import(zfile, company_id, user_id, metadata)
+            cls._import(
+                zfile,
+                company_id=company_id,
+                user_id=user_id,
+                metadata=metadata,
+                user_mapping=user_mapping,
+            )
 
         if artifacts_path and os.path.isdir(artifacts_path):
             artifacts_file = Path(filename).with_suffix(cls.artifacts_ext)
@@ -438,7 +461,7 @@ class PrePopulate:
         projects: Sequence[str] = None,
         task_statuses: Sequence[str] = None,
     ) -> Dict[Type[mongoengine.Document], Set[mongoengine.Document]]:
-        entities = defaultdict(set)
+        entities: Dict[Any] = defaultdict(set)
 
         if projects:
             print("Reading projects...")
@@ -497,7 +520,6 @@ class PrePopulate:
     @classmethod
     def _cleanup_model(cls, model: Model):
         model.company = ""
-        model.user = ""
         model.tags = cls._filter_out_export_tags(model.tags)
 
     @classmethod
@@ -505,7 +527,6 @@ class PrePopulate:
         task.comment = "Auto generated by Allegro.ai"
         task.status_message = ""
         task.status_reason = ""
-        task.user = ""
         task.company = ""
         task.tags = cls._filter_out_export_tags(task.tags)
         if task.output:
@@ -513,17 +534,32 @@ class PrePopulate:
 
     @classmethod
     def _cleanup_project(cls, project: Project):
-        project.user = ""
         project.company = ""
         project.tags = cls._filter_out_export_tags(project.tags)
 
     @classmethod
-    def _cleanup_entity(cls, entity_cls, entity):
+    def _cleanup_auth_user(cls, user: AuthUser):
+        user.company = ""
+        for cred in user.credentials:
+            if getattr(cred, "company", None):
+                cred["company"] = ""
+        return user
+
+    @classmethod
+    def _cleanup_be_user(cls, user: User):
+        user.company = ""
+        user.preferences = None
+        return user
+
+    @classmethod
+    def _cleanup_entity(cls, entity_cls, entity, cleanup_users):
+        if cleanup_users:
+            entity.user = ""
         if entity_cls == cls.task_cls:
             cls._cleanup_task(entity)
         elif entity_cls == cls.model_cls:
             cls._cleanup_model(entity)
-        elif entity == cls.project_cls:
+        elif entity_cls == cls.project_cls:
             cls._cleanup_project(entity)
 
     @classmethod
@@ -633,6 +669,38 @@ class PrePopulate:
             else:
                 print(f"Artifact {full_path} not found")
 
+    @classmethod
+    def _export_users(cls, writer: ZipFile):
+        auth_users = {
+            user.id: cls._cleanup_auth_user(user)
+            for user in cls.auth_user_cls.objects(role__in=(Role.admin, Role.user))
+        }
+        if not auth_users:
+            return
+
+        be_users = {
+            user.id: cls._cleanup_be_user(user)
+            for user in cls.user_cls.objects(id__in=list(auth_users))
+        }
+        if not be_users:
+            return
+
+        auth_users = {uid: data for uid, data in auth_users.items() if uid in be_users}
+        print(f"Writing {len(auth_users)} users into {writer.filename}")
+        data = {}
+        for field, users in (("auth", auth_users), ("backend", be_users)):
+            with BytesIO() as f:
+                with cls.JsonLinesWriter(f) as w:
+                    for user in users.values():
+                        w.write(user.to_json())
+                data[field] = f.getvalue()
+
+        def get_field_bytes(k: str, v: bytes) -> bytes:
+            return f'"{k}": '.encode("utf-8") + v
+
+        data_str = b",\n".join(get_field_bytes(k, v) for k, v in data.items())
+        writer.writestr(cls.users_filename, b"{\n" + data_str + b"\n}")
+
     @classmethod
     def _get_base_filename(cls, cls_: type):
         name = f"{cls_.__module__}.{cls_.__name__}"
@@ -642,7 +710,13 @@ class PrePopulate:
 
     @classmethod
     def _export(
-        cls, writer: ZipFile, entities: dict, hash_, tag_entities: bool = False
+        cls,
+        writer: ZipFile,
+        entities: dict,
+        hash_,
+        tag_entities: bool = False,
+        export_events: bool = True,
+        cleanup_users: bool = True,
     ) -> Sequence[str]:
         """
         Export the requested experiments, projects and models and return the list of artifact files
@@ -656,18 +730,19 @@ class PrePopulate:
             if not items:
                 continue
             base_filename = cls._get_base_filename(cls_)
-            for item in items:
-                artifacts.extend(
-                    cls._export_entity_related_data(
-                        cls_, item, base_filename, writer, hash_
+            if export_events:
+                for item in items:
+                    artifacts.extend(
+                        cls._export_entity_related_data(
+                            cls_, item, base_filename, writer, hash_
+                        )
                     )
-                )
             filename = base_filename + ".json"
             print(f"Writing {len(items)} items into {writer.filename}:{filename}")
             with BytesIO() as f:
                 with cls.JsonLinesWriter(f) as w:
                     for item in items:
-                        cls._cleanup_entity(cls_, item)
+                        cls._cleanup_entity(cls_, item, cleanup_users=cleanup_users)
                         w.write(item.to_json())
                 data = f.getvalue()
                 hash_.update(data)
@@ -717,7 +792,10 @@ class PrePopulate:
 
     @classmethod
     def _generate_new_ids(
-        cls, reader: ZipFile, entity_files: Sequence, metadata: Mapping[str, Any],
+        cls,
+        reader: ZipFile,
+        entity_files: Sequence,
+        metadata: Mapping[str, Any],
     ) -> Mapping[str, str]:
         if not metadata or not any(
             metadata.get(key) for key in ("new_ids", "example_ids", "private_ids")
@@ -745,6 +823,68 @@ class PrePopulate:
                         )
         return ids
 
+    @classmethod
+    def _import_users(cls, reader: ZipFile, company_id: str = "") -> dict:
+        """
+        Import users to db and return the mapping of old user ids to the new ones
+        If no users were in the users file then the mapping was empty
+        If the user in the file has the same email as one of the existing ones then this user is skipped
+        and its id is mapped to the existing user with the same email
+        If the user with the same id exists in backend or auth db then its creation is skipped
+        """
+        users_file = first(
+            fi for fi in reader.filelist if fi.orig_filename == cls.users_filename
+        )
+        if not users_file:
+            return {}
+
+        existing_user_ids = set(cls.user_cls.objects().scalar("id")) | set(
+            cls.auth_user_cls.objects().scalar("id")
+        )
+        existing_user_emails = {u.email: u.id for u in cls.auth_user_cls.objects()}
+        user_id_mappings = {}
+
+        with reader.open(users_file) as f:
+            data = json.loads(f.read())
+
+        auth_users = {u["_id"]: u for u in data["auth"]}
+        be_users = {u["_id"]: u for u in data["backend"]}
+        for uid, user in auth_users.items():
+            email = user.get("email")
+            existing_user_id = existing_user_emails.get(email)
+            if existing_user_id:
+                user_id_mappings[uid] = existing_user_id
+                continue
+
+            user_id_mappings[uid] = uid
+            if uid in existing_user_ids:
+                continue
+
+            credentials = user.get("credentials", [])
+            for c in credentials:
+                if c.get("company") == "":
+                    c["company"] = company_id
+
+            if hasattr(cls.auth_user_cls, "sec_groups"):
+                user_role = user.get("role", Role.user)
+                if user_role == Role.user:
+                    user["sec_groups"] = ["30795571-a470-4717-a80d-e8705fc776bf"]
+                else:
+                    user["sec_groups"] = [
+                        "c14a3cc6-1144-4896-8ea6-fb186ee19896",
+                        "30795571-a470-4717-a80d-e8705fc776bf",
+                        "30795571a4704717a80de8705897ytuyg",
+                    ]
+
+            auth_user = cls.auth_user_cls.from_json(json.dumps(user), created=True)
+            auth_user.company = company_id
+            auth_user.save()
+            be_user = cls.user_cls.from_json(json.dumps(be_users[uid]), created=True)
+            be_user.company = company_id
+            be_user.save()
+
+        return user_id_mappings
+
     @classmethod
     def _import(
         cls,
@@ -753,6 +893,7 @@ class PrePopulate:
         user_id: str = None,
         metadata: Mapping[str, Any] = None,
         sort_tasks_by_last_updated: bool = True,
+        user_mapping: Mapping[str, str] = None,
     ):
         """
         Import entities and events from the zip file
@@ -763,7 +904,7 @@ class PrePopulate:
             fi
             for fi in reader.filelist
             if not fi.orig_filename.endswith(event_file_ending)
-            and fi.orig_filename != cls.metadata_filename
+            and fi.orig_filename not in (cls.metadata_filename, cls.users_filename)
         ]
         metadata = metadata or {}
         old_to_new_ids = cls._generate_new_ids(reader, entity_files, metadata)
@@ -773,7 +914,13 @@ class PrePopulate:
                 full_name = splitext(entity_file.orig_filename)[0]
                 print(f"Reading {reader.filename}:{full_name}...")
                 res = cls._import_entity(
-                    f, full_name, company_id, user_id, metadata, old_to_new_ids
+                    f,
+                    full_name=full_name,
+                    company_id=company_id,
+                    user_id=user_id,
+                    metadata=metadata,
+                    old_to_new_ids=old_to_new_ids,
+                    user_mapping=user_mapping,
                 )
                 if res:
                     tasks = res
@@ -794,7 +941,7 @@ class PrePopulate:
             with reader.open(events_file) as f:
                 full_name = splitext(events_file.orig_filename)[0]
                 print(f"Reading {reader.filename}:{full_name}...")
-                cls._import_events(f, company_id, user_id, task.id)
+                cls._import_events(f, company_id, task.user, task.id)
 
     @classmethod
     def _get_entity_type(cls, full_name) -> Type[mongoengine.Document]:
@@ -874,7 +1021,7 @@ class PrePopulate:
         ):
             old_path = old_field.split(".")
             old_model = nested_get(task_data, old_path)
-            new_models = models.get(type_, [])
+            new_models = [m for m in models.get(type_, []) if m.get("model") is not None]
             name = TaskModelNames[type_]
             if old_model and not any(
                 m
@@ -908,7 +1055,9 @@ class PrePopulate:
         user_id: str,
         metadata: Mapping[str, Any],
         old_to_new_ids: Mapping[str, str] = None,
+        user_mapping: Mapping[str, str] = None,
     ) -> Optional[Sequence[Task]]:
+        user_mapping = user_mapping or {}
         cls_ = cls._get_entity_type(full_name)
         print(f"Writing {cls_.__name__.lower()}s into database")
         tasks = []
@@ -930,7 +1079,7 @@ class PrePopulate:
 
             doc = cls_.from_json(item, created=True)
             if hasattr(doc, "user"):
-                doc.user = user_id
+                doc.user = user_mapping.get(doc.user, user_id) if doc.user else user_id
             if hasattr(doc, "company"):
                 doc.company = company_id
             if isinstance(doc, cls.project_cls):
@@ -960,13 +1109,17 @@ class PrePopulate:
             return tasks
 
     @classmethod
-    def _import_events(cls, f: IO[bytes], company_id: str, _, task_id: str):
+    def _import_events(cls, f: IO[bytes], company_id: str, user_id: str, task_id: str):
         print(f"Writing events for task {task_id} into database")
         for events_chunk in chunked_iter(cls.json_lines(f), 1000):
             events = [json.loads(item) for item in events_chunk]
             for ev in events:
                 ev["task"] = task_id
                 ev["company_id"] = company_id
+                ev["allow_locked"] = True
             cls.event_bll.add_events(
-                company_id, events=events, worker="", allow_locked=True
+                company_id=company_id,
+                identity=Identity(user_id, company=company_id, role=Role.admin),
+                events=events,
+                worker="",
             )

apiserver/mongo/initialize/user.py

@@ -26,6 +26,7 @@ def _ensure_auth_user(user_data: dict, company_id: str, log: Logger, revoke: boo
         credentials = [] if revoke else [creds]
 
     user_id = user_data.get("id", f"__{user_data['name']}__")
+    autocreated = user_data.get("autocreated", False)
 
     log.info(f"Creating user: {user_data['name']}")
 
@@ -37,6 +38,7 @@ def _ensure_auth_user(user_data: dict, company_id: str, log: Logger, revoke: boo
         email=user_data["email"],
         created=datetime.utcnow(),
         credentials=credentials,
+        autocreated=autocreated,
     )
 
     user.save()
@@ -59,7 +61,7 @@ def _ensure_backend_user(user_id: str, company_id: str, user_name: str):
     return user_id
 
 
-def ensure_fixed_user(user: FixedUser, log: Logger):
+def ensure_fixed_user(user: FixedUser, log: Logger, emails: set):
     db_user = User.objects(company=user.company, id=user.user_id).first()
     if db_user:
         # noinspection PyBroadException
@@ -73,9 +75,12 @@ def ensure_fixed_user(user: FixedUser, log: Logger):
 
     data = attr.asdict(user)
     data["id"] = user.user_id
-    data["email"] = f"{user.user_id}@example.com"
+    email = f"{user.user_id}@example.com"
+    data["email"] = email
     data["role"] = Role.guest if user.is_guest else Role.user
+    data["autocreated"] = True
 
     _ensure_auth_user(user_data=data, company_id=user.company, log=log)
+    emails.add(email)
 
     return _ensure_backend_user(user.user_id, user.company, user.name)

apiserver/mongo/migrations/1_9_0.py

@@ -0,0 +1,17 @@
+import logging as log
+
+from pymongo.collection import Collection
+from pymongo.database import Database
+from pymongo.errors import OperationFailure
+
+
+def migrate_backend(db: Database):
+    """
+    Drop task text index so that the new one including reports field is created
+    """
+    tasks: Collection = db["task"]
+    try:
+        tasks.drop_index("backend-db.task.main_text_index")
+    except OperationFailure as ex:
+        log.warning(f"Could not delete task text index due to: {str(ex)}")
+        pass

apiserver/redis_manager.py

@@ -2,7 +2,7 @@ from os import getenv
 
 from boltons.iterutils import first
 from redis import StrictRedis
-from rediscluster import RedisCluster
+from redis.cluster import RedisCluster
 
 from apiserver.apierrors.errors.server_error import ConfigError, GeneralError
 from apiserver.config_repo import config
@@ -83,7 +83,7 @@ class RedisManager(object):
     def host(self, alias):
         r = self.connection(alias)
         if isinstance(r, RedisCluster):
-            connections = first(r.connection_pool._available_connections.values())
+            connections = r.get_default_node().redis_connection.connection_pool._available_connections
         else:
             connections = r.connection_pool._available_connections
 

apiserver/requirements.txt

@@ -1,33 +1,37 @@
-attrs>=22.1.0
+attrs>=22.1.0,<23
+azure-storage-blob>=12.13.1
 bcrypt>=3.1.4
 boltons>=19.1.0
-boto3==1.14.13
+boto3>=1.26
+boto3-stubs[s3]>=1.26
+clearml>=1.10.3
 dpath>=1.4.2,<2.0
-elasticsearch==7.13.3
+elasticsearch==8.12.0
 fastjsonschema>=2.8
 flask-compress>=1.4.0
 flask-cors>=3.0.5
-flask>=0.12.2
-funcsigs==1.0.2
+flask>=2.3.3
 furl>=2.0.0
-gunicorn>=19.7.1
-humanfriendly==4.18
-jinja2==2.11.3
+google-cloud-storage>=2.8.0
+gunicorn>=20.1.0
+humanfriendly>=4.17
+jinja2
 jsonmodels>=2.3
 jsonschema>=2.6.0
 luqum>=0.10.0
-mongoengine==0.23.1
+mongoengine==0.27.0
 nested_dict>=1.61
 packaging==20.3
 psutil>=5.6.5
-pyhocon>=0.3.35
+pyhocon>=0.3.35r
 pyjwt>=2.4.0
-pymongo[srv]==3.12.0
+pymongo==4.4.0
 python-rapidjson>=0.6.3
-redis==3.5.3
-redis-py-cluster>=2.1.3
+redis>=4.5.4,<5
 requests>=2.13.0
 semantic_version>=2.8.3,<3
+setuptools>=65.5.1
 six
-tqdm
-validators>=0.12.4
+validators>=0.12.4
+urllib3>=1.26.18
+werkzeug>=3.0.1

apiserver/schema/services/_common.conf

@@ -1,3 +1,43 @@
+field_filter {
+    type: object
+    description: Filter on a field that includes combination of 'any' or 'all' included and excluded terms
+    properties {
+        any {
+            type: object
+            description: All the terms in 'any' condition are combined with 'or' operation
+            properties {
+                "include" {
+                    type: array
+                    items {type: string}
+                }
+                exclude {
+                    type: array
+                    items {type: string}
+                }
+            }
+        }
+        all {
+            type: object
+            description: All the terms in 'all' condition are combined with 'and' operation
+            properties {
+                "include" {
+                    type: array
+                    items {type: string}
+                }
+                exclude {
+                    type: array
+                    items {type: string}
+                }
+            }
+        }
+        op {
+            type: string
+            description: The operation between 'any' and 'all' parts of the filter if both are provided
+            default: and
+            enum: [and, or]
+        }
+    }
+}
 metadata_item {
     type: object
     properties {
@@ -15,6 +55,35 @@ metadata_item {
         }
     }
 }
+task_status_enum {
+    type: string
+    enum: [
+        created
+        queued
+        in_progress
+        stopped
+        published
+        publishing
+        closed
+        failed
+        completed
+        unknown
+    ]
+}
+multi_field_pattern_data {
+    type: object
+    properties {
+        pattern {
+            description: "Pattern string (regex)"
+            type: string
+        }
+        fields {
+            description: "List of field names"
+            type: array
+            items { type: string }
+        }
+    }
+}
 credentials {
     type: object
     properties {

apiserver/schema/services/_events_common.conf

@@ -0,0 +1,141 @@
+scalar_key_enum {
+    type: string
+    enum: [
+        iter
+        timestamp
+        iso_time
+    ]
+}
+metric_variants {
+    type: object
+    properties {
+        metric {
+            description: The metric name
+            type: string
+        }
+        variants {
+            type: array
+            description: The names of the metric variants
+            items {type: string}
+        }
+    }
+}
+debug_images_response_task_metrics {
+    type: object
+    properties {
+        task {
+            type: string
+            description: Task ID
+        }
+        iterations {
+            type: array
+            items {
+                type: object
+                properties {
+                    iter {
+                        type: integer
+                        description: Iteration number
+                    }
+                    events {
+                        type: array
+                        items {
+                            type: object
+                            description: Debug image event
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+debug_images_response {
+    type: object
+    properties {
+        scroll_id {
+            type: string
+            description: "Scroll ID for getting more results"
+        }
+        metrics {
+            type: array
+            description: "Debug image events grouped by tasks and iterations"
+            items {"$ref": "#/definitions/debug_images_response_task_metrics"}
+        }
+    }
+}
+plots_response_task_metrics {
+    type: object
+    properties {
+        task {
+            type: string
+            description: Task ID
+        }
+        iterations {
+            type: array
+            items {
+                type: object
+                properties {
+                    iter {
+                        type: integer
+                        description: Iteration number
+                    }
+                    events {
+                        type: array
+                        items {
+                            type: object
+                            description: Plot event
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+plots_response {
+    type: object
+    properties {
+        scroll_id {
+            type: string
+            description: "Scroll ID for getting more results"
+        }
+        metrics {
+            type: array
+            description: "Plot events grouped by tasks and iterations"
+            items {"$ref": "#/definitions/plots_response_task_metrics"}
+        }
+    }
+}
+single_value_task_metrics {
+    type: object
+    properties {
+        task {
+            type: string
+            description: Task ID
+        }
+        task_name {
+            type: string
+            description: Task name
+        }
+        values {
+            type: array
+            items {
+                type: object
+                properties {
+                    metric { type: string }
+                    variant { type: string}
+                    value { type: number }
+                    timestamp { type: number }
+                }
+            }
+        }
+    }
+}
+single_value_metrics_response {
+    type: object
+    properties {
+        tasks {
+            description: Single value metrics grouped by task
+            type: array
+            items {"$ref": "#/definitions/single_value_task_metrics"}
+        }
+    }
+}

apiserver/schema/services/_tasks_common.conf

@@ -0,0 +1,506 @@
+include "_common.conf"
+task_type_enum {
+    type: string
+    enum: [
+        training
+        testing
+        inference
+        data_processing
+        application
+        monitor
+        controller
+        optimizer
+        service
+        qc
+        custom
+    ]
+}
+script {
+    type: object
+    properties {
+        binary {
+            description: "Binary to use when running the script"
+            type: string
+            default: python
+        }
+        repository {
+            description: "Name of the repository where the script is located"
+            type: string
+        }
+        tag {
+            description: "Repository tag"
+            type: string
+        }
+        branch  {
+            description: "Repository branch id If not provided and tag not provided, default repository branch is used."
+            type: string
+        }
+        version_num {
+            description: "Version (changeset) number. Optional (default is head version) Unused if tag is provided."
+            type: string
+        }
+        entry_point {
+            description: "Path to execute within the repository"
+            type: string
+        }
+        working_dir {
+            description: "Path to the folder from which to run the script Default - root folder of repository"
+            type: string
+        }
+        requirements {
+            description: "A JSON object containing requirements strings by key"
+            type: object
+        }
+        diff {
+            description: "Uncommitted changes found in the repository when task was run"
+            type: string
+        }
+    }
+}
+model_type_enum {
+    type: string
+    enum: ["input", "output"]
+}
+task_model_item {
+    type: object
+    required: [ name, model]
+    properties {
+        name {
+            description: "The task model name"
+            type: string
+        }
+        model {
+            description: "The model ID"
+            type: string
+        }
+    }
+}
+output {
+        type: object
+        properties {
+            destination {
+                description: "Storage id. This is where output files will be stored."
+                type: string
+            }
+            model {
+                description: "Model id."
+                type: string
+            }
+            result {
+                description: "Task result. Values: 'success', 'failure'"
+                type: string
+            }
+            error {
+                description: "Last error text"
+                type: string
+            }
+        }
+    }
+task_execution_progress_enum {
+    type: string
+    enum: [
+        unknown
+        running
+        stopping
+        stopped
+    ]
+}
+artifact_type_data {
+    type: object
+    properties {
+        preview {
+            description: "Description or textual data"
+            type: string
+        }
+        content_type {
+            description: "System defined raw data content type"
+            type: string
+        }
+        data_hash {
+            description: "Hash of raw data, without any headers or descriptive parts"
+            type: string
+        }
+    }
+}
+artifact_mode_enum {
+    type: string
+    enum: [
+        input
+        output
+    ]
+    default: output
+}
+artifact {
+    type: object
+    required: [key, type]
+    properties {
+        key {
+            description: "Entry key"
+            type: string
+        }
+        type {
+            description: "System defined type"
+            type: string
+        }
+        mode {
+            description: "System defined input/output indication"
+            "$ref": "#/definitions/artifact_mode_enum"
+        }
+        uri {
+            description: "Raw data location"
+            type: string
+        }
+        content_size {
+            description: "Raw data length in bytes"
+            type: integer
+        }
+        hash {
+            description: "Hash of entire raw data"
+            type: string
+        }
+        timestamp {
+            description: "Epoch time when artifact was created"
+            type: integer
+        }
+        type_data {
+            description: "Additional fields defined by the system"
+            "$ref": "#/definitions/artifact_type_data"
+        }
+        display_data {
+            description: "User-defined list of key/value pairs, sorted"
+            type: array
+            items {
+                type: array
+                items {
+                    type: string  # can also be a number... TODO: upgrade the generator
+                }
+            }
+        }
+    }
+}
+artifact_id {
+    type: object
+    required: [key]
+    properties {
+        key {
+            description: "Entry key"
+            type: string
+        }
+        mode {
+            description: "System defined input/output indication"
+            "$ref": "#/definitions/artifact_mode_enum"
+        }
+    }
+}
+task_models {
+    type: object
+    properties {
+        input {
+            description: "The list of task input models"
+            type: array
+            items {"$ref": "#/definitions/task_model_item"}
+
+        }
+        output {
+            description: "The list of task output models"
+            type: array
+            items {"$ref": "#/definitions/task_model_item"}
+        }
+    }
+}
+execution {
+    type: object
+    properties {
+        queue {
+            description: "Queue ID where task was queued."
+            type: string
+        }
+        parameters {
+            description: "Json object containing the Task parameters"
+            type: object
+            additionalProperties: true
+        }
+        model {
+            description: "Execution input model ID Not applicable for Register (Import) tasks"
+            type: string
+        }
+        model_desc {
+            description: "Json object representing the Model descriptors"
+            type: object
+            additionalProperties: true
+        }
+        model_labels {
+            description: """Json object representing the ids of the labels in the model.
+            The keys are the layers' names and the values are the IDs.
+            Not applicable for Register (Import) tasks.
+            Mandatory for Training tasks"""
+            type: object
+            additionalProperties: { type: integer }
+        }
+        framework {
+            description: """Framework related to the task. Case insensitive. Mandatory for Training tasks. """
+            type: string
+        }
+        docker_cmd {
+            description: "Command for running docker script for the execution of the task"
+            type: string
+        }
+        artifacts {
+            description: "Task artifacts"
+            type: array
+            items { "$ref": "#/definitions/artifact" }
+        }
+    }
+}
+last_metrics_event {
+    type: object
+    properties {
+        metric {
+            description: "Metric name"
+            type: string
+        }
+        variant {
+            description: "Variant name"
+            type: string
+        }
+        value {
+            description: "Last value reported"
+            type: number
+        }
+        min_value {
+            description: "Minimum value reported"
+            type: number
+        }
+        min_value_iteration {
+            description: "The iteration at which the minimum value was reported"
+            type: integer
+        }
+        max_value {
+            description: "Maximum value reported"
+            type: number
+        }
+        max_value_iteration {
+            description: "The iteration at which the maximum value was reported"
+            type: integer
+        }
+    }
+}
+last_metrics_variants {
+    type: object
+    description: "Last metric events, one for each variant hash"
+    additionalProperties {
+        "$ref": "#/definitions/last_metrics_event"
+    }
+}
+params_item {
+    type: object
+    properties {
+        section {
+            description: "Section that the parameter belongs to"
+            type: string
+        }
+        name {
+            description: "Name of the parameter. The combination of section and name should be unique"
+            type: string
+        }
+        value {
+            description: "Value of the parameter"
+            type: string
+        }
+        type {
+            description: "Type of the parameter. Optional"
+            type: string
+        }
+        description {
+            description: "The parameter description. Optional"
+            type: string
+        }
+    }
+}
+configuration_item {
+    type: object
+    properties {
+        name {
+            description: "Name of the parameter. Should be unique"
+            type: string
+        }
+        value {
+            description: "Value of the parameter"
+            type: string
+        }
+        type {
+            description: "Type of the parameter. Optional"
+            type: string
+        }
+        description {
+            description: "The parameter description. Optional"
+            type: string
+        }
+    }
+}
+section_params {
+    description: "Task section params"
+    type: object
+    additionalProperties {
+        "$ref": "#/definitions/params_item"
+    }
+}
+task {
+    type: object
+    properties {
+        id {
+            description: "Task id"
+            type: string
+        }
+        name {
+            description: "Task Name"
+            type: string
+        }
+        user {
+            description: "Associated user id"
+            type: string
+        }
+        company {
+            description: "Company ID"
+            type: string
+        }
+        type {
+            description: "Type of task. Values: 'training', 'testing'"
+            "$ref": "#/definitions/task_type_enum"
+        }
+        status {
+            description: ""
+            "$ref": "#/definitions/task_status_enum"
+        }
+        comment {
+            description: "Free text comment"
+            type: string
+        }
+        created {
+            description: "Task creation time (UTC) "
+            type: string
+            format: "date-time"
+        }
+        started {
+            description: "Task start time (UTC)"
+            type: string
+            format: "date-time"
+        }
+        completed {
+            description: "Task end time (UTC)"
+            type: string
+            format: "date-time"
+        }
+        active_duration {
+            description: "Task duration time (seconds)"
+            type: integer
+        }
+        parent {
+            description: "Parent task id"
+            type: string
+        }
+        project {
+            description: "Project ID of the project to which this task is assigned"
+            type: string
+        }
+        output {
+            description: "Task output params"
+            "$ref": "#/definitions/output"
+        }
+        execution {
+            description: "Task execution params"
+            "$ref": "#/definitions/execution"
+        }
+        container {
+            description: "Docker container parameters"
+            type: object
+            additionalProperties { type: string }
+        }
+        models {
+            description: "Task models"
+            "$ref": "#/definitions/task_models"
+        }
+        // TODO: will be removed
+        script {
+            description: "Script info"
+            "$ref": "#/definitions/script"
+        }
+        tags {
+            description: "User-defined tags list"
+            type: array
+            items { type: string }
+        }
+        system_tags {
+            description: "System tags list. This field is reserved for system use, please don't use it."
+            type: array
+            items { type: string }
+        }
+        status_changed {
+            description: "Last status change time"
+            type: string
+            format: "date-time"
+        }
+        status_message {
+            description: "free text string representing info about the status"
+            type: string
+        }
+        status_reason {
+            description: "Reason for last status change"
+            type: string
+        }
+        published {
+            description: "Task publish time"
+            type: string
+            format: "date-time"
+        }
+        last_worker {
+            description: "ID of last worker that handled the task"
+            type: string
+        }
+        last_worker_report {
+            description: "Last time a worker reported while working on this task"
+            type: string
+            format: "date-time"
+        }
+        last_update {
+            description: "Last time this task was created, edited, changed or events for this task were reported"
+            type: string
+            format: "date-time"
+        }
+        last_change {
+            description: "Last time any update was done to the task"
+            type: string
+            format: "date-time"
+        }
+        last_iteration {
+            description: "Last iteration reported for this task"
+            type: integer
+        }
+        last_metrics {
+            description: "Last metric variants (hash to events), one for each metric hash"
+            type: object
+            additionalProperties {
+                "$ref": "#/definitions/last_metrics_variants"
+            }
+        }
+        hyperparams {
+            description: "Task hyper params per section"
+            type: object
+            additionalProperties {
+                "$ref": "#/definitions/section_params"
+            }
+        }
+        configuration {
+            description: "Task configuration params"
+            type: object
+            additionalProperties {
+                "$ref": "#/definitions/configuration_item"
+            }
+        }
+        runtime {
+            description: "Task runtime mapping"
+            type: object
+            additionalProperties: true
+        }
+    }
+}

apiserver/schema/services/events.conf

@@ -1,17 +1,6 @@
 _description : "Provides an API for running tasks to report events collected by the system."
 _definitions {
-    metric_variants {
-        type: object
-        metric {
-            description: The metric name
-            type: string
-        }
-        variants {
-            type: array
-            description: The names of the metric variants
-            items {type: string}
-        }
-    }
+    include "_events_common.conf"
     metrics_scalar_event {
         description: "Used for reporting scalar metrics during training task"
         type: object
@@ -22,8 +11,8 @@ _definitions {
                 type: number
             }
             type {
-                description: "training_stats_vector"
-                const: "training_stats_scalar"
+                description: "'training_stats_scalar'"
+                type: string
             }
             task {
                 description: "Task ID (required)"
@@ -57,8 +46,8 @@ _definitions {
                 type: number
             }
             type {
-                description: "training_stats_vector"
-                const: "training_stats_vector"
+                description: "'training_stats_vector'"
+                type: string
             }
             task {
                 description: "Task ID (required)"
@@ -93,8 +82,8 @@ _definitions {
                 type: number
             }
             type {
-                description: ""
-                const: "training_debug_image"
+                description: "'training_debug_image'"
+                type: string
             }
             task {
                 description: "Task ID (required)"
@@ -134,7 +123,7 @@ _definitions {
             }
             type {
                 description: "'plot'"
-                const: "plot"
+                type: string
             }
             task {
                 description: "Task ID (required)"
@@ -164,14 +153,6 @@ _definitions {
             }
         }
     }
-    scalar_key_enum {
-        type: string
-        enum: [
-            iter
-            timestamp
-            iso_time
-        ]
-    }
     log_level_enum {
         type: string
         enum: [
@@ -240,7 +221,7 @@ _definitions {
             }
             type {
                 description: "'log'"
-                const: "log"
+                type: string
             }
             task {
                 description: "Task ID (required)"
@@ -260,90 +241,6 @@ _definitions {
             }
         }
     }
-    debug_images_response_task_metrics {
-        type: object
-        properties {
-            task {
-                type: string
-                description: Task ID
-            }
-            iterations {
-                type: array
-                items {
-                    type: object
-                    properties {
-                        iter {
-                            type: integer
-                            description: Iteration number
-                        }
-                        events {
-                            type: array
-                            items {
-                                type: object
-                                description: Debug image event
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    debug_images_response {
-        type: object
-        properties {
-            scroll_id {
-                type: string
-                description: "Scroll ID for getting more results"
-            }
-            metrics {
-                type: array
-                description: "Debug image events grouped by tasks and iterations"
-                items {"$ref": "#/definitions/debug_images_response_task_metrics"}
-            }
-        }
-    }
-    plots_response_task_metrics {
-        type: object
-        properties {
-            task {
-                type: string
-                description: Task ID
-            }
-            iterations {
-                type: array
-                items {
-                    type: object
-                    properties {
-                        iter {
-                            type: integer
-                            description: Iteration number
-                        }
-                        events {
-                            type: array
-                            items {
-                                type: object
-                                description: Plot event
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    plots_response {
-        type: object
-        properties {
-            scroll_id {
-                type: string
-                description: "Scroll ID for getting more results"
-            }
-            metrics {
-                type: array
-                description: "Plot events grouped by tasks and iterations"
-                items {"$ref": "#/definitions/plots_response_task_metrics"}
-            }
-        }
-    }
     debug_image_sample_response {
         type: object
         properties {
@@ -547,7 +444,7 @@ debug_images {
                 }
                 total {
                     type: number
-                    description: "Total number of results available for this query"
+                    description: "Total number of results available for this query. In case there are more than 10000 results it is set to 10000"
                 }
                 scroll_id {
                     type: string
@@ -601,7 +498,7 @@ debug_images {
         }
     }
     "2.22": ${debug_images."2.14"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
@@ -624,7 +521,7 @@ plots {
                 }
                 iters {
                     type: integer
-                    description: "Max number of latest iterations for which to return debug images"
+                    description: "Max number of latest iterations for which to return plots"
                 }
                 navigate_earlier {
                     type: boolean
@@ -643,7 +540,7 @@ plots {
         response {"$ref": "#/definitions/plots_response"}
     }
     "2.22": ${plots."2.20"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model plots. Otherwise task plots
             default: false
@@ -693,7 +590,7 @@ get_debug_image_sample {
         }
     }
     "2.22": ${get_debug_image_sample."2.20"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model debug images. Otherwise task debug images
             default: false
@@ -730,7 +627,7 @@ next_debug_image_sample {
             default: false
             description: If set then navigate to the next/previous iteration
         }
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model debug images. Otherwise task debug images
             default: false
@@ -774,7 +671,7 @@ get_plot_sample {
         response {"$ref": "#/definitions/plot_sample_response"}
     }
     "2.22": ${get_plot_sample."2.20"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model plots. Otherwise task plots
             default: false
@@ -811,7 +708,7 @@ next_plot_sample {
             default: false
             description: If set then navigate to the next/previous iteration
         }
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model plots. Otherwise task plots
             default: false
@@ -850,13 +747,49 @@ get_task_metrics{
         }
     }
     "2.22": ${get_task_metrics."2.7"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then get metrics from model events. Otherwise from task events
             default: false
         }
     }
 }
+get_multi_task_metrics {
+    "2.28" {
+        description: """Get unique metrics and variants from the events of the specified type.
+        Only events reported for the passed task or model ids are analyzed."""
+        request {
+            type: object
+            required: [ tasks ]
+            properties {
+                tasks {
+                    description: task ids to get metrics from
+                    type: array
+                    items {type: string}
+                }
+                model_events {
+                    description: If not set or set to false then passed ids are task ids otherwise model ids
+                    type: boolean
+                    default: false
+                }
+                event_type {
+                    "description": Event type. If not specified then metrics are collected from the reported events of all types
+                    "$ref": "#/definitions/event_type_enum"
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                metrics {
+                    type: array
+                    description: List of metrics and variants
+                    items { "$ref": "#/definitions/metric_variants" }
+                }
+            }
+        }
+    }
+}
 get_task_log {
     "1.5" {
         description: "Get all 'log' events for this task"
@@ -955,7 +888,7 @@ get_task_log {
                 }
                 total {
                     type: number
-                    description: "Total number of results available for this query"
+                    description: "Total number of results available for this query. In case there are more than 10000 results it is set to 10000"
                 }
                 scroll_id {
                     type: string
@@ -1009,7 +942,7 @@ get_task_log {
                 }
                 total {
                     type: number
-                    description: "Total number of log events available for this query"
+                    description: "Total number of log events available for this query. In case there are more than 10000 events it is set to 10000"
                 }
             }
         }
@@ -1064,7 +997,7 @@ get_task_events {
                 }
                 total {
                     type: number
-                    description: "Total number of results available for this query"
+                    description: "Total number of results available for this query. In case there are more than 10000 results it is set to 10000"
                 }
                 scroll_id {
                     type: string
@@ -1074,10 +1007,17 @@ get_task_events {
         }
     }
     "2.22": ${get_task_events."2.1"} {
-        model_events {
-            type: boolean
-            description: If set then get retrieving model events. Otherwise task events
-            default: false
+        request.properties {
+            model_events {
+                type: boolean
+                description: If set then get retrieving model events. Otherwise task events
+                default: false
+            }
+            metrics {
+                type: array
+                description: List of metrics and variants
+                items { "$ref": "#/definitions/metric_variants" }
+            }
         }
     }
 }
@@ -1130,7 +1070,7 @@ get_task_plots {
                 }
                 iters {
                     type: integer
-                    description: "Max number of latest iterations for which to return debug images"
+                    description: "Max number of latest iterations for which to return plots"
                 }
                 scroll_id {
                     type: string
@@ -1154,7 +1094,7 @@ get_task_plots {
                 }
                 total {
                     type: number
-                    description: "Total number of results available for this query"
+                    description: "Total number of results available for this query. In case there are more than 10000 results it is set to 10000"
                 }
                 scroll_id {
                     type: string
@@ -1182,7 +1122,7 @@ get_task_plots {
         }
     }
     "2.22": ${get_task_plots."2.16"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
@@ -1208,7 +1148,7 @@ get_multi_task_plots {
                 }
                 iters {
                     type: integer
-                    description: "Max number of latest iterations for which to return debug images"
+                    description: "Max number of latest iterations for which to return plots"
                 }
                 scroll_id {
                     type: string
@@ -1229,7 +1169,7 @@ get_multi_task_plots {
                 }
                 total {
                     type: number
-                    description: "Total number of results available for this query"
+                    description: "Total number of results available for this query. In case there are more than 10000 results it is set to 10000"
                 }
                 scroll_id {
                     type: string
@@ -1246,12 +1186,26 @@ get_multi_task_plots {
         }
     }
     "2.22": ${get_multi_task_plots."2.16"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
         }
     }
+    "2.26": ${get_multi_task_plots."2.22"} {
+        request.properties.last_iters_per_task_metric {
+            type: boolean
+            description: If set to 'true' and iters passed then last iterations for each task metrics are retrieved. Otherwise last iterations for the whole task are retrieved
+            default: true
+        }
+    }
+    "2.28": ${get_multi_task_plots."2.26"} {
+        request.properties.metrics {
+            type: array
+            description: List of metrics and variants
+            items { "$ref": "#/definitions/metric_variants" }
+        }
+    }
 }
 get_vector_metrics_and_variants {
     "2.1" {
@@ -1281,7 +1235,7 @@ get_vector_metrics_and_variants {
         }
     }
     "2.22": ${get_vector_metrics_and_variants."2.1"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
@@ -1326,7 +1280,7 @@ vector_metrics_iter_histogram {
         }
     }
     "2.22": ${vector_metrics_iter_histogram."2.1"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
@@ -1386,7 +1340,7 @@ scalar_metrics_iter_histogram {
         }
     }
     "2.22": ${scalar_metrics_iter_histogram."2.14"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
@@ -1403,7 +1357,7 @@ multi_task_scalar_metrics_iter_histogram {
             ]
             properties {
                 tasks {
-                    description: "List of task Task IDs. Maximum amount of tasks is 10"
+                    description: "List of task Task IDs. Maximum amount of tasks is 100"
                     type: array
                     items {
                         type: string
@@ -1432,12 +1386,19 @@ multi_task_scalar_metrics_iter_histogram {
         }
     }
     "2.22": ${multi_task_scalar_metrics_iter_histogram."2.1"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
         }
     }
+    "2.28": ${multi_task_scalar_metrics_iter_histogram."2.22"} {
+        request.properties.metrics {
+            type: array
+            description: List of metrics and variants
+            items { "$ref": "#/definitions/metric_variants" }
+        }
+    }
 }
 get_task_single_value_metrics {
     "2.20" {
@@ -1456,44 +1417,22 @@ get_task_single_value_metrics {
                 }
             }
         }
-        response {
-            type: object
-            properties {
-                tasks {
-                    description: Single value metrics grouped by task
-                    type: array
-                    items {
-                        type: object
-                        properties {
-                            task {
-                                type: string
-                                description: Task ID
-                            }
-                            values {
-                                type: array
-                                items {
-                                    type: object
-                                    properties {
-                                        metric { type: string }
-                                        variant { type: string}
-                                        value { type: number }
-                                        timestamp { type: number }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
+        response {"$ref": "#/definitions/single_value_metrics_response"}
     }
     "2.22": ${get_task_single_value_metrics."2.20"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
         }
     }
+    "2.28": ${get_task_single_value_metrics."2.22"} {
+        request.properties.metrics {
+            type: array
+            description: List of metrics and variants
+            items { "$ref": "#/definitions/metric_variants" }
+        }
+    }
 }
 get_task_latest_scalar_values {
     "2.1" {
@@ -1574,7 +1513,7 @@ get_scalar_metrics_and_variants {
         }
     }
     "2.22": ${get_scalar_metrics_and_variants."2.1"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
@@ -1595,6 +1534,10 @@ get_scalar_metric_data {
                     type: string
                     description: type of metric
                 }
+                scroll_id {
+                    type: string
+                    description: "Scroll ID of previous call (used for getting more results)"
+                }
             }
         }
         response {
@@ -1617,7 +1560,7 @@ get_scalar_metric_data {
                 }
                 scroll_id {
                     type: string
-                    description: "Scroll ID of previous call (used for getting more results)"
+                    description: "Scroll ID for getting more results"
                 }
             }
         }
@@ -1630,7 +1573,7 @@ get_scalar_metric_data {
         }
     }
     "2.22": ${get_scalar_metric_data."2.16"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
@@ -1701,7 +1644,7 @@ scalar_metrics_iter_raw {
         }
     }
     "2.22": ${scalar_metrics_iter_raw."2.16"} {
-        model_events {
+        request.properties.model_events {
             type: boolean
             description: If set then the retrieving model events. Otherwise task events
             default: false
@@ -1762,4 +1705,4 @@ clear_task_log {
             }
         }
     }
-}
+}

apiserver/schema/services/login.conf

@@ -6,21 +6,12 @@ _default {
 }
 
 supported_modes {
-    authorize: false
+    authorize: null
     "2.9" {
         description:  """ Return supported login modes."""
         request {
             type: object
-            properties {
-                state {
-                    description: "ASCII base64 encoded application state"
-                    type: string
-                }
-                callback_url_prefix {
-                    description: "URL prefix used to generate the callback URL for each supported SSO provider"
-                    type: string
-                }
-            }
+            additionalProperties: false
         }
         response {
             type: object
@@ -59,7 +50,7 @@ supported_modes {
                     description: "SSO authentication providers"
                     type: object
                     additionalProperties {
-                        desctiprion: "Provider redirect URL"
+                        description: "Provider redirect URL"
                         type: string
                     }
                 }
@@ -95,7 +86,7 @@ supported_modes {
 }
 
 logout {
-    authorize: false
+    authorize: null
     allow_roles = [ "*" ]
     "2.13" {
         description: """ Logout (including SSO, if used)) """

apiserver/schema/services/models.conf

@@ -1,6 +1,6 @@
 _description: """This service provides a management interface for models (results of training tasks) stored in the system."""
 _definitions {
-    include "_common.conf"
+    include "_tasks_common.conf"
     multi_field_pattern_data {
         type: object
         properties {
@@ -104,6 +104,17 @@ _definitions {
                     "$ref": "#/definitions/metadata_item"
                 }
             }
+            last_iteration {
+                description: "Last iteration reported for this model"
+                type: integer
+            }
+            last_metrics {
+                description: "Last metric variants (hash to events), one for each metric hash"
+                type: object
+                additionalProperties {
+                    "$ref": "#/definitions/last_metrics_variants"
+                }
+            }
             stats {
                 description: "Model statistics"
                 type: object
@@ -241,6 +252,23 @@ get_all_ex {
             default: false
         }
     }
+    "2.23": ${get_all_ex."2.20"} {
+        request.properties {
+            allow_public {
+                description: "Allow public models to be returned in the results"
+                type: boolean
+                default: true
+            }
+        }
+    }
+    "2.27": ${get_all_ex."2.23"} {
+        request.properties {
+            filters {
+                type: object
+                additionalProperties: ${_definitions.field_filter}
+            }
+        }
+    }
 }
 get_all {
     "2.1" {
@@ -337,9 +365,6 @@ get_all {
                     "$ref": "#/definitions/multi_field_pattern_data"
                 }
             }
-            dependencies {
-                page: [ page_size ]
-            }
         }
         response {
             type: object
@@ -375,6 +400,17 @@ get_all {
             description: "Scroll ID that can be used with the next calls to get_all to retrieve more data"
         }
     }
+    "2.26": ${get_all."2.15"} {
+        request {
+            properties {
+                include_subprojects {
+                    description: "If set to 'true' and project field is set then models from the subprojects are searched too"
+                    type: boolean
+                    default: false
+                }
+            }
+        }
+    }
 }
 get_frameworks {
     "2.8" {
@@ -976,7 +1012,7 @@ move {
                     items { type: string }
                 }
                 project {
-                    description: "Target project ID. If not provided, `project_name` must be provided."
+                    description: "Target project ID. If not provided, `project_name` must be provided. Use null for the root project"
                     type: string
                 }
                 project_name {
@@ -1055,4 +1091,38 @@ delete_metadata {
             }
         }
     }
+}
+update_tags {
+    "2.27" {
+        description: Add or remove tags from multiple models
+        request {
+            type: object
+            properties {
+                ids {
+                    type: array
+                    description: IDs of the models to update
+                    items {type: string}
+                }
+                add_tags {
+                    type: array
+                    description: User tags to add
+                    items {type: string}
+                }
+                remove_tags {
+                    type: array
+                    description: User tags to remove
+                    items {type: string}
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                updated {
+                    type: integer
+                    description: The number of updated models
+                }
+            }
+        }
+    }
 }

apiserver/schema/services/organization.conf

@@ -1,5 +1,38 @@
 _description: "This service provides organization level operations"
-
+_definitions {
+    value_mapping {
+        type: object
+        required: [key, value]
+        properties {
+            key {
+                description: Original value
+                type: object
+            }
+            value {
+                description: Translated value
+                type: object
+            }
+        }
+    }
+    field_mapping {
+        type: object
+        required: [field]
+        properties {
+            field {
+                description: The source field name as specified in the only_fields
+                type: string
+            }
+            name {
+                description: The column name in the exported csv file
+                type: string
+            }
+            values {
+                type: array
+                items { "$ref": "#/definitions/value_mapping"}
+            }
+        }
+    }
+}
 get_tags {
     "2.8" {
         description: "Get all the user and system tags used for the company tasks and models"
@@ -170,10 +203,96 @@ get_entities_count {
                 default: false
             }
             active_users {
-                descritpion: "The list of users that were active in the project. If passes then the resulting projects are filtered to the ones that have tasks created by these users"
+                description: "The list of users that were active in the project. If passes then the resulting projects are filtered to the ones that have tasks created by these users"
                 type: array
                 items: {type: string}
             }
         }
     }
+    "2.23": ${get_entities_count."2.22"} {
+        request.properties {
+            reports {
+                type: object
+                additionalProperties: true
+                description: Search criteria for reports
+            }
+            allow_public {
+                description: "Allow public entities to be counted in the results"
+                type: boolean
+                default: true
+            }
+        }
+        response.properties {
+            reports {
+                type: integer
+                description: The number of reports matching the criteria
+            }
+        }
+    }
 }
+prepare_download_for_get_all {
+    "2.26": {
+        description: Prepares download from get_all_ex parameters
+        request {
+            type: object
+            required: [ entity_type,  only_fields, field_mappings]
+            properties {
+                only_fields {
+                    description: "List of task field names (nesting is supported using '.', e.g. execution.model_labels). If provided, this list defines the query's projection (only these fields will be returned for each result entry)"
+                    type: array
+                    items {type: string}
+                }
+                allow_public {
+                    description: "Allow public entities to be returned in the results"
+                    type: boolean
+                    default: true
+                }
+                search_hidden {
+                    description: "If set to 'true' then hidden entities are included in the search results"
+                    type: boolean
+                    default: false
+                }
+                entity_type {
+                    description: "The type of the entity to retrieve"
+                    type: string
+                    enum: [
+                        task
+                        model
+                    ]
+                }
+                field_mappings {
+                    description: The name and value mappings for the exported fields. The fields that are not in the mappings will not be exported
+                    type: array
+                    items { "$ref": "#/definitions/field_mapping"}
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                prepare_id {
+                    description: "Prepare ID (use when calling 'download_for_get_all')"
+                    type: string
+                }
+            }
+        }
+    }
+}
+download_for_get_all {
+    "2.26": {
+        description: Generates a file for the download
+        request {
+            type: object
+            required: [ prepare_id ]
+            properties {
+                prepare_id {
+                    description: "Call ID returned by a call to prepare_download_for_get_all"
+                    type: string
+                }
+            }
+        }
+        response {
+            type: string
+        }
+    }
+}

apiserver/schema/services/pipelines.conf

@@ -1,7 +1,42 @@
 _description: "Provides a management API for pipelines in the system."
 _definitions {
+    include "_common.conf"
+}
+delete_runs {
+    "2.26": ${_definitions.batch_operation} {
+        description: Delete pipeline runs
+        request {
+            required: [ids, project]
+            properties {
+                ids.description: "IDs of the pipeline runs to delete. Should be the ids of pipeline controller tasks"
+                project {
+                    description: "Pipeline project ids. When deleting at least one run should be left"
+                    type: string
+                }
+            }
+        }
+        response {
+            properties {
+                succeeded.items.properties.deleted {
+                    description: "Indicates whether the task was deleted"
+                    type: boolean
+                }
+                succeeded.items.properties.updated_children {
+                    description: "Number of child tasks whose parent property was updated"
+                    type: integer
+                }
+                succeeded.items.properties.updated_models {
+                    description: "Number of models whose task property was updated"
+                    type: integer
+                }
+                succeeded.items.properties.deleted_models {
+                    description: "Number of deleted output models"
+                    type: integer
+                }
+            }
+        }
+    }
 }
-
 start_pipeline {
     "2.17" {
         description: "Start a pipeline"
@@ -24,7 +59,7 @@ start_pipeline {
                         type: object
                         properties {
                             name: { type: string }
-                            value: { type: [string, null] }
+                            value: { type: string }
                         }
                     }
                 }
@@ -44,4 +79,15 @@ start_pipeline {
             }
         }
     }
+    "2.28": ${start_pipeline."2.17"} {
+        request.properties.verify_watched_queue {
+            description: If passed then check wheter there are any workers watiching the queue
+            type: boolean
+            default: false
+        }
+        response.properties.queue_watched {
+            description: Returns true if there are workers or autscalers working with the queue
+            type: boolean
+        }
+    }
 }

apiserver/schema/services/projects.conf

@@ -1,5 +1,6 @@
 _description: "Provides support for defining Projects containing Tasks, Models and Dataset Versions."
 _definitions {
+    include "_common.conf"
     multi_field_pattern_data {
         type: object
         properties {
@@ -61,12 +62,26 @@ _definitions {
                 type: string
             }
             last_update {
-                description: """Last project update time. Reflects the last time the project metadata was changed or a task in this project has changed status"""
+                description: "Last project update time. Reflects the last time the project metadata was changed or a task in this project has changed status"
                 type: string
                 format: "date-time"
             }
         }
     }
+    stats_datasets {
+        type: object
+        properties {
+            count {
+                description: Number of datasets
+                type: integer
+            }
+            tags {
+                description: Dataset tags
+                type: array
+                items {type: string}
+            }
+        }
+    }
     stats_status_count {
         type: object
         properties {
@@ -141,6 +156,10 @@ _definitions {
                 description: "Stats for archived tasks"
                 "$ref": "#/definitions/stats_status_count"
             }
+            datasets {
+                description: "Stats for childrent datasets"
+                "$ref": "#/definitions/stats_datasets"
+            }
         }
     }
     projects_get_all_response_single {
@@ -191,11 +210,15 @@ _definitions {
                 type: string
             }
             last_update {
-                description: """Last project update time. Reflects the last time the project metadata was changed or a task in this project has changed status"""
+                description: "Last project update time. Reflects the last time the project metadata was changed or a task in this project has changed status"
                 type: string
                 format: "date-time"
             }
             // extra properties
+            hidden {
+                description: "Returned if the search_hidden flag was specified in the get_all_ex call and the project is hidden"
+                type: boolean
+            }
             stats {
                 description: "Additional project stats"
                 "$ref": "#/definitions/stats"
@@ -217,6 +240,10 @@ _definitions {
                     }
                 }
             }
+            own_datasets {
+                description: "The amount of datasets/hyperdatasers under this project (without children projects). Returned if 'check_own_contents' flag is set in the request and children_type is set to 'dataset' or 'hyperdataset'"
+                type: integer
+            }
             own_tasks {
                 description: "The amount of tasks under this project (without children projects). Returned if 'check_own_contents' flag is set in the request"
                 type: integer
@@ -543,7 +570,7 @@ get_all_ex {
         request {
             properties {
                 active_users {
-                    descritpion: "The list of users that were active in the project. If passes then the resulting projects are filtered to the ones that have tasks created by these users"
+                    description: "The list of users that were active in the project. If passes then the resulting projects are filtered to the ones that have tasks created by these users"
                     type: array
                     items: {type: string}
                 }
@@ -611,6 +638,38 @@ get_all_ex {
             default: false
         }
     }
+    "2.23": ${get_all_ex."2.20"} {
+        request.properties {
+            allow_public {
+                description: "Allow public projects to be returned in the results"
+                type: boolean
+                default: true
+            }
+        }
+    }
+    "2.24": ${get_all_ex."2.23"} {
+        request.properties.children_type {
+            description: If specified that only the projects under which the entities of this type can be found will be returned
+            type: string
+            enum: [pipeline, report, dataset]
+        }
+    }
+    "2.25": ${get_all_ex."2.24"} {
+        request.properties.children_tags {
+            description: "The list of tag values to filter children by. Takes effect only if children_type is set. Use 'null' value to specify empty tags. Use '__Snot' value to specify that the following value should be excluded"
+            type: array
+            items {type: string}
+        }
+    }
+    "2.27": ${get_all_ex."2.25"} {
+        request.properties {
+            filters {
+                type: object
+                additionalProperties: ${_definitions.field_filter}
+            }
+            children_tags_filter: ${_definitions.field_filter}
+        }
+    }
 }
 update {
     "2.1" {
@@ -759,6 +818,26 @@ validate_delete {
             }
         }
     }
+    "2.26": ${validate_delete."2.14"} {
+        response.properties {
+            reports {
+                description: "The total number of reports under the project and all its children"
+                type: integer
+            }
+            non_archived_reports {
+                description: "The total number of non-archived reports under the project and all its children"
+                type: integer
+            }
+            pipelines {
+                description: "The total number of pipelines with active controllers under the project and all its children"
+                type: integer
+            }
+            datasets {
+                description: "The total number of non-empty datasets under the project and all its children"
+                type: integer
+            }
+        }
+    }
 }
 delete {
     "2.1" {
@@ -819,6 +898,13 @@ delete {
             }
         }
     }
+    "2.26": ${delete."2.13"} {
+        request.properties.delete_external_artifacts {
+            description: "If set to 'true' then BE will try to delete the extenal artifacts associated with the project tasks and models from the fileserver (if configured to do so)"
+            type: boolean
+            default: true
+        }
+    }
 }
 get_unique_metric_variants {
     "2.1" {
@@ -856,6 +942,20 @@ get_unique_metric_variants {
             }
         }
     }
+    "2.25": ${get_unique_metric_variants."2.13"} {
+        request.properties.model_metrics {
+            description: If set to true then bring unique metric and variant names from the project models otherwise from the project tasks
+            type: boolean
+            default: false
+        }
+    }
+    "2.28": ${get_unique_metric_variants."2.25"} {
+        request.properties.ids {
+            description: IDs of the tasks or models to get metrics from
+            type: array
+            items {type: string}
+        }
+    }
 }
 get_hyperparam_values {
     "2.13" {
@@ -903,6 +1003,26 @@ get_hyperparam_values {
             }
         }
     }
+    "2.26": ${get_hyperparam_values."2.13"} {
+        request.properties {
+            page {
+                description: "Page number"
+                default: 0
+                type: integer
+            }
+            page_size {
+                description: "Page size"
+                default: 500
+                type: integer
+            }
+        }
+    }
+    "2.27": ${get_hyperparam_values."2.26"} {
+        request.properties.pattern {
+            type: string
+            description: The search pattern regex
+        }
+    }
 }
 get_hyper_parameters {
     "2.9" {
@@ -1000,6 +1120,20 @@ get_model_metadata_values {
             }
         }
     }
+    "2.26": ${get_model_metadata_values."2.17"} {
+        request.properties {
+            page {
+                description: "Page number"
+                default: 0
+                type: integer
+            }
+            page_size {
+                description: "Page size"
+                default: 500
+                type: integer
+            }
+        }
+    }
 }
 get_model_metadata_keys {
     "2.17" {
@@ -1159,13 +1293,15 @@ get_task_parents {
                             }
                             project {
                                 type: object
-                                id {
-                                    description: "The ID of the parent task project"
-                                    type: string
-                                }
-                                name {
-                                    description: "The name of the parent task project"
-                                    type: string
+                                properties {
+                                    id {
+                                        description: "The ID of the parent task project"
+                                        type: string
+                                    }
+                                    name {
+                                        description: "The name of the parent task project"
+                                        type: string
+                                    }
                                 }
                             }
                         }
@@ -1185,4 +1321,58 @@ get_task_parents {
             }
         }
     }
+    "2.25": ${get_task_parents."2.13"} {
+        request.properties.task_name {
+            description: Task name pattern for the returned parent tasks
+            type: string
+        }
+    }
 }
+get_user_names {
+    "2.26" {
+        description: "Get names and ids of the users who created child entitites under the passed projects"
+        request {
+            type: object
+            properties {
+                projects {
+                    description: "The list of projects. If not passed or empty then all the projects are searched"
+                    type: array
+                    items { type: string }
+                }
+                include_subprojects {
+                    description: "If set to 'true' and the projects field is not empty then the result includes user name from the subprojects children"
+                    type: boolean
+                    default: true
+                }
+                entity {
+                    description: The type of the child entity to look for
+                    type: string
+                    enum: [task, model]
+                    default: task
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                users {
+                    description: "The list of users sorted by their names"
+                    type: array
+                    items {
+                        type: object
+                        properties {
+                            id {
+                                description: "The ID of the user"
+                                type: string
+                            }
+                            name {
+                                description: "The name of the user"
+                                type: string
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

apiserver/schema/services/queues.conf

@@ -159,6 +159,14 @@ get_all_ex {
             default: false
         }
     }
+    "2.27": ${get_all_ex."2.21"} {
+        request.properties {
+            filters {
+                type: object
+                additionalProperties: ${_definitions.field_filter}
+            }
+        }
+    }
 }
 get_all {
     "2.4" {

apiserver/schema/services/reports.conf

@@ -0,0 +1,747 @@
+_description: "Provides a management API for reports in the system."
+_definitions {
+    include "_tasks_common.conf"
+    include "_events_common.conf"
+    update_response {
+        type: object
+        properties {
+            updated {
+                description: "Number of reports updated (0 or 1)"
+                type: integer
+                enum: [ 0, 1 ]
+            }
+            fields {
+                description: "Updated fields names and values"
+                type: object
+                additionalProperties: true
+            }
+        }
+    }
+    report_status_enum {
+        type: string
+        enum: [
+            created
+            published
+        ]
+    }
+    report {
+        type: object
+        properties {
+            id {
+                description: "Report id"
+                type: string
+            }
+            name {
+                description: "Report Name"
+                type: string
+            }
+            user {
+                description: "Associated user id"
+                type: string
+            }
+            company {
+                description: "Company ID"
+                type: string
+            }
+            status {
+                description: ""
+                "$ref": "#/definitions/report_status_enum"
+            }
+            comment {
+                description: "Free text comment"
+                type: string
+            }
+            report {
+                description: "Report template"
+                type: string
+            }
+            report_assets {
+                description: "List of the external report assets"
+                type: array
+                items { type: string }
+            }
+            created {
+                description: "Report creation time (UTC) "
+                type: string
+                format: "date-time"
+            }
+            project {
+                description: "Project ID of the project to which this report is assigned"
+                type: string
+            }
+            tags {
+                description: "User-defined tags list"
+                type: array
+                items { type: string }
+            }
+            system_tags {
+                description: "System tags list. This field is reserved for system use, please don't use it."
+                type: array
+                items { type: string }
+            }
+            status_changed {
+                description: "Last status change time"
+                type: string
+                format: "date-time"
+            }
+            status_message {
+                description: "free text string representing info about the status"
+                type: string
+            }
+            status_reason {
+                description: "Reason for last status change"
+                type: string
+            }
+            published {
+                description: "Report publish time"
+                type: string
+                format: "date-time"
+            }
+            last_update {
+                description: "Last time this report was created, edited, changed"
+                type: string
+                format: "date-time"
+            }
+        }
+    }
+}
+create {
+    "2.23" {
+        description: "Create a new report"
+        request {
+            type: object
+            required: [
+                name
+            ]
+            properties {
+                name {
+                    description: "Report name. Unique within the company."
+                    type: string
+                }
+                tags {
+                    description: "User-defined tags list"
+                    type: array
+                    items { type: string }
+                }
+                comment {
+                    description: "Free text comment "
+                    type: string
+                }
+                report {
+                    description: "Report template"
+                    type: string
+                }
+                project {
+                    description: "Project ID of the project to which this report is assigned Must exist[ab]"
+                    type: string
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                id {
+                    description: "ID of the report"
+                    type: string
+                }
+                project_id {
+                    description: "ID of the project that the report belongs to"
+                    type: string
+                }
+            }
+        }
+    }
+    "2.24": ${create."2.23"} {
+        request.properties.report_assets {
+            description: "List of the external report assets"
+            type: array
+            items { type: string }
+        }
+    }
+}
+update {
+    "2.23" {
+        description: "Create a new report"
+        request {
+            type: object
+            required: [
+                task
+            ]
+            properties {
+                task {
+                    description: "The ID of the report task to update"
+                    type: string
+                }
+                name {
+                    description: "Report name. Unique within the company."
+                    type: string
+                }
+                tags {
+                    description: "User-defined tags list"
+                    type: array
+                    items { type: string }
+                }
+                comment {
+                    description: "Free text comment "
+                    type: string
+                }
+                report {
+                    description: "Report template"
+                    type: string
+                }
+            }
+        }
+        response: ${_definitions.update_response}
+    }
+    "2.24": ${update."2.23"} {
+        request.properties.report_assets {
+            description: "List of the external report assets"
+            type: array
+            items { type: string }
+        }
+    }
+}
+move {
+    "2.23" {
+        description: "Move reports to a project"
+        request {
+            type: object
+            required: [task]
+            properties {
+                task {
+                    description: "ID of the report to move"
+                    type: string
+                }
+                project {
+                    description: "Target project ID. If not provided, `project_name` must be provided. Use null for the root project"
+                    type: string
+                }
+                project_name {
+                    description: "Target project name. If provided and a project with this name does not exist, a new project will be created. If not provided, `project` must be provided."
+                    type: string
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                project_id: {
+                    description: The ID of the target project
+                    type: string
+                }
+            }
+        }
+    }
+}
+publish {
+    "2.23" {
+        description: "Publish report"
+        request {
+            type: object
+            required: [
+                task
+            ]
+            properties {
+                task {
+                    description: "The ID of the report task to publish"
+                    type: string
+                }
+                comment {
+                    description: "The client message"
+                    type: string
+                }
+            }
+        }
+        response: ${_definitions.update_response}
+    }
+}
+archive {
+    "2.23" {
+        description: "Archive report"
+        request {
+            type: object
+            required: [
+                task
+            ]
+            properties {
+                task {
+                    description: "The ID of the report task to archive"
+                    type: string
+                }
+                comment {
+                    description: "The client message"
+                    type: string
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                archived {
+                    description: "Number of reports archived (0 or 1)"
+                    type: integer
+                    enum: [0, 1]
+                }
+            }
+        }
+    }
+}
+unarchive {
+    "2.23" {
+        description: "Unarchive report"
+        request {
+            type: object
+            required: [
+                task
+            ]
+            properties {
+                task {
+                    description: "The ID of the report task to unarchive"
+                    type: string
+                }
+                comment {
+                    description: "The client message"
+                    type: string
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                unarchived {
+                    description: "Number of reports unarchived (0 or 1)"
+                    type: integer
+                    enum: [0, 1]
+                }
+            }
+        }
+    }
+}
+//share {
+//    "999.0" {
+//        description: "Share or unshare report"
+//        request {
+//            type: object
+//            required: [
+//                task
+//            ]
+//            properties {
+//                task {
+//                    description: "The ID of the report task to share/unshare"
+//                    type: string
+//                }
+//                share {
+//                    description: "If set to 'true' then the report will be shared. Otherwise unshared."
+//                    type: boolean
+//                    default: true
+//                }
+//            }
+//        }
+//        response {
+//            type: object
+//            properties {
+//                changed {
+//                    description: "Number of changed reports (0 or 1)"
+//                    type: integer
+//                    enum: [0, 1]
+//                }
+//            }
+//        }
+//    }
+//}
+delete {
+    "2.23" {
+        description: "Delete report"
+        request {
+            type: object
+            required: [
+                task
+            ]
+            properties {
+                task {
+                    description: "The ID of the report task to delete"
+                    type: string
+                }
+                force {
+                    description: "If not set then published or unarchived reports cannot be deleted"
+                    type: boolean
+                    default: false
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                deleted {
+                    description: "Number of deleted reports (0 or 1)"
+                    type: integer
+                    enum: [0, 1]
+                }
+            }
+        }
+    }
+}
+get_task_data {
+    "2.23" {
+        description: "Get the tasks data according the passed search criteria + requested events"
+        request {
+            type: object
+            properties {
+                id {
+                    description: "List of IDs to filter by"
+                    type: array
+                    items { type: string }
+                }
+                name {
+                    description: "Get only tasks whose name matches this pattern (python regular expression syntax)"
+                    type: string
+                }
+                user {
+                    description: "List of user IDs used to filter results by the task's creating user"
+                    type: array
+                    items { type: string }
+                }
+                size {
+                    type: integer
+                    minimum: 1
+                    description: "The number of tasks to retrieve"
+                }
+                order_by {
+                    description: "List of field names to order by. When search_text is used, '@text_score' can be used as a field representing the text score of returned documents. Use '-' prefix to specify descending order. Optional, recommended when using page"
+                    type: array
+                    items { type: string }
+                }
+                type {
+                    description: "List of task types. One or more of: 'import', 'annotation', 'training' or 'testing' (case insensitive)"
+                    type: array
+                    items { type: string }
+                }
+                tags {
+                    description: "List of task user-defined tags. Use '-' prefix to exclude tags"
+                    type: array
+                    items { type: string }
+                }
+                system_tags {
+                    description: "List of task system tags. Use '-' prefix to exclude system tags"
+                    type: array
+                    items { type: string }
+                }
+                status {
+                    description: "List of task status."
+                    type: array
+                    items { "$ref": "#/definitions/task_status_enum" }
+                }
+                project {
+                    description: "List of project IDs"
+                    type: array
+                    items { type: string }
+                }
+                only_fields {
+                    description: "List of task field names (nesting is supported using '.', e.g. execution.model_labels). If provided, this list defines the query's projection (only these fields will be returned for each result entry)"
+                    type: array
+                    items { type: string }
+                }
+                parent {
+                    description: "Parent ID"
+                    type: string
+                }
+                status_changed {
+                    description: "List of status changed constraint strings (utcformat, epoch) with an optional prefix modifier (>, >=, <, <=)"
+                    type: array
+                    items {
+                        type: string
+                        pattern: "^(>=|>|<=|<)?.*$"
+                    }
+                }
+                search_text {
+                    description: "Free text search query"
+                    type: string
+                }
+                allow_public {
+                    description: "Allow public tasks to be returned in the results"
+                    type: boolean
+                    default: true
+                }
+                _all_ {
+                    description: "Multi-field pattern condition (all fields match pattern)"
+                    "$ref": "#/definitions/multi_field_pattern_data"
+                }
+                _any_ {
+                    description: "Multi-field pattern condition (any field matches pattern)"
+                    "$ref": "#/definitions/multi_field_pattern_data"
+                }
+                "input.view.entries.dataset" {
+                    description: "List of input dataset IDs"
+                    type: array
+                    items { type: string }
+                }
+                "input.view.entries.version" {
+                    description: "List of input dataset version IDs"
+                    type: array
+                    items { type: string }
+                }
+                search_hidden {
+                    description: "If set to 'true' then hidden tasks are included in the search results"
+                    type: boolean
+                    default: false
+                }
+                include_subprojects {
+                    description: "If set to 'true' and project field is set then tasks from the subprojects are searched too"
+                    type: boolean
+                    default: false
+                }
+                plots {
+                    type: object
+                    properties {
+                        iters {
+                            type: integer
+                            description: "Max number of latest iterations for which to return plots"
+                        }
+                        metrics {
+                            type: array
+                            description: List of metrics and variants
+                            items { "$ref": "#/definitions/metric_variants" }
+                        }
+                    }
+                }
+                debug_images {
+                    type: object
+                    properties {
+                        iters {
+                            type: integer
+                            description: "Max number of latest iterations for which to return debug images"
+                        }
+                        metrics {
+                            type: array
+                            description: List of metrics and variants
+                            items { "$ref": "#/definitions/metric_variants" }
+                        }
+                    }
+                }
+                scalar_metrics_iter_histogram {
+                    type: object
+                    properties {
+                        samples {
+                            description: "The amount of histogram points to return (0 to return all the points). Optional, the default value is 6000."
+                            type: integer
+                        }
+                        key {
+                            description: """
+                            Histogram x axis to use:
+                            iter - iteration number
+                            iso_time - event time as ISO formatted string
+                            timestamp - event timestamp as milliseconds since epoch
+                            """
+                            "$ref": "#/definitions/scalar_key_enum"
+                        }
+                        metrics {
+                            type: array
+                            description: List of metrics and variants
+                            items { "$ref": "#/definitions/metric_variants" }
+                        }
+                    }
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                tasks {
+                    description: "List of tasks"
+                    type: array
+                    items { "$ref": "#/definitions/task" }
+                }
+                plots {
+                    type: object
+                    description: "Plots mapped by metric, variant, task and iteration"
+                    additionalProperties: true
+                }
+                debug_images {
+                    type: array
+                    description: "Debug image events grouped by tasks and iterations"
+                    items {"$ref": "#/definitions/debug_images_response_task_metrics"}
+                }
+                scalar_metrics_iter_histogram {
+                    type: object
+                    additionalProperties: true
+                }
+            }
+        }
+    }
+    "2.25": ${get_task_data."2.23"} {
+        request.properties {
+            model_events {
+                type: boolean
+                description: If set then the retrieving model events. Otherwise task events
+                default: false
+            }
+            single_value_metrics {
+                type: object
+                description: If passed then task single value metrics are returned
+                additionalProperties: false
+            }
+        }
+        response.properties.single_value_metrics {
+            type: array
+            description: Single value metrics grouped by task
+            items {"$ref": "#/definitions/single_value_task_metrics"}
+        }
+    }
+    "2.26": ${get_task_data."2.25"} {
+        request.properties.plots.properties.last_iters_per_task_metric {
+            type: boolean
+            description: If set to 'true' and iters passed then last iterations for each task metrics are retrieved. Otherwise last iterations for the whole task are retrieved
+            default: true
+        }
+    }
+}
+get_all_ex {
+    "2.23" {
+        description: "Get all the company's and public report tasks"
+        request {
+            type: object
+            properties {
+                id {
+                    description: "List of IDs to filter by"
+                    type: array
+                    items { type: string }
+                }
+                name {
+                    description: "Get only reports whose name matches this pattern (python regular expression syntax)"
+                    type: string
+                }
+                user {
+                    description: "List of user IDs used to filter results by the reports's creating user"
+                    type: array
+                    items { type: string }
+                }
+                page {
+                    description: "Page number, returns a specific page out of the resulting list of reports"
+                    type: integer
+                    minimum: 0
+                }
+                page_size {
+                    description: "Page size, specifies the number of results returned in each page (last page may contain fewer results)"
+                    type: integer
+                    minimum: 1
+                }
+                order_by {
+                    description: "List of field names to order by. When search_text is used, '@text_score' can be used as a field representing the text score of returned documents. Use '-' prefix to specify descending order. Optional, recommended when using page"
+                    type: array
+                    items { type: string }
+                }
+                tags {
+                    description: "List of report user-defined tags. Use '-' prefix to exclude tags"
+                    type: array
+                    items { type: string }
+                }
+                system_tags {
+                    description: "List of report system tags. Use '-' prefix to exclude system tags"
+                    type: array
+                    items { type: string }
+                }
+                status {
+                    description: "List of report status."
+                    type: array
+                    items { "$ref": "#/definitions/report_status_enum" }
+                }
+                project {
+                    description: "List of project IDs"
+                    type: array
+                    items { type: string }
+                }
+                only_fields {
+                    description: "List of report field names (nesting is supported using '.'). If provided, this list defines the query's projection (only these fields will be returned for each result entry)"
+                    type: array
+                    items { type: string }
+                }
+                status_changed {
+                    description: "List of status changed constraint strings (utcformat, epoch) with an optional prefix modifier (>, >=, <, <=)"
+                    type: array
+                    items {
+                        type: string
+                        pattern: "^(>=|>|<=|<)?.*$"
+                    }
+                }
+                search_text {
+                    description: "Free text search query"
+                    type: string
+                }
+                scroll_id {
+                    type: string
+                    description: "Scroll ID returned from the previos calls to get_all"
+                }
+                refresh_scroll {
+                    type: boolean
+                    description: "If set then all the data received with this scroll will be requeried"
+                }
+                size {
+                    type: integer
+                    minimum: 1
+                    description: "The number of tasks to retrieve"
+                }
+                allow_public {
+                    description: "Allow public reports to be returned in the results"
+                    type: boolean
+                    default: true
+                }
+                _all_ {
+                    description: "Multi-field pattern condition (all fields match pattern)"
+                    "$ref": "#/definitions/multi_field_pattern_data"
+                }
+                _any_ {
+                    description: "Multi-field pattern condition (any field matches pattern)"
+                    "$ref": "#/definitions/multi_field_pattern_data"
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                tasks {
+                    description: "List of report tasks"
+                    type: array
+                    items { "$ref": "#/definitions/report" }
+                }
+                scroll_id {
+                    type: string
+                    description: "Scroll ID that can be used with the next calls to get_all to retrieve more data"
+                }
+            }
+        }
+    }
+    "2.26": ${get_all_ex."2.23"} {
+        request.properties.include_subprojects {
+            description: "If set to 'true' and project field is set then reports from the subprojects are searched too"
+            type: boolean
+            default: false
+        }
+    }
+    "2.27": ${get_all_ex."2.26"} {
+        request.properties {
+            filters {
+                type: object
+                additionalProperties: ${_definitions.field_filter}
+            }
+        }
+    }
+}
+get_tags {
+    "2.23" {
+        description: "Get all the user tags used for the company reports"
+        request {
+            type: object
+            additionalProperties: false
+        }
+        response {
+            type: object
+            properties {
+                tags {
+                    description: "The list of unique tag values"
+                    type: array
+                    items {type: string}
+                }
+            }
+        }
+    }
+}

apiserver/schema/services/tasks.conf

@@ -25,7 +25,7 @@ _references {
     }
 }
 _definitions {
-    include "_common.conf"
+    include "_tasks_common.conf"
     change_many_request: ${_definitions.batch_operation} {
         request {
             properties {
@@ -69,374 +69,6 @@ _definitions {
             }
         }
     }
-    multi_field_pattern_data {
-        type: object
-        properties {
-            pattern {
-                description: "Pattern string (regex)"
-                type: string
-            }
-            fields {
-                description: "List of field names"
-                type: array
-                items { type: string }
-            }
-        }
-    }
-    model_type_enum {
-        type: string
-        enum: ["input", "output"]
-    }
-    task_model_item {
-        type: object
-        required: [ name, model]
-        properties {
-            name {
-                description: "The task model name"
-                type: string
-            }
-            model {
-                description: "The model ID"
-                type: string
-            }
-        }
-    }
-    script {
-        type: object
-        properties {
-            binary {
-                description: "Binary to use when running the script"
-                type: string
-                default: python
-            }
-            repository {
-                description: "Name of the repository where the script is located"
-                type: string
-            }
-            tag {
-                description: "Repository tag"
-                type: string
-            }
-            branch  {
-                description: "Repository branch id If not provided and tag not provided, default repository branch is used."
-                type: string
-            }
-            version_num {
-                description: "Version (changeset) number. Optional (default is head version) Unused if tag is provided."
-                type: string
-            }
-            entry_point {
-                description: "Path to execute within the repository"
-                type: string
-            }
-            working_dir {
-                description: "Path to the folder from which to run the script Default - root folder of repository"
-                type: string
-            }
-            requirements {
-                description: "A JSON object containing requirements strings by key"
-                type: object
-            }
-            diff {
-                description: "Uncommitted changes found in the repository when task was run"
-                type: string
-            }
-        }
-    }
-    output {
-        type: object
-        properties {
-            destination {
-                description: "Storage id. This is where output files will be stored."
-                type: string
-            }
-            model {
-                description: "Model id."
-                type: string
-            }
-            result {
-                description: "Task result. Values: 'success', 'failure'"
-                type: string
-            }
-            error {
-                description: "Last error text"
-                type: string
-            }
-        }
-    }
-    task_execution_progress_enum {
-        type: string
-        enum: [
-            unknown
-            running
-            stopping
-            stopped
-        ]
-    }
-    output_rois_enum {
-        type: string
-        enum: [
-            all_in_frame
-            only_filtered
-            frame_per_roi
-        ]
-    }
-    artifact_type_data {
-        type: object
-        properties {
-            preview {
-                description: "Description or textual data"
-                type: string
-            }
-            content_type {
-                description: "System defined raw data content type"
-                type: string
-            }
-            data_hash {
-                description: "Hash of raw data, without any headers or descriptive parts"
-                type: string
-            }
-        }
-    }
-    artifact_mode_enum {
-        type: string
-        enum: [
-            input
-            output
-        ]
-        default: output
-    }
-    artifact {
-        type: object
-        required: [key, type]
-        properties {
-            key {
-                description: "Entry key"
-                type: string
-            }
-            type {
-                description: "System defined type"
-                type: string
-            }
-            mode {
-                description: "System defined input/output indication"
-                "$ref": "#/definitions/artifact_mode_enum"
-            }
-            uri {
-                description: "Raw data location"
-                type: string
-            }
-            content_size {
-                description: "Raw data length in bytes"
-                type: integer
-            }
-            hash {
-                description: "Hash of entire raw data"
-                type: string
-            }
-            timestamp {
-                description: "Epoch time when artifact was created"
-                type: integer
-            }
-            type_data {
-                description: "Additional fields defined by the system"
-                "$ref": "#/definitions/artifact_type_data"
-            }
-            display_data {
-                description: "User-defined list of key/value pairs, sorted"
-                type: array
-                items {
-                    type: array
-                    items {
-                        type: string  # can also be a number... TODO: upgrade the generator
-                    }
-                }
-            }
-        }
-    }
-    artifact_id {
-        type: object
-        required: [key]
-        properties {
-            key {
-                description: "Entry key"
-                type: string
-            }
-            mode {
-                description: "System defined input/output indication"
-                "$ref": "#/definitions/artifact_mode_enum"
-            }
-        }
-    }
-    task_models {
-        type: object
-        properties {
-            input {
-                description: "The list of task input models"
-                type: array
-                items {"$ref": "#/definitions/task_model_item"}
-
-            }
-            output {
-                description: "The list of task output models"
-                type: array
-                items {"$ref": "#/definitions/task_model_item"}
-            }
-        }
-    }
-    execution {
-        type: object
-        properties {
-            queue {
-                description: "Queue ID where task was queued."
-                type: string
-            }
-            parameters {
-                description: "Json object containing the Task parameters"
-                type: object
-                additionalProperties: true
-            }
-            model {
-                description: "Execution input model ID Not applicable for Register (Import) tasks"
-                type: string
-            }
-            model_desc {
-                description: "Json object representing the Model descriptors"
-                type: object
-                additionalProperties: true
-            }
-            model_labels {
-                description: """Json object representing the ids of the labels in the model.
-                The keys are the layers' names and the values are the IDs.
-                Not applicable for Register (Import) tasks.
-                Mandatory for Training tasks"""
-                type: object
-                additionalProperties: { type: integer }
-            }
-            framework {
-                description: """Framework related to the task. Case insensitive. Mandatory for Training tasks. """
-                type: string
-            }
-            docker_cmd {
-                description: "Command for running docker script for the execution of the task"
-                type: string
-            }
-            artifacts {
-                description: "Task artifacts"
-                type: array
-                items { "$ref": "#/definitions/artifact" }
-            }
-        }
-    }
-    task_status_enum {
-        type: string
-        enum: [
-            created
-            queued
-            in_progress
-            stopped
-            published
-            publishing
-            closed
-            failed
-            completed
-            unknown
-        ]
-    }
-    task_type_enum {
-        type: string
-        enum: [
-            training
-            testing
-            inference
-            data_processing
-            application
-            monitor
-            controller
-            optimizer
-            service
-            qc
-            custom
-        ]
-    }
-    last_metrics_event {
-        type: object
-        properties {
-            metric {
-                description: "Metric name"
-                type: string
-            }
-            variant {
-                description: "Variant name"
-                type: string
-            }
-            value {
-                description: "Last value reported"
-                type: number
-            }
-            min_value {
-                description: "Minimum value reported"
-                type: number
-            }
-            max_value {
-                description: "Maximum value reported"
-                type: number
-            }
-        }
-    }
-    last_metrics_variants {
-        type: object
-        description: "Last metric events, one for each variant hash"
-        additionalProperties {
-            "$ref": "#/definitions/last_metrics_event"
-        }
-    }
-    params_item {
-        type: object
-        properties {
-            section {
-                description: "Section that the parameter belongs to"
-                type: string
-            }
-            name {
-                description: "Name of the parameter. The combination of section and name should be unique"
-                type: string
-            }
-            value {
-                description: "Value of the parameter"
-                type: string
-            }
-            type {
-                description: "Type of the parameter. Optional"
-                type: string
-            }
-            description {
-                description: "The parameter description. Optional"
-                type: string
-            }
-        }
-    }
-    configuration_item {
-        type: object
-        properties {
-            name {
-                description: "Name of the parameter. Should be unique"
-                type: string
-            }
-            value {
-                description: "Value of the parameter"
-                type: string
-            }
-            type {
-                description: "Type of the parameter. Optional"
-                type: string
-            }
-            description {
-                description: "The parameter description. Optional"
-                type: string
-            }
-        }
-    }
     param_key {
         type: object
         properties {
@@ -450,13 +82,6 @@ _definitions {
             }
         }
     }
-    section_params {
-        description: "Task section params"
-        type: object
-        additionalProperties {
-            "$ref": "#/definitions/params_item"
-        }
-    }
     replace_hyperparams_enum {
         type: string
         enum: [
@@ -465,165 +90,6 @@ _definitions {
             all
         ]
     }
-    task {
-        type: object
-        properties {
-            id {
-                description: "Task id"
-                type: string
-            }
-            name {
-                description: "Task Name"
-                type: string
-            }
-            user {
-                description: "Associated user id"
-                type: string
-            }
-            company {
-                description: "Company ID"
-                type: string
-            }
-            type {
-                description: "Type of task. Values: 'training', 'testing'"
-                "$ref": "#/definitions/task_type_enum"
-            }
-            status {
-                description: ""
-                "$ref": "#/definitions/task_status_enum"
-            }
-            comment {
-                description: "Free text comment"
-                type: string
-            }
-            created {
-                description: "Task creation time (UTC) "
-                type: string
-                format: "date-time"
-            }
-            started {
-                description: "Task start time (UTC)"
-                type: string
-                format: "date-time"
-            }
-            completed {
-                description: "Task end time (UTC)"
-                type: string
-                format: "date-time"
-            }
-            active_duration {
-                description: "Task duration time (seconds)"
-                type: integer
-            }
-            parent {
-                description: "Parent task id"
-                type: string
-            }
-            project {
-                description: "Project ID of the project to which this task is assigned"
-                type: string
-            }
-            output {
-                description: "Task output params"
-                "$ref": "#/definitions/output"
-            }
-            execution {
-                description: "Task execution params"
-                "$ref": "#/definitions/execution"
-            }
-            container {
-                description: "Docker container parameters"
-                type: object
-                additionalProperties { type: [string, null] }
-            }
-            models {
-                description: "Task models"
-                "$ref": "#/definitions/task_models"
-            }
-            // TODO: will be removed
-            script {
-                description: "Script info"
-                "$ref": "#/definitions/script"
-            }
-            tags {
-                description: "User-defined tags list"
-                type: array
-                items { type: string }
-            }
-            system_tags {
-                description: "System tags list. This field is reserved for system use, please don't use it."
-                type: array
-                items { type: string }
-            }
-            status_changed {
-                description: "Last status change time"
-                type: string
-                format: "date-time"
-            }
-            status_message {
-                description: "free text string representing info about the status"
-                type: string
-            }
-            status_reason {
-                description: "Reason for last status change"
-                type: string
-            }
-            published {
-                description: "Last status change time"
-                type: string
-                format: "date-time"
-            }
-            last_worker {
-                description: "ID of last worker that handled the task"
-                type: string
-            }
-            last_worker_report {
-                description: "Last time a worker reported while working on this task"
-                type: string
-                format: "date-time"
-            }
-            last_update {
-                description: "Last time this task was created, updated, changed or events for this task were reported"
-                type: string
-                format: "date-time"
-            }
-            last_change {
-                description: "Last time any update was done to the task"
-                type: string
-                format: "date-time"
-            }
-            last_iteration {
-                description: "Last iteration reported for this task"
-                type: integer
-            }
-            last_metrics {
-                description: "Last metric variants (hash to events), one for each metric hash"
-                type: object
-                additionalProperties {
-                    "$ref": "#/definitions/last_metrics_variants"
-                }
-            }
-            hyperparams {
-                description: "Task hyper params per section"
-                type: object
-                additionalProperties {
-                    "$ref": "#/definitions/section_params"
-                }
-            }
-            configuration {
-                description: "Task configuration params"
-                type: object
-                additionalProperties {
-                    "$ref": "#/definitions/configuration_item"
-                }
-            }
-            runtime {
-                description: "Task runtime mapping"
-                type: object
-                additionalProperties: true
-            }
-        }
-    }
     task_urls {
         type: object
         properties {
@@ -715,6 +181,23 @@ get_all_ex {
             description: "Scroll ID that can be used with the next calls to get_all_ex to retrieve more data"
         }
     }
+    "2.23": ${get_all_ex."2.15"} {
+        request.properties {
+            allow_public {
+                description: "Allow public tasks to be returned in the results"
+                type: boolean
+                default: true
+            }
+        }
+    }
+    "2.27": ${get_all_ex."2.23"} {
+        request.properties {
+            filters {
+                type: object
+                additionalProperties: ${_definitions.field_filter}
+            }
+        }
+    }
 }
 get_all {
     "2.1" {
@@ -814,9 +297,6 @@ get_all {
                     "$ref": "#/definitions/multi_field_pattern_data"
                 }
             }
-            dependencies {
-                page: [ page_size ]
-            }
         }
         response {
             type: object
@@ -859,6 +339,17 @@ get_all {
             description: "Scroll ID that can be used with the next calls to get_all to retrieve more data"
         }
     }
+    "2.26": ${get_all."2.15"} {
+        request {
+            properties {
+                include_subprojects {
+                    description: "If set to 'true' and project field is set then tasks from the subprojects are searched too"
+                    type: boolean
+                    default: false
+                }
+            }
+        }
+    }
 }
 get_types {
     "2.8" {
@@ -995,7 +486,7 @@ clone {
                 new_task_container {
                     description: "The docker container properties for the new task. If not provided then taken from the original task"
                     type: object
-                    additionalProperties { type: [string, null] }
+                    additionalProperties { type: string }
                 }
             }
         }
@@ -1173,7 +664,7 @@ create {
                 container {
                     description: "Docker container parameters"
                     type: object
-                    additionalProperties { type: [string, null] }
+                    additionalProperties { type: string }
                 }
             }
         }
@@ -1227,6 +718,10 @@ validate {
                     description: "Task execution params"
                     "$ref": "#/definitions/execution"
                 }
+                script {
+                    description: "Script info"
+                    "$ref": "#/definitions/script"
+                }
                 hyperparams {
                     description: "Task hyper params per section"
                     type: object
@@ -1241,10 +736,6 @@ validate {
                         "$ref": "#/definitions/configuration_item"
                     }
                 }
-                script {
-                    description: "Script info"
-                    "$ref": "#/definitions/script"
-                }
             }
         }
         response {
@@ -1262,7 +753,7 @@ validate {
                 container {
                     description: "Docker container parameters"
                     type: object
-                    additionalProperties { type: [string, null] }
+                    additionalProperties { type: string }
                 }
             }
         }
@@ -1392,6 +883,10 @@ edit {
                     description: "Task execution params"
                     "$ref": "#/definitions/execution"
                 }
+                script {
+                    description: "Script info"
+                    "$ref": "#/definitions/script"
+                }
                 hyperparams {
                     description: "Task hyper params per section"
                     type: object
@@ -1406,10 +901,6 @@ edit {
                         "$ref": "#/definitions/configuration_item"
                     }
                 }
-                script {
-                    description: "Script info"
-                    "$ref": "#/definitions/script"
-                }
             }
         }
         response: ${_definitions.update_response}
@@ -1424,7 +915,7 @@ edit {
                 container {
                     description: "Docker container parameters"
                     type: object
-                    additionalProperties { type: [string, null] }
+                    additionalProperties { type: string }
                 }
                 runtime {
                     description: "Task runtime mapping"
@@ -1478,6 +969,10 @@ reset {
                     description: "If set to 'true' then return the urls of the files that were uploaded by this task. Default value is 'false'"
                     type: boolean
                 }
+                delete_output_models {
+                    description: "If set to 'true' then delete output models of this task that are not referenced by other tasks. Default value is 'true'"
+                    type: boolean
+                }
             }
         }
         response {
@@ -1665,6 +1160,10 @@ delete {
                     description: "If set to 'true' then return the urls of the files that were uploaded by this task. Default value is 'false'"
                     type: boolean
                 }
+                delete_output_models {
+                    description: "If set to 'true' then delete output models of this task that are not referenced by other tasks. Default value is 'true'"
+                    type: boolean
+                }
             }
         }
         response {
@@ -1736,12 +1235,12 @@ archive_many {
                     type: string
                 }
             }
-            response {
-                properties {
-                    succeeded.items.properties.archived {
-                        description: "Indicates whether the task was archived"
-                        type: boolean
-                    }
+        }
+        response {
+            properties {
+                succeeded.items.properties.archived {
+                    description: "Indicates whether the task was archived"
+                    type: boolean
                 }
             }
         }
@@ -2024,6 +1523,19 @@ dequeue {
             }
         }
     }
+    "2.25": ${dequeue."1.5"} {
+        request.properties.remove_from_all_queues {
+            type: boolean
+            description: If set to 'true' then the task is searched and removed from all the queues. Otherwise only from the queue stored in the task execution parameters
+            default: false
+        }
+    }
+    "2.26": ${dequeue."2.25"} {
+        request.properties.new_status {
+            type: string
+            description: The new status to assign to the task after the dequeue instead of the default one
+        }
+    }
 }
 dequeue_many {
     "2.13": ${_definitions.change_many_request} {
@@ -2042,6 +1554,19 @@ dequeue_many {
             }
         }
     }
+    "2.25": ${dequeue_many."2.13"} {
+        request.properties.remove_from_all_queues {
+            type: boolean
+            description: If set to 'true' then the tasks are searched and removed from all the queues. Otherwise only from the queue stored in the task execution parameters
+            default: false
+        }
+    }
+    "2.26": ${dequeue_many."2.25"} {
+        request.properties.new_status {
+            type: string
+            description: The new status to assign to the task after the dequeue instead of the default one
+        }
+    }
 }
 set_requirements {
     "2.1" {
@@ -2515,7 +2040,7 @@ move {
                     items { type: string }
                 }
                 project {
-                    description: "Target project ID. If not provided, `project_name` must be provided."
+                    description: "Target project ID. If not provided, `project_name` must be provided. Use null for the root project"
                     type: string
                 }
                 project_name {
@@ -2530,3 +2055,37 @@ move {
         }
     }
 }
+update_tags {
+    "2.27" {
+        description: Add or remove tags from multiple tasks
+        request {
+            type: object
+            properties {
+                ids {
+                    type: array
+                    description: IDs of the tasks to update
+                    items {type: string}
+                }
+                add_tags {
+                    type: array
+                    description: User tags to add
+                    items {type: string}
+                }
+                remove_tags {
+                    type: array
+                    description: User tags to remove
+                    items {type: string}
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                updated {
+                    type: integer
+                    description: The number of updated tasks
+                }
+            }
+        }
+    }
+}

apiserver/schema/services/users.conf

@@ -155,6 +155,17 @@ get_current_user {
             }
         }
     }
+    "2.26": ${get_current_user."2.20"} {
+        response.properties.settings {
+            type: object
+            properties {
+                max_download_items {
+                    type: string
+                    description: The maximum items downloaded for this user in csv file downloads
+                }
+            }
+        }
+    }
 }
 
 get_all_ex {

apiserver/schema/services/workers.conf

@@ -311,6 +311,41 @@ get_all {
         }
     }
 }
+get_count {
+    "2.26": {
+        description: "Returns the number of registered workers."
+        request {
+            type: object
+            properties {
+                last_seen {
+                    description: """Filter out workers not active for more than last_seen seconds.
+                        A value or 0 or 'none' will disable the filter."""
+                    type: integer
+                    default: 0
+                }
+                tags {
+                    description: The list of allowed worker tags. Prepend tag value with '-' in order to exclude
+                    type: array
+                    items { type: string }
+                }
+                system_tags {
+                    description: The list of allowed worker system tags. Prepend tag value with '-' in order to exclude
+                    type: array
+                    items { type: string }
+                }
+            }
+        }
+        response {
+            type: object
+            properties {
+                count {
+                    description: Workers count
+                    type: integer
+                }
+            }
+        }
+    }
+}
 register {
     "2.4" {
         description: "Register a worker in the system. Called by the Worker Daemon."

apiserver/server_init/app_sequence.py

@@ -46,7 +46,6 @@ class AppSequence:
         self._attach_request_handlers(request_handlers)
 
     def _attach_request_handlers(self, request_handlers: RequestHandlers):
-        self.app.before_first_request(request_handlers.before_app_first_request)
         self.app.before_request(request_handlers.before_request)
         self.app.after_request(request_handlers.after_request)
 

apiserver/server_init/request_handlers.py

@@ -1,3 +1,5 @@
+import unicodedata
+import urllib.parse
 from functools import partial
 
 from flask import request, Response, redirect
@@ -19,9 +21,11 @@ log = config.logger(__file__)
 class RequestHandlers:
     _request_strip_prefix = config.get("apiserver.request.strip_prefix", None)
     _server_header = config.get("apiserver.response.headers.server", "clearml")
-
-    def before_app_first_request(self):
-        pass
+    _custom_cookie_settings = {
+        c["name"]: c["settings"]
+        for c in config.get("apiserver.auth.custom_cookies", {}).values()
+        if c.get("enabled") and c.get("settings")
+    }
 
     def before_request(self):
         if request.method == "OPTIONS":
@@ -30,7 +34,10 @@ class RequestHandlers:
             return
 
         if request.content_encoding:
-            return f"Content encoding is not supported ({request.content_encoding})", 415
+            return (
+                f"Content encoding is not supported ({request.content_encoding})",
+                415,
+            )
 
         try:
             call = self._create_api_call(request)
@@ -43,10 +50,21 @@ class RequestHandlers:
                 response = redirect(call.result.redirect.url, call.result.redirect.code)
             else:
                 headers = None
+                disable_cache = False
                 if call.result.filename:
-                    headers = {
-                        "Content-Disposition": f"attachment; filename={call.result.filename}"
-                    }
+                    # make sure that downloaded files are not cached by the client
+                    disable_cache = True
+                    try:
+                        call.result.filename.encode("ascii")
+                    except UnicodeEncodeError:
+                        simple = unicodedata.normalize("NFKD", call.result.filename)
+                        simple = simple.encode("ascii", "ignore").decode("ascii")
+                        # safe = RFC 5987 attr-char
+                        quoted = urllib.parse.quote(call.result.filename, safe="")
+                        filenames = f"filename={simple}; filename*=UTF-8''{quoted}"
+                    else:
+                        filenames = f"filename={call.result.filename}"
+                    headers = {"Content-Disposition": "attachment; " + filenames}
 
                 response = Response(
                     content,
@@ -54,10 +72,16 @@ class RequestHandlers:
                     status=call.result.code,
                     headers=headers,
                 )
+                if disable_cache:
+                    response.cache_control.no_store = True
+                    response.cache_control.max_age = 0
 
             if call.result.cookies:
                 for key, value in call.result.cookies.items():
-                    kwargs = config.get("apiserver.auth.cookies").copy()
+                    kwargs = (
+                        self._custom_cookie_settings.get(key)
+                        or config.get("apiserver.auth.cookies")
+                    ).copy()
                     if value is None:
                         # Removing a cookie
                         kwargs["max_age"] = 0
@@ -74,7 +98,9 @@ class RequestHandlers:
                     if company:
                         try:
                             # use no default value to allow setting a null domain as well
-                            kwargs["domain"] = config.get(f"apiserver.auth.cookies_domain_override.{company}")
+                            kwargs["domain"] = config.get(
+                                f"apiserver.auth.cookies_domain_override.{company}"
+                            )
                         except KeyError:
                             pass
 
@@ -101,11 +127,15 @@ class RequestHandlers:
             return v
 
         for k, v in md.lists():
-            v = [convert_value(x) for x in v] if (len(v) > 1 or k.endswith("[]")) else convert_value(v[0])
+            v = (
+                [convert_value(x) for x in v]
+                if (len(v) > 1 or k.endswith("[]"))
+                else convert_value(v[0])
+            )
             nested_set(body, k.rstrip("[]").split("."), v)
 
     def _update_call_data(self, call, req):
-        """ Use request payload/form to fill call data or batched data """
+        """Use request payload/form to fill call data or batched data"""
         if req.content_type == "application/json-lines":
             items = []
             for i, line in enumerate(req.data.splitlines()):
@@ -135,6 +165,9 @@ class RequestHandlers:
         call.set_error_result(msg=msg, code=code, subcode=subcode)
         return call
 
+    def _get_session_auth_cookie(self, req):
+        return req.cookies.get(config.get("apiserver.auth.session_auth_cookie_name"))
+
     def _create_api_call(self, req):
         call = None
         try:
@@ -148,9 +181,7 @@ class RequestHandlers:
 
             # Resolve authorization: if cookies contain an authorization token, use it as a starting point.
             # in any case, request headers always take precedence.
-            auth_cookie = req.cookies.get(
-                config.get("apiserver.auth.session_auth_cookie_name")
-            )
+            auth_cookie = self._get_session_auth_cookie(req)
             headers = (
                 {}
                 if not auth_cookie

apiserver/service_repo/apicall.py

@@ -655,7 +655,11 @@ class APICall(DataContainer):
             }
             if self.content_type.lower() == JSON_CONTENT_TYPE:
                 try:
-                    func = json.dumps if self._json_flags.pop("ensure_ascii", True) else json.dumps_notascii
+                    func = (
+                        json.dumps
+                        if self._json_flags.pop("ensure_ascii", True)
+                        else json.dumps_notascii
+                    )
                     res = func(res, **(self._json_flags or {}))
                 except Exception as ex:
                     # JSON serialization may fail, probably problem with data or error_data so pop it and try again
@@ -685,8 +689,12 @@ class APICall(DataContainer):
             cookies=self._result.cookies,
         )
 
-    def get_redacted_headers(self):
-        headers = self.headers.copy()
+    def get_redacted_headers(self, fields=None):
+        headers = (
+            {k: v for k, v in self._headers.items() if k in fields}
+            if fields
+            else self.headers
+        )
         if not self.requires_authorization or self.auth:
             # We won't log the authorization header if call shouldn't be authorized, or if it was successfully
             #  authorized. This means we'll only log authorization header for calls that failed to authorize (hopefully

apiserver/service_repo/auth/__init__.py

@@ -1,4 +1,4 @@
-from .auth import get_auth_func, authorize_impersonation
+from .auth import get_auth_func, authorize_impersonation, revoke_auth_token
 from .payload import Token, Basic, AuthType, Payload
 from .identity import Identity
 from .utils import get_client_id, get_secret_key