162 lines
6.1 KiB
Python
162 lines
6.1 KiB
Python
from urllib import request
|
|
from io import TextIOWrapper
|
|
from itertools import groupby
|
|
import re
|
|
import json
|
|
from meta_release import SourceMetaRelease, MetaRelease
|
|
import pdb
|
|
|
|
|
|
#RELEASE_WORD_MATCHER = r'(^\Origin\:\s|Label:\s|Suite:\s|Version:\s|Codename:\s|Date:\s|Architecture:\s|Components:\s|Description:\s|MD5Sum:\s|SHA256:\s|Aquire\-By\-Hash:\s)'
|
|
|
|
class Release:
|
|
def __init__(self, distro_codename):
|
|
# example url:http://old-releases.ubuntu.com/ubuntu/dists/hoary/Release
|
|
# example distro_codename = 'hoary'
|
|
self.distro_codename = distro_codename
|
|
self.meta_release = self.changelog_release_file()
|
|
|
|
def changelog_release_file(self):
|
|
meta_release = SourceMetaRelease().meta_release_parse()
|
|
return meta_release
|
|
|
|
def distro_release_file_urls(self):
|
|
meta_release_objects = []
|
|
|
|
for d in self.meta_release:
|
|
meta_release_obj = MetaRelease(d)
|
|
dist_and_release_file_url = { meta_release_obj.dist: meta_release_obj.release_file }
|
|
meta_release_objects.append(dist_and_release_file_url)
|
|
|
|
return meta_release_objects
|
|
|
|
def line_format(self, line):
|
|
""" Use this method for cleaning the line, especially the one with the md5
|
|
and shasums in them. """
|
|
try:
|
|
data = {}
|
|
split_line_arr = line.split(':')
|
|
split_line_arr_len = len(split_line_arr)
|
|
|
|
if split_line_arr_len == 1:
|
|
data = self.checksum_line_clean(split_line_arr)
|
|
|
|
elif split_line_arr_len >= 2:
|
|
k = split_line_arr[0].strip().lower()
|
|
v = split_line_arr[1].strip()
|
|
|
|
#if k == 'md5sum':
|
|
# v = []
|
|
#elif k == 'sha256':
|
|
# v = []
|
|
|
|
data[k] = v
|
|
|
|
return data
|
|
except Exception as e:
|
|
print(f'Failed to clean {line}')
|
|
print(e.__doc__)
|
|
print(e.message)
|
|
|
|
def checksum_line_clean(self, checksum_line_arr):
|
|
"""
|
|
in: [' 26f7612b4526f7b97b6b2f7abbdd59e5f83f879a0dbdcce799b7b91bc36387de 36973 universe/debian-installer/binary-sparc/Packages\n']
|
|
out: { 'checksum': '26f7612b4526f7b97b6b2f7abbdd59e5f83f879a0dbdcce799b7b91bc36387de', 'filesize': '36973', 'filepath': 'universe/debian-installer/binary-sparc/Packages\n' }
|
|
"""
|
|
data = {}
|
|
|
|
l = checksum_line_arr[0]
|
|
checksum_size_and_filepath = l.strip().split(' ')
|
|
|
|
while ('' in checksum_size_and_filepath):
|
|
checksum_size_and_filepath.remove('')
|
|
|
|
data['checksum'] = checksum_size_and_filepath[0]
|
|
data['filesize'] = checksum_size_and_filepath[1]
|
|
data['filepath'] = checksum_size_and_filepath[2]
|
|
|
|
return data
|
|
|
|
def validate_parse(self):
|
|
""" Use this method for validating the entire returned dictionary. make
|
|
sure it has the expected keys we want/expect. """
|
|
return
|
|
|
|
def release_file_parse(self, release_file_url):
|
|
""" Returns the parsed_release_file parsed as a list of dicts """
|
|
data = {}
|
|
|
|
with request.urlopen(f'{release_file_url}') as response:
|
|
index_count = 0
|
|
lines = TextIOWrapper(response, encoding='utf-8')
|
|
lines = [ l for l in lines ]
|
|
|
|
cleaned_lines = []
|
|
|
|
for l in lines:
|
|
index_count += 1
|
|
cleaned_line = self.line_format(l)
|
|
|
|
# TODO: FINISH THIS. MAKE A FUNCTION THAT HANDLES THIS STUFF.
|
|
if 'md5sum' in cleaned_line:
|
|
# this should get the dict with md5sum
|
|
# next one should be a range of each dicts checksum,
|
|
# filesize, and filepath until we reach sha256.
|
|
md5sum_index = index_count
|
|
start_md5_checksums = md5sum_index + 1
|
|
# the older distros use sha1
|
|
elif 'sha1' in cleaned_line:
|
|
sha1sum_index = index_count
|
|
start_sha1_checksums = sha1sum_index + 1
|
|
end_md5_checksums = sha1sum_index - 1
|
|
if 'aquire-by-hash' in cleaned_line:
|
|
aquire_by_hash_index = index_count
|
|
end_sha1sum_checksums = aquire_by_hash_index - 1
|
|
# newer distros use sha256
|
|
elif 'sha256' in cleaned_line:
|
|
sha256sum_index = index_count
|
|
end_md5_checksums = sha256sum_index - 1
|
|
start_sha256_checksums = sha256sum_index + 1
|
|
if 'aquire-by-hash' in cleaned_line:
|
|
aquire_by_hash_index = index_count
|
|
end_sha256_checksums = aquire_by_hash_index - 1
|
|
#else:
|
|
#cleaned_lines.append(cleaned_line)
|
|
cleaned_lines.append(cleaned_line)
|
|
|
|
|
|
# can we use list slicing to extract each range? we know where
|
|
# the index is for each.
|
|
|
|
md5sums = cleaned_lines[start_md5_checksums:end_md5_checksums]
|
|
print(f'index of md5 start: {start_md5_checksums}')
|
|
print(f'index of md5 end: {end_md5_checksums}')
|
|
sha256sums = cleaned_lines[start_sha256_checksums:end_sha256_checksums]
|
|
print(f'index of sha256 start: {start_sha256_checksums}')
|
|
print(f'index of sha256 end: {end_sha256_checksums}')
|
|
#sha1sums = cleaned_lines[start_sha1_checksums:end_sha1_checksums]
|
|
#print(f'index of sha1 start: {start_sha1_checksums}')
|
|
#print(f'index of sha1 end: {end_sha1_checksums}')
|
|
#return cleaned_lines
|
|
#return md5sums
|
|
return sha256sums
|
|
|
|
|
|
if __name__ == '__main__':
|
|
# testing
|
|
|
|
r = Release('focal')
|
|
release_file_urls = r.distro_release_file_urls()
|
|
|
|
for meta_release_dict in release_file_urls:
|
|
keys = meta_release_dict.keys()
|
|
for distro in keys:
|
|
url = meta_release_dict[distro]
|
|
try:
|
|
results = r.release_file_parse(url)
|
|
for d in results:
|
|
print(d)
|
|
except Exception as e:
|
|
print(e.__doc__)
|
|
print(e)
|
|
|