File size: 5,891 Bytes
f764cdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
917c16d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
f764cdf
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
"""Offline recovery, filtering, and content-integrity tests."""

from contextlib import closing
import gzip
import hashlib
import io
from pathlib import Path
import tempfile
import threading
from types import SimpleNamespace
import unittest

import pyarrow as pa
import pyarrow.parquet as pq

from stackgo.scripts import download_stack_v2_contents as downloader


class FakeS3:
    def __init__(self, bodies):
        self.bodies = bodies
        self.calls = []

    def get_object(self, Bucket, Key):
        self.calls.append(Key)
        return {'Body': io.BytesIO(gzip.compress(self.bodies[Key.split('/')[-1]]))}


class ContentsTest(unittest.TestCase):
    def test_prepare_accepts_strict_star_range(self):
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            blob = hashlib.sha1(b'body').hexdigest()
            files = [dict(blob_id=blob, length_bytes=4, path='src/a.py')]
            source = root / 'source.parquet'
            pq.write_table(pa.Table.from_pylist([
                dict(repo_name=str(stars), star_events_count=stars, revision_id=str(stars), files=files)
                for stars in (1, 2, 9, 10, 11, None)
            ]), source)
            target = root / 'shard'
            self.assertTrue(downloader.prepare(
                source, target, threading.Event(),
                min_stars_exclusive=1, max_stars_exclusive=11,
            ))
            self.assertEqual(
                [row['repo_name'] for row in pq.read_table(target / 'repositories.parquet').to_pylist()],
                ['2', '9', '10'],
            )

    def test_strict_filter_full_metadata_and_crash_recovery(self):
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            bodies = {hashlib.sha1(b'hello').hexdigest(): b'hello',
                      hashlib.sha1(b'world').hexdigest(): b'world'}
            files = [dict(blob_id=blob, length_bytes=len(body) + number, path=f'src/{number}.py',
                          detected_licenses=['MIT'], src_encoding='utf-8')
                     for number, (blob, body) in enumerate(bodies.items())]
            source = root / 'source.parquet'
            pq.write_table(pa.Table.from_pylist([
                dict(repo_name='excluded', star_events_count=10, revision_id='a', files=files),
                dict(repo_name='included', star_events_count=11, revision_id='b', files=files + files[:1]),
                dict(repo_name='unknown', star_events_count=None, revision_id='c', files=files),
            ]), source)
            target = root / 'shard'
            stop = threading.Event()
            self.assertTrue(downloader.prepare(source, target, stop))
            metadata = pq.read_table(target / 'repositories.parquet').to_pylist()
            self.assertEqual(len(metadata), 1)
            self.assertEqual(metadata[0]['files'], files + files[:1])
            args = SimpleNamespace(workers=2, shard_files=2, shard_mib=1)
            s3 = FakeS3(bodies)
            with closing(downloader.state(target / 'queue.sqlite3')) as db:
                with db:
                    db.execute("UPDATE blobs SET status='fetching'")
                # Simulate atomic Parquet publication followed by a crash before DB acknowledgement.
                content_dir = target / 'contents'
                content_dir.mkdir()
                blob, body = next(iter(bodies.items()))
                pq.write_table(pa.Table.from_pylist([dict(blob_id=blob, content=body,
                    length_bytes=len(body))], schema=downloader.BODY_SCHEMA), content_dir / 'recovered.parquet')
                count = downloader.download(db, target, s3, args, stop, None)
                self.assertEqual(count, 1)
                self.assertEqual(len(s3.calls), 1)
                self.assertEqual(db.execute("SELECT count(*) FROM blobs WHERE status='done'").fetchone()[0], 2)
                self.assertEqual(downloader.download(db, target, s3, args, stop, None), 0)
                recovered = pq.read_table(content_dir).to_pylist()
                self.assertEqual({row['blob_id']: row['content'] for row in recovered}, bodies)
                self.assertFalse(next(row for row in recovered if row['blob_id'] != blob)['length_matches_index'])

    def test_corrupt_content_rejected(self):
        blob = hashlib.sha1(b'right').hexdigest()
        with self.assertRaisesRegex(ValueError, 'SHA1Mismatch'):
            downloader.fetch(FakeS3({blob: b'wrong'}), blob, 5)
        self.assertEqual(downloader.fetch(FakeS3({blob: b'right'}), blob, 1), b'right')

    def test_transient_failure_survives_restart_and_attempt_limit(self):
        class Unreachable:
            def get_object(self, **kwargs):
                raise TimeoutError('offline')

        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
            body = b'retry me'
            blob = hashlib.sha1(body).hexdigest()
            args = SimpleNamespace(workers=2, shard_files=2, shard_mib=1)
            stop = threading.Event()
            with closing(downloader.state(root / 'queue.sqlite3')) as db:
                with db:
                    db.execute('INSERT INTO blobs(blob_id,length_bytes) VALUES (?,?)', (blob, len(body)))
                self.assertEqual(downloader.download(db, root, Unreachable(), args, stop, 1), 1)
                self.assertEqual(db.execute('SELECT status,attempts FROM blobs').fetchone(), ('error', 1))
            with closing(downloader.state(root / 'queue.sqlite3')) as db:
                with db:
                    db.execute('UPDATE blobs SET retry_at=0')
                self.assertEqual(downloader.download(db, root, FakeS3({blob: body}), args, stop, 1), 1)
                self.assertEqual(db.execute('SELECT status FROM blobs').fetchone()[0], 'done')


if __name__ == '__main__':
    unittest.main()