mirror of
https://gitlab.com/dslackw/slpkg.git
synced 2024-12-31 10:26:39 +01:00
1653 lines
64 KiB
Python
1653 lines
64 KiB
Python
#!/usr/bin/python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import re
|
|
from pathlib import Path
|
|
|
|
from slpkg.configs import Configs
|
|
from slpkg.utilities import Utilities
|
|
from slpkg.repositories import Repositories
|
|
from slpkg.models.models import session as Session
|
|
from slpkg.models.models import (SBoTable, PonceTable,
|
|
BinariesTable, LastRepoUpdated)
|
|
|
|
|
|
class InstallData(Configs):
|
|
|
|
def __init__(self):
|
|
super(Configs, self).__init__()
|
|
self.session = Session
|
|
self.utils = Utilities()
|
|
self.repos = Repositories()
|
|
|
|
def last_updated(self, repo_file: Path) -> str:
|
|
""" Reads the first date of the changelog file."""
|
|
lines: list = self.utils.read_file(repo_file)
|
|
days = ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun')
|
|
for line in lines:
|
|
if line.startswith(days):
|
|
return line.replace('\n', '')
|
|
|
|
def install_sbo_data(self) -> None:
|
|
""" Install the data for SBo repository. """
|
|
sbo_tags = [
|
|
'SLACKBUILD NAME:',
|
|
'SLACKBUILD LOCATION:',
|
|
'SLACKBUILD FILES:',
|
|
'SLACKBUILD VERSION:',
|
|
'SLACKBUILD DOWNLOAD:',
|
|
'SLACKBUILD DOWNLOAD_x86_64:',
|
|
'SLACKBUILD MD5SUM:',
|
|
'SLACKBUILD MD5SUM_x86_64:',
|
|
'SLACKBUILD REQUIRES:',
|
|
'SLACKBUILD SHORT DESCRIPTION:'
|
|
]
|
|
|
|
path_slackbuilds: Path = Path(self.repos.sbo_repo_path, self.repos.sbo_repo_slackbuilds)
|
|
path_changelog: Path = Path(self.repos.sbo_repo_path, self.repos.sbo_repo_changelog)
|
|
|
|
slackbuilds_txt: list = self.utils.read_file(path_slackbuilds)
|
|
|
|
cache: list = [] # init cache
|
|
|
|
print(f"Updating the database for '{self.cyan}{self.repos.sbo_repo_name}{self.endc}'... ", end='', flush=True)
|
|
|
|
for i, line in enumerate(slackbuilds_txt, 1):
|
|
|
|
for tag in sbo_tags:
|
|
if line.startswith(tag):
|
|
line = line.replace(tag, '').strip()
|
|
cache.append(line)
|
|
|
|
if (i % 11) == 0:
|
|
data: str = SBoTable(name=cache[0], location=cache[1].split('/')[1],
|
|
files=cache[2], version=cache[3],
|
|
download=cache[4], download64=cache[5],
|
|
md5sum=cache[6], md5sum64=cache[7],
|
|
requires=cache[8], short_description=cache[9])
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache after 11 lines
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.sbo_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_ponce_data(self) -> None:
|
|
""" Install the data for SBo repository. """
|
|
sbo_tags = [
|
|
'SLACKBUILD NAME:',
|
|
'SLACKBUILD LOCATION:',
|
|
'SLACKBUILD FILES:',
|
|
'SLACKBUILD VERSION:',
|
|
'SLACKBUILD DOWNLOAD:',
|
|
'SLACKBUILD DOWNLOAD_x86_64:',
|
|
'SLACKBUILD MD5SUM:',
|
|
'SLACKBUILD MD5SUM_x86_64:',
|
|
'SLACKBUILD REQUIRES:',
|
|
'SLACKBUILD SHORT DESCRIPTION:'
|
|
]
|
|
|
|
path_slackbuilds = Path(self.repos.ponce_repo_path, self.repos.ponce_repo_slackbuilds)
|
|
path_changelog: Path = Path(self.repos.ponce_repo_path, self.repos.ponce_repo_changelog)
|
|
|
|
slackbuilds_txt: list = self.utils.read_file(path_slackbuilds)
|
|
|
|
cache: list = [] # init cache
|
|
|
|
print(f"Updating the database for '{self.cyan}{self.repos.ponce_repo_name}{self.endc}'... ", end='', flush=True)
|
|
|
|
for i, line in enumerate(slackbuilds_txt, 1):
|
|
|
|
for tag in sbo_tags:
|
|
if line.startswith(tag):
|
|
line = line.replace(tag, '').strip()
|
|
cache.append(line)
|
|
|
|
if (i % 11) == 0:
|
|
data: str = PonceTable(name=cache[0], location=cache[1].split('/')[1],
|
|
files=cache[2], version=cache[3],
|
|
download=cache[4], download64=cache[5],
|
|
md5sum=cache[6], md5sum64=cache[7],
|
|
requires=cache[8], short_description=cache[9])
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache after 11 lines
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.ponce_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_slack_data(self) -> None:
|
|
""" Install the data for slackware repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.slack_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE MIRROR:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.slack_repo_path, self.repos.slack_repo_packages)
|
|
path_checksums: Path = Path(self.repos.slack_repo_path, self.repos.slack_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.slack_repo_path, self.repos.slack_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.slack_repo_mirror[0]
|
|
if self.repos.slack_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.slack_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
package_location = line.replace(pkg_tag[2], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (.) dot
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.slack_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.slack_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_slack_extra_data(self) -> None:
|
|
""" Install the data for slackware extra repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.slack_extra_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE MIRROR:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.slack_extra_repo_path, self.repos.slack_extra_repo_packages)
|
|
path_checksums: Path = Path(self.repos.slack_extra_repo_path, self.repos.slack_extra_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.slack_extra_repo_path, self.repos.slack_extra_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.slack_extra_repo_mirror[0]
|
|
if self.repos.slack_extra_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.slack_extra_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
package_location = line.replace(pkg_tag[2], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (.) dot
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.slack_extra_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.slack_extra_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_slack_patches_data(self) -> None:
|
|
""" Install the data for slackware patches repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.slack_patches_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE MIRROR:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.slack_patches_repo_path, self.repos.slack_patches_repo_packages)
|
|
path_checksums: Path = Path(self.repos.slack_patches_repo_path, self.repos.slack_patches_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.slack_patches_repo_path, self.repos.slack_patches_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.slack_patches_repo_mirror[0]
|
|
if self.repos.slack_patches_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.slack_patches_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
package_location = line.replace(pkg_tag[2], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (.) dot
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.slack_patches_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.slack_patches_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_alien_data(self) -> None:
|
|
""" Install the data for alien repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.alien_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE REQUIRED:',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.alien_repo_path, self.repos.alien_repo_packages)
|
|
path_checksums: Path = Path(self.repos.alien_repo_path, self.repos.alien_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.alien_repo_path, self.repos.alien_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = ''.join(self.repos.alien_repo_mirror)
|
|
if self.repos.alien_repo_local[0].startswith('file'):
|
|
mirror: str = ''.join(self.repos.alien_repo_local)
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (.) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
required = line.replace(pkg_tag[4], '').strip()
|
|
package_required = required.replace(',', ' ').strip()
|
|
cache.append(package_required)
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 10:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.alien_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
required=cache[8],
|
|
description=cache[9],
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.alien_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_multilib_data(self) -> None:
|
|
""" Install the data for multilib repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.multilib_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.multilib_repo_path, self.repos.multilib_repo_packages)
|
|
path_checksums: Path = Path(self.repos.multilib_repo_path, self.repos.multilib_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.multilib_repo_path, self.repos.multilib_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = ''.join(self.repos.multilib_repo_mirror)
|
|
if self.repos.multilib_repo_local[0].startswith('file'):
|
|
mirror: str = ''.join(self.repos.multilib_repo_local)
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
package_description = line.replace(pkg_tag[4], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.multilib_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.multilib_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_restricted_data(self) -> None:
|
|
""" Install the data for multilib repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.restricted_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.restricted_repo_path, self.repos.restricted_repo_packages)
|
|
path_checksums: Path = Path(self.repos.restricted_repo_path, self.repos.restricted_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.restricted_repo_path, self.repos.restricted_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = ''.join(self.repos.restricted_repo_mirror)
|
|
if self.repos.restricted_repo_local[0].startswith('file'):
|
|
mirror: str = ''.join(self.repos.restricted_repo_local)
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
package_description = line.replace(pkg_tag[4], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.restricted_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.restricted_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_gnome_data(self) -> None:
|
|
""" Install the data for gnome repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.gnome_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE MIRROR:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.gnome_repo_path, self.repos.gnome_repo_packages)
|
|
path_checksums: Path = Path(self.repos.gnome_repo_path, self.repos.gnome_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.gnome_repo_path, self.repos.gnome_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.gnome_repo_mirror[0]
|
|
if self.repos.gnome_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.gnome_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
package_location = line.replace(pkg_tag[2], '').strip()
|
|
cache.append(package_location[1:]) # Do not install (.) dot
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.gnome_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.gnome_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_msb_data(self) -> None:
|
|
""" Install the data for msb repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.msb_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.msb_repo_path, self.repos.msb_repo_packages)
|
|
path_checksums: Path = Path(self.repos.msb_repo_path, self.repos.msb_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.msb_repo_path, self.repos.msb_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = ''.join(self.repos.msb_repo_mirror)
|
|
if self.repos.msb_repo_local[0].startswith('file'):
|
|
mirror: str = ''.join(self.repos.msb_repo_local)
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
package_description = line.replace(pkg_tag[4], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.msb_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.msb_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_csb_data(self) -> None:
|
|
""" Install the data for csb repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.csb_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.csb_repo_path, self.repos.csb_repo_packages)
|
|
path_checksums: Path = Path(self.repos.csb_repo_path, self.repos.csb_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.csb_repo_path, self.repos.csb_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = ''.join(self.repos.csb_repo_mirror)
|
|
if self.repos.csb_repo_local[0].startswith('file'):
|
|
mirror: str = ''.join(self.repos.csb_repo_local)
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
package_description = line.replace(pkg_tag[4], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.csb_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.csb_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_conraid_data(self) -> None:
|
|
""" Install the data for conraid repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.conraid_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE MIRROR:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.conraid_repo_path, self.repos.conraid_repo_packages)
|
|
path_checksums: Path = Path(self.repos.conraid_repo_path, self.repos.conraid_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.conraid_repo_path, self.repos.conraid_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.conraid_repo_mirror[0]
|
|
if self.repos.conraid_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.conraid_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = []
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name: str = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
package_location: str = line.replace(pkg_tag[2], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description: str = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 9:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.conraid_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
description=cache[8],
|
|
required='',
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.conraid_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_slackonly_data(self) -> None:
|
|
""" Install the data for slackonly repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.slackonly_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE REQUIRED:',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.slackonly_repo_path, self.repos.slackonly_repo_packages)
|
|
path_checksums: Path = Path(self.repos.slackonly_repo_path, self.repos.slackonly_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.slackonly_repo_path, self.repos.slackonly_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.slackonly_repo_mirror[0]
|
|
if self.repos.slackonly_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.slackonly_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
required = line.replace(pkg_tag[4], '').strip()
|
|
package_required = required.replace(',', ' ').strip()
|
|
cache.append(package_required)
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 10:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.slackonly_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
required=cache[8],
|
|
description=cache[9],
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.slackonly_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_salixos_data(self) -> None:
|
|
""" Install the data for salixos repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.salixos_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE REQUIRED:',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.salixos_repo_path, self.repos.salixos_repo_packages)
|
|
path_checksums: Path = Path(self.repos.salixos_repo_path, self.repos.salixos_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.salixos_repo_path, self.repos.salixos_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.salixos_repo_mirror[0]
|
|
if self.repos.salixos_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.salixos_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
deps: list = []
|
|
required = line.replace(pkg_tag[4], '').strip()
|
|
|
|
for req in required.split(','):
|
|
dep = req.split('|')
|
|
if len(dep) > 1:
|
|
deps.append(dep[1])
|
|
else:
|
|
deps.extend(dep)
|
|
|
|
cache.append(' '.join(deps))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 10:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.salixos_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
required=cache[8],
|
|
description=cache[9],
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.salixos_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_salixos_extra_data(self) -> None:
|
|
""" Install the data for salixos_extra repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.salixos_extra_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE REQUIRED:',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.salixos_extra_repo_path, self.repos.salixos_extra_repo_packages)
|
|
path_checksums: Path = Path(self.repos.salixos_extra_repo_path, self.repos.salixos_extra_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.salixos_extra_repo_path,
|
|
self.repos.salixos_extra_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.salixos_extra_repo_mirror[0]
|
|
if self.repos.salixos_extra_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.salixos_extra_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
deps: list = []
|
|
required = line.replace(pkg_tag[4], '').strip()
|
|
|
|
for req in required.split(','):
|
|
dep = req.split('|')
|
|
if len(dep) > 1:
|
|
deps.append(dep[1])
|
|
else:
|
|
deps.extend(dep)
|
|
|
|
cache.append(' '.join(deps))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 10:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.salixos_extra_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
required=cache[8],
|
|
description=cache[9],
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.salixos_extra_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_salixos_patches_data(self) -> None:
|
|
""" Install the data for salixos_patches repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.salixos_patches_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE REQUIRED:',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.salixos_patches_repo_path, self.repos.salixos_patches_repo_packages)
|
|
path_checksums: Path = Path(self.repos.salixos_patches_repo_path, self.repos.salixos_patches_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.salixos_patches_repo_path,
|
|
self.repos.salixos_patches_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.salixos_patches_repo_mirror[0]
|
|
if self.repos.salixos_patches_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.salixos_patches_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
deps: list = []
|
|
required = line.replace(pkg_tag[4], '').strip()
|
|
|
|
for req in required.split(','):
|
|
dep = req.split('|')
|
|
if len(dep) > 1:
|
|
deps.append(dep[1])
|
|
else:
|
|
deps.extend(dep)
|
|
|
|
cache.append(' '.join(deps))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 10:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.salixos_patches_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
required=cache[8],
|
|
description=cache[9],
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.salixos_patches_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_slackel_data(self) -> None:
|
|
""" Install the data for slackel repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.slackel_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE REQUIRED:',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.slackel_repo_path, self.repos.slackel_repo_packages)
|
|
path_checksums: Path = Path(self.repos.slackel_repo_path, self.repos.slackel_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.slackel_repo_path, self.repos.slackel_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.slackel_repo_mirror[0]
|
|
if self.repos.slackel_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.slackel_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
deps: list = []
|
|
required = line.replace(pkg_tag[4], '').strip()
|
|
|
|
for req in required.split(','):
|
|
dep = req.split('|')
|
|
if len(dep) > 1:
|
|
deps.append(dep[1])
|
|
else:
|
|
deps.extend(dep)
|
|
|
|
cache.append(' '.join(deps))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 10:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.slackel_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
required=cache[8],
|
|
description=cache[9],
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.slackel_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|
|
|
|
def install_slint_data(self) -> None:
|
|
""" Install the data for slint repository. """
|
|
print(f"Updating the database for '{self.cyan}{self.repos.slint_repo_name}{self.endc}'... ",
|
|
end='', flush=True)
|
|
|
|
checksums_dict: dict = {}
|
|
pkg_tag = [
|
|
'PACKAGE NAME:',
|
|
'PACKAGE LOCATION:',
|
|
'PACKAGE SIZE (compressed):',
|
|
'PACKAGE SIZE (uncompressed):',
|
|
'PACKAGE REQUIRED:',
|
|
'PACKAGE DESCRIPTION:'
|
|
]
|
|
path_packages: Path = Path(self.repos.slint_repo_path, self.repos.slint_repo_packages)
|
|
path_checksums: Path = Path(self.repos.slint_repo_path, self.repos.slint_repo_checksums)
|
|
path_changelog: Path = Path(self.repos.slint_repo_path, self.repos.slint_repo_changelog)
|
|
packages_txt: list = self.utils.read_file(path_packages)
|
|
checksums_md5: list = self.utils.read_file(path_checksums)
|
|
|
|
mirror: str = self.repos.slint_repo_mirror[0]
|
|
if self.repos.slint_repo_local[0].startswith('file'):
|
|
mirror: str = self.repos.slint_repo_local[0]
|
|
|
|
for line in checksums_md5:
|
|
line = line.strip()
|
|
|
|
if line.endswith(('.txz', '.tgz')):
|
|
file: str = line.split('./')[1].split('/')[-1].strip()
|
|
checksum: str = line.split('./')[0].strip()
|
|
checksums_dict[file] = checksum
|
|
|
|
cache: list = [] # init cache
|
|
|
|
for line in packages_txt:
|
|
|
|
if line.startswith(pkg_tag[0]):
|
|
package_name = line.replace(pkg_tag[0], '').strip()
|
|
split_package: list = self.utils.split_binary_pkg(package_name)
|
|
cache.append(split_package[0]) # package name
|
|
cache.append(split_package[1]) # package version
|
|
cache.append(package_name)
|
|
cache.append(mirror)
|
|
try:
|
|
cache.append(checksums_dict[package_name])
|
|
except KeyError:
|
|
cache.append('error checksum')
|
|
|
|
if line.startswith(pkg_tag[1]):
|
|
package_location = line.replace(pkg_tag[1], '').strip()
|
|
cache.append(package_location[2:]) # Do not install (./) dot
|
|
|
|
if line.startswith(pkg_tag[2]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[3]):
|
|
cache.append(''.join(re.findall(r'\d+', line)))
|
|
|
|
if line.startswith(pkg_tag[4]):
|
|
deps: list = []
|
|
required = line.replace(pkg_tag[4], '').strip()
|
|
|
|
for req in required.split(','):
|
|
dep = req.split('|')
|
|
if len(dep) > 1:
|
|
deps.append(dep[1])
|
|
else:
|
|
deps.extend(dep)
|
|
|
|
cache.append(' '.join(deps))
|
|
|
|
if line.startswith(pkg_tag[5]):
|
|
package_description = line.replace(pkg_tag[5], '').strip()
|
|
cache.append(package_description)
|
|
|
|
if len(cache) == 10:
|
|
data: str = BinariesTable(
|
|
repo=self.repos.slint_repo_name,
|
|
name=cache[0],
|
|
version=cache[1],
|
|
package=cache[2],
|
|
mirror=cache[3],
|
|
checksum=cache[4],
|
|
location=cache[5],
|
|
size_comp=cache[6],
|
|
size_uncomp=cache[7],
|
|
required=cache[8],
|
|
description=cache[9],
|
|
conflicts='',
|
|
suggests=''
|
|
)
|
|
|
|
self.session.add(data)
|
|
|
|
cache: list = [] # reset cache
|
|
|
|
last_updated: str = self.last_updated(path_changelog)
|
|
date: str = LastRepoUpdated(repo=self.repos.slint_repo_name, date=last_updated)
|
|
self.session.add(date)
|
|
|
|
print(f'{self.byellow}Done{self.endc}\n')
|
|
|
|
self.session.commit()
|