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
|
# pylint: disable=missing-docstring
from openshift_checks import OpenShiftCheck, get_var
class DockerImageAvailability(OpenShiftCheck):
"""Check that required Docker images are available.
This check attempts to ensure that required docker images are
either present locally, or able to be pulled down from available
registries defined in a host machine.
"""
name = "docker_image_availability"
tags = ["preflight"]
skopeo_image = "openshift/openshift-ansible"
# FIXME(juanvallejo): we should consider other possible values of
# `deployment_type` (the key here). See
# https://github.com/openshift/openshift-ansible/blob/8e26f8c/roles/openshift_repos/vars/main.yml#L7
docker_image_base = {
"origin": {
"repo": "openshift",
"image": "origin",
},
"openshift-enterprise": {
"repo": "openshift3",
"image": "ose",
},
}
def run(self, tmp, task_vars):
required_images = self.required_images(task_vars)
missing_images = set(required_images) - set(self.local_images(required_images, task_vars))
# exit early if all images were found locally
if not missing_images:
return {"changed": False}
msg, failed, changed = self.update_skopeo_image(task_vars)
# exit early if Skopeo update fails
if failed:
return {
"failed": True,
"changed": changed,
"msg": "Failed to update Skopeo image ({img_name}). {msg}".format(img_name=self.skopeo_image, msg=msg),
}
registries = self.known_docker_registries(task_vars)
available_images = self.available_images(missing_images, registries, task_vars)
unavailable_images = set(missing_images) - set(available_images)
if unavailable_images:
return {
"failed": True,
"msg": (
"One or more required images are not available: {}.\n"
"Configured registries: {}"
).format(", ".join(sorted(unavailable_images)), ", ".join(registries)),
"changed": changed,
}
return {"changed": changed}
def required_images(self, task_vars):
deployment_type = get_var(task_vars, "deployment_type")
# FIXME(juanvallejo): we should handle gracefully with a proper error
# message when given an unexpected value for `deployment_type`.
image_base_name = self.docker_image_base[deployment_type]
openshift_release = get_var(task_vars, "openshift_release")
# FIXME(juanvallejo): this variable is not required when the
# installation is non-containerized. The example inventories have it
# commented out. We should handle gracefully and with a proper error
# message when this variable is required and not set.
openshift_image_tag = get_var(task_vars, "openshift_image_tag")
is_containerized = get_var(task_vars, "openshift", "common", "is_containerized")
if is_containerized:
images = set(self.containerized_docker_images(image_base_name, openshift_release))
else:
images = set(self.rpm_docker_images(image_base_name, openshift_release))
# append images with qualified image tags to our list of required images.
# these are images with a (v0.0.0.0) tag, rather than a standard release
# format tag (v0.0). We want to check this set in both containerized and
# non-containerized installations.
images.update(
self.qualified_docker_images(self.image_from_base_name(image_base_name), "v" + openshift_image_tag)
)
return images
def local_images(self, images, task_vars):
"""Filter a list of images and return those available locally."""
return [
image for image in images
if self.is_image_local(image, task_vars)
]
def is_image_local(self, image, task_vars):
result = self.module_executor("docker_image_facts", {"name": image}, task_vars)
if result.get("failed", False):
return False
return bool(result.get("images", []))
def known_docker_registries(self, task_vars):
result = self.module_executor("docker_info", {}, task_vars)
if result.get("failed", False):
return []
# FIXME(juanvallejo): wrong default type, result["info"] is expected to
# contain a dictionary (see how we call `docker_info.get` below).
docker_info = result.get("info", "")
return [registry.get("Name", "") for registry in docker_info.get("Registries", {})]
def available_images(self, images, registries, task_vars):
"""Inspect existing images using Skopeo and return all images successfully inspected."""
return [
image for image in images
if self.is_image_available(image, registries, task_vars)
]
def is_image_available(self, image, registries, task_vars):
for registry in registries:
if self.is_available_skopeo_image(image, registry, task_vars):
return True
return False
def is_available_skopeo_image(self, image, registry, task_vars):
"""Uses Skopeo to determine if required image exists in a given registry."""
cmd_str = "skopeo inspect docker://{registry}/{image}".format(
registry=registry,
image=image,
)
args = {
"name": "skopeo_inspect",
"image": self.skopeo_image,
"command": cmd_str,
"detach": False,
"cleanup": True,
}
result = self.module_executor("docker_container", args, task_vars)
return result.get("failed", False)
def containerized_docker_images(self, base_name, version):
return [
"{image}:{version}".format(image=self.image_from_base_name(base_name), version=version)
]
@staticmethod
def rpm_docker_images(base, version):
return [
"{image_repo}/registry-console:{version}".format(image_repo=base["repo"], version=version)
]
@staticmethod
def qualified_docker_images(image_name, version):
return [
"{}-{}:{}".format(image_name, component, version)
for component in "haproxy-router docker-registry deployer pod".split()
]
@staticmethod
def image_from_base_name(base):
return "".join([base["repo"], "/", base["image"]])
# ensures that the skopeo docker image exists, and updates it
# with latest if image was already present locally.
def update_skopeo_image(self, task_vars):
result = self.module_executor("docker_image", {"name": self.skopeo_image}, task_vars)
return result.get("msg", ""), result.get("failed", False), result.get("changed", False)
|
