# SPDX-License-Identifier: GPL-3.0-or-later
# Haketilo proxy data and configuration (update of dependency tree in the db).
#
# This file is part of Hydrilla&Haketilo.
#
# Copyright (C) 2022 Wojtek Kosior
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
#
# I, Wojtek Kosior, thereby promise not to sue for violation of this
# file's license. Although I request that you do not make use of this
# code in a proprietary program, I am not going to enforce this in
# court.
"""
....
"""
import sqlite3
import typing as t
from .... import item_infos
from ... import simple_dependency_satisfying as sds
from .. import base
from .pull_missing_files import pull_missing_files, FileResolver, \
DummyFileResolver
AnyInfoVar = t.TypeVar(
'AnyInfoVar',
item_infos.ResourceInfo,
item_infos.MappingInfo
)
def _get_infos_of_type(cursor: sqlite3.Cursor, info_type: t.Type[AnyInfoVar],) \
-> t.Mapping[int, AnyInfoVar]:
join_mapping_statuses = 'JOIN mapping_statuses AS ms USING (item_id)'
condition = "i.type = 'M' AND ms.enabled != 'D'"
if info_type is item_infos.ResourceInfo:
join_mapping_statuses = ''
condition = "i.type = 'R'"
cursor.execute(
f'''
SELECT
ive.item_version_id,
ive.definition,
ive.repo,
ive.repo_iteration
FROM
item_versions_extra AS ive
JOIN items AS i USING (item_id)
{join_mapping_statuses}
WHERE
{condition};
'''
)
result: dict[int, AnyInfoVar] = {}
for item_version_id, definition, repo_name, repo_iteration \
in cursor.fetchall():
info = info_type.load(definition, repo_name, repo_iteration)
if info.compatible:
result[item_version_id] = info
return result
def _get_current_required_state(
cursor: sqlite3.Cursor,
unlocked_required_mappings: t.Sequence[int]
) -> tuple[list[sds.MappingRequirement], list[sds.ResourceVersionRequirement]]:
# For mappings explicitly enabled by the user (+ all mappings they
# recursively depend on) let's make sure that their exact same versions will
# be enabled after the change. Make exception for mappings specified by the
# caller.
# The mappings to make exception for are passed by their item_id's. First,
# we compute a set of their corresponding item_version_id's.
with base.temporary_ids_tables(
cursor = cursor,
tables = [
('__work_ids_0', unlocked_required_mappings),
('__work_ids_1', []),
('__unlocked_ids', [])
]
):
cursor.execute(
'''
INSERT INTO
__work_ids_1
SELECT
item_version_id
FROM
item_versions
WHERE
item_id IN __work_ids_0;
'''
)
# Recursively update the our unlocked ids collection with all mapping
# version ids that are required by mapping versions already referenced
# there.
work_tab = '__work_ids_1'
next_tab = '__work_ids_0'
while True:
cursor.execute(f'SELECT COUNT(*) FROM {work_tab};')
(count,), = cursor.fetchall()
if count == 0:
break
cursor.execute(f'DELETE FROM {next_tab};')
cursor.execute(
f'''
INSERT INTO
{next_tab}
SELECT
item_version_id
FROM
item_versions AS iv
JOIN items AS i
USING (item_id)
JOIN mapping_statuses AS ms
USING (item_id)
JOIN resolved_required_mappings AS rrm
ON iv.item_version_id = rrm.required_mapping_id
WHERE
ms.enabled != 'E' AND
rrm.requiring_mapping_id IN {work_tab} AND
rrm.requiring_mapping_id NOT IN __unlocked_ids;
'''
)
cursor.execute(
f'''
INSERT OR IGNORE INTO
__unlocked_ids
SELECT
id
FROM
{work_tab};
'''
)
work_tab, next_tab = next_tab, work_tab
# Describe all required mappings using requirement objects.
cursor.execute(
'''
SELECT
ive.definition, ive.repo, ive.repo_iteration
FROM
item_versions_extra AS ive
JOIN items AS i USING (item_id)
WHERE
i.type = 'M' AND
ive.item_version_id NOT IN __unlocked_ids AND
ive.active = 'R';
''',
)
rows = cursor.fetchall()
mapping_requirements: list[sds.MappingRequirement] = []
for definition, repo, iteration in rows:
mapping_info = \
item_infos.MappingInfo.load(definition, repo, iteration)
mapping_req = sds.MappingVersionRequirement(
identifier = mapping_info.identifier,
version_info = mapping_info
)
mapping_requirements.append(mapping_req)
# Describe all required resources using requirement objects.
cursor.execute(
'''
SELECT
i_m.identifier,
ive_r.definition, ive_r.repo, ive_r.repo_iteration
FROM
resolved_depended_resources AS rdd
JOIN item_versions_extra AS ive_r
ON rdd.resource_item_id = ive_r.item_version_id
JOIN payloads AS p
USING (payload_id)
JOIN item_versions AS iv_m
ON p.mapping_item_id = iv_m.item_version_id
JOIN items AS i_m
ON iv_m.item_id = i_m.item_id
WHERE
iv_m.item_version_id NOT IN __unlocked_ids AND
iv_m.active = 'R';
''',
)
rows = cursor.fetchall()
resource_requirements: list[sds.ResourceVersionRequirement] = []
for mapping_identifier, definition, repo, iteration in rows:
resource_info = \
item_infos.ResourceInfo.load(definition, repo, iteration)
resource_req = sds.ResourceVersionRequirement(
mapping_identifier = mapping_identifier,
version_info = resource_info
)
resource_requirements.append(resource_req)
return (mapping_requirements, resource_requirements)
def _mark_version_installed(cursor: sqlite3.Cursor, version_id: int) -> None:
cursor.execute(
'''
UPDATE
item_versions
SET
installed = 'I'
WHERE
item_version_id = ?;
''',
(version_id,)
)
def _recompute_dependencies_no_state_update_no_pull_files(
cursor: sqlite3.Cursor,
unlocked_required_mappings: base.NoLockArg = [],
) -> None:
cursor.execute('DELETE FROM payloads;')
ids_to_resources = _get_infos_of_type(cursor, item_infos.ResourceInfo)
ids_to_mappings = _get_infos_of_type(cursor, item_infos.MappingInfo)
resources_to_ids = dict((info, id) for id, info in ids_to_resources.items())
mappings_to_ids = dict((info, id) for id, info in ids_to_mappings.items())
if unlocked_required_mappings != 'all_mappings_unlocked':
mapping_reqs, resource_reqs = _get_current_required_state(
cursor = cursor,
unlocked_required_mappings = unlocked_required_mappings
)
else:
mapping_reqs, resource_reqs = [], []
cursor.execute(
'''
SELECT
i.identifier
FROM
mapping_statuses AS ms
JOIN items AS i USING(item_id)
WHERE
ms.enabled = 'E' AND ms.frozen = 'N';
'''
)
for mapping_identifier, in cursor.fetchall():
mapping_reqs.append(sds.MappingRequirement(mapping_identifier))
cursor.execute(
'''
SELECT
active_version_id, frozen
FROM
mapping_statuses
WHERE
enabled = 'E' AND frozen IN ('R', 'E');
'''
)
for active_version_id, frozen in cursor.fetchall():
info = ids_to_mappings[active_version_id]
requirement: sds.MappingRequirement
if frozen == 'R':
requirement = sds.MappingRepoRequirement(info.identifier, info.repo)
else:
requirement = sds.MappingVersionRequirement(info.identifier, info)
mapping_reqs.append(requirement)
mapping_choices = sds.compute_payloads(
resources = ids_to_resources.values(),
mappings = ids_to_mappings.values(),
mapping_requirements = mapping_reqs,
resource_requirements = resource_reqs
)
cursor.execute(
'''
UPDATE
mapping_statuses
SET
active_version_id = NULL
WHERE
enabled != 'E';
'''
)
cursor.execute("UPDATE item_versions SET active = 'N';")
cursor.execute('DELETE FROM payloads;')
cursor.execute('DELETE FROM resolved_required_mappings;')
for choice in mapping_choices.values():
mapping_ver_id = mappings_to_ids[choice.info]
if choice.required:
_mark_version_installed(cursor, mapping_ver_id)
cursor.execute(
'''
SELECT
item_id
FROM
item_versions
WHERE
item_version_id = ?;
''',
(mapping_ver_id,)
)
(mapping_item_id,), = cursor.fetchall()
cursor.execute(
'''
UPDATE
mapping_statuses
SET
active_version_id = ?
WHERE
item_id = ?;
''',
(mapping_ver_id, mapping_item_id)
)
cursor.execute(
'''
UPDATE
item_versions
SET
active = ?
WHERE
item_version_id = ?;
''',
('R' if choice.required else 'A', mapping_ver_id)
)
for depended_mapping_info in choice.mapping_dependencies:
cursor.execute(
'''
INSERT INTO resolved_required_mappings(
requiring_mapping_id,
required_mapping_id
)
VALUES (?, ?);
''',
(mapping_ver_id, mappings_to_ids[depended_mapping_info])
)
for num, (pattern, payload) in enumerate(choice.payloads.items()):
cursor.execute(
'''
INSERT INTO payloads(
mapping_item_id,
pattern,
eval_allowed,
cors_bypass_allowed
)
VALUES (?, ?, ?, ?);
''',
(
mapping_ver_id,
pattern,
payload.allows_eval,
payload.allows_cors_bypass
)
)
cursor.execute(
'''
SELECT
payload_id
FROM
payloads
WHERE
mapping_item_id = ? AND pattern = ?;
''',
(mapping_ver_id, pattern)
)
(payload_id,), = cursor.fetchall()
for res_num, resource_info in enumerate(payload.resources):
resource_ver_id = resources_to_ids[resource_info]
if choice.required:
_mark_version_installed(cursor, resource_ver_id)
cursor.execute(
'''
INSERT INTO resolved_depended_resources(
payload_id,
resource_item_id,
idx
)
VALUES(?, ?, ?);
''',
(payload_id, resource_ver_id, res_num)
)
new_status = 'R' if choice.required else 'A'
cursor.execute(
'''
UPDATE
item_versions
SET
active = (
CASE
WHEN active = 'R' OR ? = 'R' THEN 'R'
WHEN active = 'A' OR ? = 'A' THEN 'A'
ELSE 'N'
END
)
WHERE
item_version_id = ?;
''',
(new_status, new_status, resource_ver_id)
)
def _recompute_dependencies_no_state_update(
cursor: sqlite3.Cursor,
unlocked_required_mappings: base.NoLockArg = [],
semirepo_file_resolver: FileResolver = DummyFileResolver()
) -> None:
_recompute_dependencies_no_state_update_no_pull_files(
cursor = cursor,
unlocked_required_mappings = unlocked_required_mappings
)
pull_missing_files(cursor, semirepo_file_resolver)
