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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
import glob
import os
import re
import sys
import subprocess
verbose = True
def debug(*args):
if verbose:
print('DEBUG:', *args)
class Exec:
def __init__(self, dirname):
self.dirname = dirname
def run(self, *args, **kwargs):
if 'cwd' not in kwargs:
kwargs['cwd'] = self.dirname
if 'check' not in kwargs:
kwargs['check'] = True
if 'stdout' not in kwargs:
kwargs['stdout'] = subprocess.PIPE
if 'stderr' not in kwargs:
kwargs['stderr'] = subprocess.STDOUT
debug('RUN:', args, kwargs)
x = subprocess.run(args, **kwargs)
if kwargs['stdout'] == subprocess.PIPE:
if x.stdout:
sys.stdout.write(x.stdout.decode('UTF-8'))
return x
def get_stdout(self, *args, **kwargs):
kwargs['check'] = True
kwargs['stdout'] = subprocess.PIPE
x = self.run(*args, **kwargs)
return x.stdout.decode('UTF-8')
def run_silently(self, *args, **kwargs):
kwargs['stdout'] = kwargs['stderr'] = subprocess.DEVNULL
kwargs['check'] = False
return self.run(*args, **kwargs)
def is_signed_tag(self, tag):
x = self.run_silently('git', 'tag', '--verify', tag)
return x.returncode == 0
def is_named_as_release_tag(self, tag, project):
prefix = tag[:len(project)]
suffix = tag[len(prefix):]
return prefix == project and re.match(r'^-\d+\.\d+(\.\d+)*$', suffix)
def is_release_tag(self, tag, project):
if not self.is_signed_tag(tag):
debug('tag is not signed:', tag)
return False
if not self.is_named_as_release_tag(tag, project):
debug('tag is not named correctly for a release tag:', tag)
return False
debug('seems to be a release tag:', tag)
return True
def get_debian_source_package(self):
output = self.get_stdout('dpkg-parsechangelog', '-S', 'Source')
return output.strip()
def get_version_from_tag(self, tag):
parts = tag.split('-', 1)
debug('tag parts:', parts)
assert len(parts) == 2
return parts[1]
def find_all_tags(self):
output = self.get_stdout('git', 'tag', '-l')
return output.splitlines()
def find_release_tags(self, project):
tags = self.find_all_tags()
return [
tag
for tag in tags
if self.is_release_tag(tag, project)
]
def create_tarball_from_tag(self, tag, filename):
self.run('git', 'archive', '-o', 'temp.tar', tag)
self.run('xz', '-9', 'temp.tar')
self.run('mv', 'temp.tar.xz', filename)
class Version:
def __init__(self, full_version):
self._full_version = full_version
@property
def full(self):
return self._full_version
@property
def upstream(self):
parts = self._full_version.split('-', 1)
return parts[0]
@property
def debian(self):
parts = self._full_version.split('-', 1)
if len(parts) == 1:
return None
return parts[1]
class DebianReleaseBuilder:
def __init__(self, ex, resultsdir):
self.ex = ex
self.results = resultsdir
def build(self, tag):
debug('Building release from tag', tag)
cwd = os.getcwd()
self.checkout(tag)
upstream_tarball = self.create_upstream_tarball(tag)
debug('upstream_tarball:', upstream_tarball)
self.stash(upstream_tarball)
source = self.get_source_package()
version = self.get_version()
debug('Source package:', source)
debug('Version:', version)
orig_tarball = self.create_debian_orig_tarball(
upstream_tarball, source, version)
self.create_dsc()
self.build_deb()
debian_files = glob.glob('{}_{}*'.format(source, version.upstream))
debug('DEBIAN:', debian_files)
self.stash(*debian_files)
filenames = glob.glob('{}_{}*'.format(source, version.upstream))
filenames.append(upstream_tarball)
self.cleanup(filenames)
debug()
def checkout(self, tag):
self.ex.run('git', 'checkout', 'master', check=False)
self.ex.run('git', 'branch', '-d', '__ickbuild', check=False)
self.ex.run('git', 'checkout', '-b', '__ickbuild', tag)
def create_upstream_tarball(self, tag):
basename = '{}.tar.xz'.format(tag)
tarball = os.path.abspath(basename)
self.ex.create_tarball_from_tag(tag, tarball)
return basename
def create_debian_orig_tarball(self, upstream_tarball, source, version):
tarball = '{}_{}.orig.tar.xz'.format(source, version.upstream)
os.link(upstream_tarball, tarball)
return tarball
def get_source_package(self):
output = self.ex.get_stdout('dpkg-parsechangelog', '-S', 'Source')
return output.strip()
def get_version(self):
output = self.ex.get_stdout('dpkg-parsechangelog', '-S', 'Version')
return Version(output.strip())
def create_dsc(self):
self.ex.run('dpkg-buildpackage', '-S', '--no-sign')
def build_deb(self):
self.ex.run('dpkg-buildpackage', '-b', '--no-sign')
def stash(self, *filenames):
if not os.path.exists(self.results):
os.mkdir(self.results)
for filename in filenames:
dst = os.path.join(self.results, filename)
debug('STASH:', filename, '->', dst)
os.link(filename, dst)
def cleanup(self, filenames):
for filename in filenames:
debug('DELETE', filename)
os.remove(filename)
known_tags = '.known_tags'
def get_known_tags():
if os.path.exists(known_tags):
with open(known_tags) as f:
return [line.strip() for line in f.readlines()]
return []
def remember_tag(tag):
with open(known_tags, 'a') as f:
f.write('{}\n'.format(tag))
def find_upstream_dirs(sources):
for source in sources:
dirname = source['location']
control = os.path.join(dirname, 'debian', 'control')
if os.path.exists(control):
yield dirname
def build_debian_releases(sources, resultsdir):
known_tags = get_known_tags()
debug('KNOWN:', known_tags)
dirnames = find_upstream_dirs(sources)
for dirname in dirnames:
ex = Exec(dirname)
project = ex.get_debian_source_package()
tags = ex.find_release_tags(project)
builder = DebianReleaseBuilder(ex, resultsdir)
for tag in tags:
if tag not in known_tags:
builder.build(tag)
remember_tag(tag)
|
