251 lines
8.0 KiB
Python
251 lines
8.0 KiB
Python
"""Models for manipulating containers and storage."""
|
|
import collections
|
|
import functools
|
|
import getpass
|
|
import json
|
|
import signal
|
|
import time
|
|
|
|
from ._containers_attach import Mixin as AttachMixin
|
|
|
|
|
|
class Container(collections.UserDict, AttachMixin):
|
|
"""Model for a container."""
|
|
|
|
def __init__(self, client, id, data):
|
|
"""Construct Container Model."""
|
|
super(Container, self).__init__(data)
|
|
|
|
self._client = client
|
|
self._id = id
|
|
|
|
with client() as podman:
|
|
self._refresh(podman)
|
|
|
|
assert self._id == self.data['id'],\
|
|
'Requested container id({}) does not match store id({})'.format(
|
|
self._id, self.id
|
|
)
|
|
|
|
def __getitem__(self, key):
|
|
"""Get items from parent dict."""
|
|
return super().__getitem__(key)
|
|
|
|
def _refresh(self, podman):
|
|
ctnr = podman.GetContainer(self._id)
|
|
super().update(ctnr['container'])
|
|
|
|
for k, v in self.data.items():
|
|
setattr(self, k, v)
|
|
if 'containerrunning' in self.data:
|
|
setattr(self, 'running', self.data['containerrunning'])
|
|
self.data['running'] = self.data['containerrunning']
|
|
|
|
return self
|
|
|
|
def refresh(self):
|
|
"""Refresh status fields for this container."""
|
|
with self._client() as podman:
|
|
return self._refresh(podman)
|
|
|
|
def processes(self):
|
|
"""Show processes running in container."""
|
|
with self._client() as podman:
|
|
results = podman.ListContainerProcesses(self.id)
|
|
yield from results['container']
|
|
|
|
def changes(self):
|
|
"""Retrieve container changes."""
|
|
with self._client() as podman:
|
|
results = podman.ListContainerChanges(self.id)
|
|
return results['container']
|
|
|
|
def kill(self, signal=signal.SIGTERM, wait=25):
|
|
"""Send signal to container.
|
|
|
|
default signal is signal.SIGTERM.
|
|
wait n of seconds, 0 waits forever.
|
|
"""
|
|
with self._client() as podman:
|
|
podman.KillContainer(self.id, signal)
|
|
timeout = time.time() + wait
|
|
while True:
|
|
self._refresh(podman)
|
|
if self.status != 'running':
|
|
return self
|
|
|
|
if wait and timeout < time.time():
|
|
raise TimeoutError()
|
|
|
|
time.sleep(0.5)
|
|
|
|
def _lower_hook(self):
|
|
"""Convert all keys to lowercase."""
|
|
|
|
@functools.wraps(self._lower_hook)
|
|
def wrapped(input):
|
|
return {k.lower(): v for (k, v) in input.items()}
|
|
|
|
return wrapped
|
|
|
|
def inspect(self):
|
|
"""Retrieve details about containers."""
|
|
with self._client() as podman:
|
|
results = podman.InspectContainer(self.id)
|
|
obj = json.loads(results['container'], object_hook=self._lower_hook())
|
|
return collections.namedtuple('ContainerInspect', obj.keys())(**obj)
|
|
|
|
def export(self, target):
|
|
"""Export container from store to tarball.
|
|
|
|
TODO: should there be a compress option, like images?
|
|
"""
|
|
with self._client() as podman:
|
|
results = podman.ExportContainer(self.id, target)
|
|
return results['tarfile']
|
|
|
|
def commit(self,
|
|
image_name,
|
|
*args,
|
|
changes=[],
|
|
message='',
|
|
pause=True,
|
|
**kwargs):
|
|
"""Create image from container.
|
|
|
|
All changes overwrite existing values.
|
|
See inspect() to obtain current settings.
|
|
|
|
Changes:
|
|
CMD=/usr/bin/zsh
|
|
ENTRYPOINT=/bin/sh date
|
|
ENV=TEST=test_containers.TestContainers.test_commit
|
|
EXPOSE=8888/tcp
|
|
LABEL=unittest=test_commit
|
|
USER=bozo:circus
|
|
VOLUME=/data
|
|
WORKDIR=/data/application
|
|
"""
|
|
# TODO: Clean up *args, **kwargs after Commit() is complete
|
|
try:
|
|
author = kwargs.get('author', getpass.getuser())
|
|
except Exception:
|
|
author = ''
|
|
|
|
for c in changes:
|
|
if c.startswith('LABEL=') and c.count('=') < 2:
|
|
raise ValueError(
|
|
'LABEL should have the format: LABEL=label=value, not {}'.
|
|
format(c))
|
|
|
|
with self._client() as podman:
|
|
results = podman.Commit(self.id, image_name, changes, author,
|
|
message, pause)
|
|
return results['image']
|
|
|
|
def start(self):
|
|
"""Start container, return container on success."""
|
|
with self._client() as podman:
|
|
podman.StartContainer(self.id)
|
|
return self._refresh(podman)
|
|
|
|
def stop(self, timeout=25):
|
|
"""Stop container, return id on success."""
|
|
with self._client() as podman:
|
|
podman.StopContainer(self.id, timeout)
|
|
return self._refresh(podman)
|
|
|
|
def remove(self, force=False):
|
|
"""Remove container, return id on success.
|
|
|
|
force=True, stop running container.
|
|
"""
|
|
with self._client() as podman:
|
|
results = podman.RemoveContainer(self.id, force)
|
|
return results['container']
|
|
|
|
def restart(self, timeout=25):
|
|
"""Restart container with timeout, return id on success."""
|
|
with self._client() as podman:
|
|
podman.RestartContainer(self.id, timeout)
|
|
return self._refresh(podman)
|
|
|
|
def rename(self, target):
|
|
"""Rename container, return id on success."""
|
|
with self._client() as podman:
|
|
# TODO: Need arguments
|
|
results = podman.RenameContainer()
|
|
# TODO: fixup objects cached information
|
|
return results['container']
|
|
|
|
def resize_tty(self, width, height):
|
|
"""Resize container tty."""
|
|
with self._client() as podman:
|
|
# TODO: magic re: attach(), arguments
|
|
podman.ResizeContainerTty()
|
|
|
|
def pause(self):
|
|
"""Pause container, return id on success."""
|
|
with self._client() as podman:
|
|
podman.PauseContainer(self.id)
|
|
return self._refresh(podman)
|
|
|
|
def unpause(self):
|
|
"""Unpause container, return id on success."""
|
|
with self._client() as podman:
|
|
podman.UnpauseContainer(self.id)
|
|
return self._refresh(podman)
|
|
|
|
def update_container(self, *args, **kwargs):
|
|
"""TODO: Update container..., return id on success."""
|
|
with self._client() as podman:
|
|
podman.UpdateContainer()
|
|
return self._refresh(podman)
|
|
|
|
def wait(self):
|
|
"""Wait for container to finish, return 'returncode'."""
|
|
with self._client() as podman:
|
|
results = podman.WaitContainer(self.id)
|
|
return int(results['exitcode'])
|
|
|
|
def stats(self):
|
|
"""Retrieve resource stats from the container."""
|
|
with self._client() as podman:
|
|
results = podman.GetContainerStats(self.id)
|
|
obj = results['container']
|
|
return collections.namedtuple('StatDetail', obj.keys())(**obj)
|
|
|
|
def logs(self, *args, **kwargs):
|
|
"""Retrieve container logs."""
|
|
with self._client() as podman:
|
|
results = podman.GetContainerLogs(self.id)
|
|
yield from results
|
|
|
|
|
|
class Containers(object):
|
|
"""Model for Containers collection."""
|
|
|
|
def __init__(self, client):
|
|
"""Construct model for Containers collection."""
|
|
self._client = client
|
|
|
|
def list(self):
|
|
"""List of containers in the container store."""
|
|
with self._client() as podman:
|
|
results = podman.ListContainers()
|
|
for cntr in results['containers']:
|
|
yield Container(self._client, cntr['id'], cntr)
|
|
|
|
def delete_stopped(self):
|
|
"""Delete all stopped containers."""
|
|
with self._client() as podman:
|
|
results = podman.DeleteStoppedContainers()
|
|
return results['containers']
|
|
|
|
def get(self, id):
|
|
"""Retrieve container details from store."""
|
|
with self._client() as podman:
|
|
cntr = podman.GetContainer(id)
|
|
return Container(self._client, cntr['container']['id'],
|
|
cntr['container'])
|