def _parse_restart_policy(self, data):
"""
Parse the restart policy from the configuration of a Docker container
in the format returned by ``self._client.inspect_container`` and return
an ``IRestartPolicy``.
:param dict data: The data structure representing the restart policy of
a container, e.g.
{"Name": "policy-name", "MaximumRetryCount": 0}
:return IRestartPolicy: The model of the restart policy.
:raises ValueError: if an unknown policy is passed.
"""
POLICIES = {
u"":
lambda data: RestartNever(),
u"always":
lambda data: RestartAlways(),
u"on-failure":
lambda data: RestartOnFailure(maximum_retry_count=data[
u"MaximumRetryCount"] or None)
}
try:
# docker will treat an unknown plolicy as "never".
# We error out here, in case new policies are added.
return POLICIES[data[u"Name"]](data)
except KeyError:
raise ValueError("Unknown restart policy: %r" % (data[u"Name"], ))
def add(unit_name,
image_name,
ports=None,
environment=None,
volumes=(),
mem_limit=None,
cpu_shares=None,
restart_policy=RestartNever()):
"""
def add(self,
unit_name,
image_name,
ports=frozenset(),
environment=None,
volumes=frozenset(),
mem_limit=None,
cpu_shares=None,
restart_policy=RestartNever()):
if unit_name in self._units:
return fail(AlreadyExists(unit_name))
self._units[unit_name] = Unit(
name=unit_name,
container_name=unit_name,
container_image=image_name,
ports=frozenset(ports),
environment=environment,
volumes=frozenset(volumes),
activation_state=u'active',
mem_limit=mem_limit,
cpu_shares=cpu_shares,
restart_policy=restart_policy,
)
return succeed(None)
def add(self,
unit_name,
image_name,
ports=None,
environment=None,
volumes=(),
mem_limit=None,
cpu_shares=None,
restart_policy=RestartNever()):
container_name = self._to_container_name(unit_name)
if environment is not None:
environment = environment.to_dict()
if ports is None:
ports = []
def _create():
self._client.create_container(
image_name,
name=container_name,
environment=environment,
volumes=list(volume.container_path.path for volume in volumes),
ports=[p.internal_port for p in ports],
mem_limit=mem_limit,
cpu_shares=cpu_shares,
)
def _add():
try:
_create()
except APIError as e:
if e.response.status_code == NOT_FOUND:
# Image was not found, so we need to pull it first:
self._client.pull(image_name)
_create()
else:
raise
# Just because we got a response doesn't mean Docker has
# actually updated any internal state yet! So if e.g. we did a
# stop on this container Docker might well complain it knows
# not the container of which we speak. To prevent this we poll
# until it does exist.
while not self._blocking_exists(container_name):
sleep(0.001)
continue
self._client.start(
container_name,
binds={
volume.node_path.path: {
u"bind": volume.container_path.path,
u"ro": False
}
for volume in volumes
},
port_bindings={
p.internal_port: p.external_port
for p in ports
},
restart_policy=self._serialize_restart_policy(restart_policy))
d = deferToThread(_add)
def _extract_error(failure):
failure.trap(APIError)
code = failure.value.response.status_code
if code == 409:
raise AlreadyExists(unit_name)
return failure
d.addErrback(_extract_error)
return d
:ivar FilePath container_path: The volume's path within the
container.
"""
@attributes([
"name",
"container_name",
"activation_state",
Attribute("container_image", default_value=None),
Attribute("ports", default_value=()),
Attribute("environment", default_value=None),
Attribute("volumes", default_value=()),
Attribute("mem_limit", default_value=None),
Attribute("cpu_shares", default_value=None),
Attribute("restart_policy", default_value=RestartNever()),
])
class Unit(object):
"""
Information about a unit managed by Docker.
XXX "Unit" is geard terminology, and should be renamed. See
https://github.com/ClusterHQ/flocker/issues/819
:ivar unicode name: The name of the unit, which may not be the same as
the container name.
:ivar unicode container_name: The name of the container where the
application is running.
:ivar unicode activation_state: The state of the