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