1
diff --git a/software-versions.sh b/software-versions.sh
2
0
new file mode 100755
0
new file mode 100755
3
index 0000000..4172ce8
4
--- /dev/null
5
+++ b/software-versions.sh
6
@@ -0,0 +1,229 @@
7
1
#!/usr/bin/env bash
8
2
# -*- coding: utf-8; mode: sh -*-
9
3
10
4
# software-versions.sh:  Determine versions of packages installed in OCI images
11
5
12
6
progname=$(basename "${0}")
13
7
progdir=$(dirname "$(readlink -f "${0}")")
14
8
15
9
if [ -z "${DOCKER_USER}" ]; then
16
10
    DOCKER_USER=$(docker info | grep Username: | cut -d: -f2 | xargs)
17
11
fi
18
12
if [ -z "${DISTRO_CODENAME}" ]; then
19
13
    DISTRO_CODENAME=$(distro-info --devel)
20
14
fi
21
15
22
16
die() {
23
17
    echo "Error:  ${*}" 1>&2
24
18
    exit 1
25
19
}
26
20
27
21
28
22
# Converts a package version number to equivalent upstream version.
29
23
# Strips off epoch, if any, and drops the debian version.
30
24
#
31
25
# :param v: Package version number to convert
32
26
upstream_version() {
33
27
    local v="${1#*:}"
34
28
    echo "${v%-*}"
35
29
}
36
30
37
31
# Look up version of package in a given Ubuntu release
38
32
#
39
33
# @param source_package_name: Name of the source package to look up
40
34
get_source_package_version() {
41
35
    local source_package_name="${1}"
42
36
43
37
    rmadison -s "${DISTRO_CODENAME}" "${source_package_name}" | cut -d\| -f2 | xargs
44
38
}
45
39
46
40
# Provides the "version family" of the software
47
41
#
48
42
# For a given Ubuntu stable release, updates will be limited to certain
49
43
# ranges of version numbers based on API and stability policies.  For
50
44
# example, some may get patch-level updates (i.e. M.N.1->M.N.2->M.N.3)
51
45
# and thus have an "M.N" version family, others may get minor-level
52
46
# updates (such as postrgres, which in focal had 12.4->12.5->12.6) so
53
47
# have an "M" version family.
54
48
#
55
49
# This routine determines this from the debian version by extracting the
56
50
# first two numbers from upstream version portion.
57
51
#
58
52
# @param software_name: Formal name of the upstream software
59
53
get_source_package_major() {
60
54
    # TODO: This routine should be named get_software_version_family
61
55
    #       or get_software_main_version or something similar
62
56
    local software_name="${1}"
63
57
    local package_version=""
64
58
65
59
    # For apache2, just return 2.4
66
60
    if [ "${software_name}" = "apache2" ]; then
67
61
	package_version=$(get_source_package_version apache2)
68
62
69
63
    # For postgres return 12, 13, etc.
70
64
    elif [ "${software_name}" = "postgres" ]; then
71
65
	pg_api_version=$(get_source_package_version postgresql)
72
66
	pg_api_package="postgresql-${pg_api_version%+*}"
73
67
	package_version=$(get_source_package_version "${pg_api_package}")
74
68
75
69
    # For mysql return 5.7, 8.0, etc.
76
70
    elif [ "${software_name}" = "mysql" ]; then
77
71
	package_version=$(get_source_package_version mysql-server)
78
72
79
73
    elif [ "${software_name}" = "redis" ]; then
80
74
	package_version=$(get_source_package_version redis-server)
81
75
    fi
82
76
83
77
    if [ -n "${package_version}" ]; then
84
78
	version=$(upstream_version "${package_version}")
85
79
	local v=( ${version//./ } )
86
80
	local version_major="${v[0]}"
87
81
	local version_minor="${v[1]}"
88
82
	if [ "${software_name}" = "postgres" ]; then
89
83
	    echo "${version_major}"
90
84
	else
91
85
	    echo "${version_major}.${version_minor}"
92
86
	fi
93
87
    fi
94
88
95
89
    # For everything else, return blank
96
90
    echo ""
97
91
}
98
92
99
93
# Determine the source package for the given software name
100
94
#
101
95
# In many cases, the software name is identical to the source package's
102
96
# name, however there are cases where the spelling may vary
103
97
# (e.g. postgres vs. postgresql), or where the source package includes
104
98
# part of the version number.  This routine does this mapping.
105
99
#
106
100
# @param software_name: Formal name of the upstream software
107
101
get_software_source_package() {
108
102
    local software_name="${1}"
109
103
    local source_package_name=""
110
104
111
105
    # Look to see if there is a <software>-N.M package
112
106
    local package_major=$(get_source_package_major "${software_name}")
113
107
    if [ -n "${package_major}" ]; then
114
108
	local prefix="${software_name}"
115
109
	if [ "${software_name}" = "postgres" ]; then
116
110
	    prefix="postgresql"
117
111
	fi
118
112
119
113
	source_package_name=$(rmadison -s "${DISTRO_CODENAME}" "${prefix}-${package_major}" | cut -d\| -f1 | xargs)
120
114
	if [ -n "${source_package_name}" ] && [ "${source_package_name}" != "${prefix}-${package_major}" ]; then
121
115
	    die "error: ${source_package_name} is not ${prefix}-${package_major} as expected"
122
116
	fi
123
117
    fi
124
118
125
119
    # If not, default to just <software>
126
120
    if [ -z "${source_package_name}" ]; then
127
121
	source_package_name="${software_name}"
128
122
    fi
129
123
130
124
    echo "${source_package_name}"
131
125
    return 0
132
126
}
133
127
134
128
# Get primary binary package for given software
135
129
#
136
130
# For some software, the binary package names differ from the source
137
131
# package name, so when checking installed versions we need to be careful
138
132
# to use the appropriate binary package name.  For now, we just manually
139
133
# translate a few specific cases.
140
134
#
141
135
# @param software_name: Formal name of the upstream software
142
136
get_software_binary_package() {
143
137
    local software_name="${1}"
144
138
    local package_major=$(get_source_package_major "${software_name}")
145
139
146
140
    if [ "${software_name}" = "mysql" ]; then
147
141
	# mysql-client-core-N and mysql-client-N are also installed
148
142
	echo "mysql-server-core-${package_major}"
149
143
    elif [ "${software_name}" = "postgres" ]; then
150
144
	echo "postgresql-${package_major}"
151
145
    elif [ "${software_name}" = "nginx" ]; then
152
146
	# nginx-common is also installed
153
147
	echo "nginx-full"
154
148
    elif [ "${software_name}" = "redis" ]; then
155
149
	echo "redis-server"
156
150
    else
157
151
	echo "${software_name}"
158
152
    fi
159
153
}
160
154
161
155
# Lookup a binary package version present in a given Docker image
162
156
#
163
157
# Uses apt-cache policy to determine installed version of a specific
164
158
# binary package.
165
159
#
166
160
# @param image_id: The name of the image to examine
167
161
# @param binary_package_name: The binary package to look up version info
168
162
get_image_installed_package_version() {
169
163
    local image_id="${1}"
170
164
    local binary_package_name="${2}"
171
165
172
166
    [ -n "${image_id}" ] || return 1
173
167
174
168
    docker run --rm \
175
169
	   --name "${image_id}-version-check" \
176
170
	   "${image_id}" \
177
171
	   apt-cache policy "${binary_package_name}" \
178
172
	| grep "Installed:" | cut -d: -f2- | xargs
179
173
}
180
174
181
175
# Display a table entry for the given software
182
176
#
183
177
# This is an aide for summarizing versions of software packages in the
184
178
# distro, vs. what's in the existing ubuntu-namespaced Docker images.
185
179
# It also displays versions of the package in the user's namespace
186
180
# as a convenience for development work.
187
181
#
188
182
# @param software_name: Formal name of the upstream software
189
183
get_software_versions() {
190
184
    # For given software_name:
191
185
    #    Create container from the image
192
186
    #    Log into the container
193
187
    #    Retrieve the version for software_name
194
188
    software_name="${1}"
195
189
    source_package_name="$(get_software_source_package ${software_name})"
196
190
    binary_package_name="$(get_software_binary_package ${software_name})"
197
191
    proposed_image_name="${DOCKER_USER}/${software_name}"
198
192
    current_image_name="ubuntu/${software_name}"
199
193
200
194
    proposed_image_id=$(docker image ls | grep ^${proposed_image_name} | grep edge | awk '{print $3}' | uniq)
201
195
    current_image_id=$(docker image ls | grep ^${current_image_name} | grep edge | awk '{print $3}' | uniq)
202
196
    package_version_distro=$(get_source_package_version "${source_package_name}")
203
197
    package_version_current=$(get_image_installed_package_version "${current_image_id}" "${binary_package_name}")
204
198
    package_version_proposed=$(get_image_installed_package_version "${proposed_image_id}" "${binary_package_name}")
205
199
206
200
    printf "%-20s %-30s %-30s %-30s\n" "${source_package_name}" \
207
201
	   "${package_version_distro:--}" "${package_version_current:--}" "${package_version_proposed:--}"
208
202
}
209
203
210
204
# Tabular report of Canonical Server's debian-based docker images
211
205
#
212
206
# Creates a summary of package version numbers for software installed
213
207
# in docker images that the canonical server team maintains.
214
208
display_version_report() {
215
209
    docker image pull ubuntu/apache2:edge
216
210
    docker image pull ubuntu/memcached:edge
217
211
    docker image pull ubuntu/mysql:edge
218
212
    docker image pull ubuntu/nginx:edge
219
213
    docker image pull ubuntu/postgres:edge
220
214
    docker image pull ubuntu/redis:edge
221
215
222
216
    printf "%-20s %-30s %-30s %-30s\n" "Software" "Distro" "Current-Image" "Proposed-Image"
223
217
    get_software_versions "apache2"
224
218
    get_software_versions "memcached"
225
219
    get_software_versions "mysql"
226
220
    get_software_versions "nginx"
227
221
    get_software_versions "postgres"
228
222
    get_software_versions "redis"
229
223
}
230
224
231
225
# If we're being run directly (i.e. not sourced), then
232
226
# print out the current software versions.
233
227
if [[ "${0}" == "${BASH_SOURCE[0]}" ]]; then
234
228
    display_version_report
235
229
fi
236
diff --git a/update-images.sh b/update-images.sh
237
0
new file mode 100755
230
new file mode 100755
238
index 0000000..ecea08a
239
--- /dev/null
240
+++ b/update-images.sh
241
@@ -0,0 +1,150 @@
242
1
#!/usr/bin/env bash
243
2
# -*- coding: utf-8; mode: sh -*-
244
3
245
4
# update-images.sh:  Refresh software versions for Ubuntu's OCI images
246
5
247
6
progname=$(basename "${0}")
248
7
progdir=$(dirname "$(readlink -f "${0}")")
249
8
250
9
# shellcheck source=/dev/null disable=SC1090
251
10
source "${progdir}/software-versions.sh"
252
11
253
12
if ! groups | grep docker > /dev/null; then
254
13
    echo "Error: Must be in docker group" 1>&2
255
14
    exit 1
256
15
fi
257
16
258
17
if [ -z "${TESTS_DIR}" ]; then
259
18
    TESTS_DIR="${progdir}/../server-test-scripts/oci-unit-tests"
260
19
fi
261
20
if [ -z "${REPOS_DIR}" ]; then
262
21
    REPOS_DIR="${progdir}/../"
263
22
fi
264
23
265
24
usage() {
266
25
    cat >&2 <<EOF
267
26
Usage: ${progname} <package-name> [package-name ...]
268
27
269
28
EOF
270
29
    # shellcheck source=/dev/null disable=SC2086
271
30
    exit "${1}"
272
31
}
273
32
274
33
# Modifies contents of the Dockerfile in the current directory
275
34
#
276
35
# @param software_name:  Formal name of the upstream software for the Dockerfile
277
36
update_dockerfile_parameters() {
278
37
    local software_name="${1}"
279
38
    local dockerfile="./Dockerfile"
280
39
281
40
    # TODO: Given that we're in the git repository, can we determine the
282
41
    #       software_name from just that?  If so, then this can run without
283
42
    #       argument $1.
284
43
285
44
    if [ ! -e "${dockerfile}" ]; then
286
45
	die "error: Dockerfile ${dockerfile} not found at ${PWD}"
287
46
    fi
288
47
289
48
    # Update global parameters
290
49
    sed -i "/FROM ubuntu:/c\FROM ubuntu:${DISTRO_CODENAME}" "${dockerfile}"
291
50
292
51
    # Update per-package parameters
293
52
    if [ "${software_name}" = "postgres" ]; then
294
53
	pg_major=$(get_source_package_major postgresql)
295
54
	sed -i "/ENV PG_MAJOR/c\ENV PG_MAJOR ${pg_major}" "${dockerfile}"
296
55
    fi
297
56
298
57
    return 0
299
58
}
300
59
301
60
# Creates branch for a new Ubuntu distro series and updates package to match
302
61
#
303
62
# This routine can be run to create an updated image for a new version
304
63
# of Ubuntu.  It sets the Dockerfile to the new Ubuntu version, and
305
64
# rebuilds it with the version of the software's package from that
306
65
# release.
307
66
#
308
67
# @param software_name:  Formal name of the upstream software for the Dockerfile
309
68
update_image() {
310
69
    [ -n "${1}" ] \
311
70
	|| usage 1
312
71
313
72
    local software_name="${1}"
314
73
    local package_name=$(get_software_source_package "${software_name}")
315
74
    local package_version=$(get_source_package_version "${package_name}")
316
75
    local package_major=$(get_source_package_major "${software_name}")
317
76
    local upstream_version=$(upstream_version "${package_version}")
318
77
    # TODO: Remove +dfsg
319
78
    local v=( ${upstream_version//./ } )
320
79
    local version_major="${v[0]}"
321
80
    local version_minor="${v[1]}"
322
81
    local docker_image="${DOCKER_USER}/${software_name}:21.04"
323
82
    local test_script="${TESTS_DIR}/${software_name}_test.sh"
324
83
    local distro_release=$(distro-info --series "${DISTRO_CODENAME}" -r)
325
84
    local branch_name="${version_major}.${version_minor}-${distro_release}"
326
85
327
86
    # Hack, due to postgres/postgresql discrepancy
328
87
    if [ "${software_name}" = "postgres" ]; then
329
88
	test_script="${TESTS_DIR}/postgresql_test.sh"
330
89
    fi
331
90
332
91
    echo
333
92
    echo "########################################################"
334
93
    echo "# distro:       ${DISTRO_CODENAME} (${distro_release})"
335
94
    echo "# software:     ${software_name} -> ${package_name} ${package_major}"
336
95
    echo "# docker_image: ${docker_image}"
337
96
    echo "# test_script:  ${test_script}"
338
97
    echo "# version:      ${package_version}"
339
98
    echo "# upstream:     ${upstream_version}"
340
99
    echo "# branch_name:  ${branch_name}"
341
100
    echo "########################################################"
342
101
343
102
    cd "${REPOS_DIR}/${software_name}" \
344
103
	|| die "Could not chdir to ${REPOS_DIR}/${software_name}"
345
104
346
105
    git checkout "${branch_name}" \
347
106
       || die "Could not checkout ${branch_name} from git"
348
107
349
108
    # Update Dockerfile parameters
350
109
    echo
351
110
    echo "### Updating Dockerfile ###"
352
111
    update_dockerfile_parameters "${software_name}"
353
112
354
113
    # Update the docs
355
114
    make all-doc \
356
115
	|| die "Could not update the documentation"
357
116
358
117
    # Build the image
359
118
    echo
360
119
    echo "### Building Image ###"
361
120
    docker build --tag "${docker_image}" . \
362
121
	|| die "Failed to build ${docker_image} for ${package_name}"
363
122
364
123
    git commit -a -m "Update docker image to ${package_version} for ${DISTRO_CODENAME}"
365
124
366
125
    # Run the test
367
126
    echo
368
127
    echo "### Testing Image ###"
369
128
    if [ ! -e "${test_script}" ]; then
370
129
	die "Test script for ${software_name} not found at ${test_script}"
371
130
    fi
372
131
    cd "${TESTS_DIR}" \
373
132
	|| die "Could not chdir to ${TESTS_DIR}"
374
133
    DOCKER_IMAGE="${docker_image}" bash ${test_script} \
375
134
	|| die "Failed ${docker_image}'s test for ${package_name}"
376
135
377
136
    exit 0
378
137
}
379
138
380
139
if [[ "${0}" == "${BASH_SOURCE[0]}" ]]; then
381
140
    [ -n "${1}" ] \
382
141
	|| usage 1
383
142
384
143
    for package_name in ${@}; do
385
144
	echo "Updating ${package_name}"
386
145
	update_image "${package_name}"
387
146
	echo
388
147
	echo "---"
389
148
	echo
390
149
    done
391
150
fi
Status:	Rejected
Rejected by:	Bryce Harrington on 2021-03-27
Proposed branch:	~ubuntu-docker-images/ubuntu-docker-images/+git/utils:update-and-check-images
Merge into:	~ubuntu-docker-images/ubuntu-docker-images/+git/utils:master
Diff against target:	391 lines (+379/-0) 2 files modified software-versions.sh (+229/-0) update-images.sh (+150/-0)
Related bugs:	Link a bug report
Reviewer	Date Requested	Status
Sergio Durigan Junior	2021-02-19	Needs Fixing on 2021-02-19
Lucas Kanashiro		Needs Information on 2021-02-19
Review via email: mp+398323@code.launchpad.net