166 lines
4.6 KiB
Python
166 lines
4.6 KiB
Python
import os
|
|
import docker
|
|
import json
|
|
|
|
DOCKER_BASE_URL = os.environ.get('DOCKER_BASE_URL') or "unix://tmp/docker.sock"
|
|
VOLUME_TYPE_BIND = "bind"
|
|
VOLUME_TYPE_VOLUME = "volume"
|
|
|
|
|
|
class Container:
|
|
|
|
def __init__(self, data):
|
|
self.id = data.get('Id')
|
|
self.state = data.get('State')
|
|
self.labels = data.get('Labels')
|
|
self.names = data.get('Names')
|
|
self.mounts = [Mount(mnt, container=self) for mnt in data.get('Mounts')]
|
|
|
|
@property
|
|
def backup_enabled(self):
|
|
return self.labels.get('restic-volume-backup.enabled') == 'True'
|
|
|
|
@property
|
|
def is_running(self):
|
|
return self.state == 'running'
|
|
|
|
@property
|
|
def service_name(self):
|
|
return self.labels['com.docker.compose.service']
|
|
|
|
@property
|
|
def project_name(self):
|
|
return self.labels['com.docker.compose.project']
|
|
|
|
@property
|
|
def is_oneoff(self):
|
|
return self.labels['com.docker.compose.oneoff'] == 'True'
|
|
|
|
def to_dict(self):
|
|
return {
|
|
'Id': self.id,
|
|
'Names': self.names,
|
|
'State': self.state,
|
|
'Labels': self.labels,
|
|
'Mounts': [mnt.data for mnt in self.mounts]
|
|
}
|
|
|
|
|
|
class Mount:
|
|
"""Mount wrapper"""
|
|
def __init__(self, data, container=None):
|
|
self.data = data
|
|
self._container = container
|
|
|
|
@property
|
|
def container(self):
|
|
return self._container
|
|
|
|
@property
|
|
def type(self):
|
|
return self.data.get('Type')
|
|
|
|
@property
|
|
def name(self):
|
|
return self.data.get('Name')
|
|
|
|
@property
|
|
def source(self):
|
|
return self.data.get('Source')
|
|
|
|
@property
|
|
def destination(self):
|
|
return self.data.get('Destination')
|
|
|
|
@property
|
|
def driver(self):
|
|
return self.data.get('Driver')
|
|
|
|
@property
|
|
def mode(self):
|
|
return self.data.get('Mode')
|
|
|
|
@property
|
|
def rw(self):
|
|
return self.data.get('RW')
|
|
|
|
def mount_string(self):
|
|
if self.type == VOLUME_TYPE_VOLUME:
|
|
return "- {}:{}:ro".format(self.name.split('_')[-1], self.destination)
|
|
elif self.type == VOLUME_TYPE_BIND:
|
|
return "- {}:{}:ro".format(self.source, self.destination)
|
|
else:
|
|
raise ValueError("Uknown volume type: {}".format(self.type))
|
|
|
|
def __repr__(self):
|
|
return str(self)
|
|
|
|
def __str__(self):
|
|
return str(self.data)
|
|
|
|
def __hash__(self):
|
|
"""Uniquness for a volume"""
|
|
if self.type == VOLUME_TYPE_VOLUME:
|
|
return hash(self.name)
|
|
elif self.type == VOLUME_TYPE_BIND:
|
|
return hash(self.source)
|
|
else:
|
|
raise ValueError("Uknown volume type: {}".format(self.type))
|
|
|
|
|
|
class RunningContainers:
|
|
|
|
def __init__(self):
|
|
client = docker.Client(base_url=DOCKER_BASE_URL)
|
|
all_containers = client.containers()
|
|
client.close()
|
|
|
|
self.containers = []
|
|
self.all_containers = []
|
|
self.backup_container = None
|
|
|
|
# Read all containers and find this container
|
|
for entry in all_containers:
|
|
container = Container(entry)
|
|
|
|
if container.id.startswith(os.environ['HOSTNAME']):
|
|
self.backup_container = container
|
|
else:
|
|
self.all_containers.append(container)
|
|
|
|
if not self.backup_container:
|
|
raise ValueError("Cannot find metadata for backup container")
|
|
|
|
for container in self.all_containers:
|
|
# Weed out containers not beloging to this project.
|
|
if container.project_name == self.backup_container.project_name:
|
|
# Keep only containers with backup enabled
|
|
# and not oneoffs (started manually with run or similar)
|
|
if container.backup_enabled and not container.is_oneoff:
|
|
self.containers.append(container)
|
|
|
|
def backup_volumes(self):
|
|
return self.backup_container.mounts
|
|
|
|
def gen_volumes(self, volume_type):
|
|
"""Generator yielding volumes of a specific type"""
|
|
for cont in self.containers:
|
|
for mnt in cont.mounts:
|
|
if mnt.type == volume_type:
|
|
yield mnt
|
|
|
|
def volume_mounts(self):
|
|
"""Docker volumes"""
|
|
return set(mnt for mnt in self.gen_volumes(VOLUME_TYPE_VOLUME))
|
|
|
|
def bind_mounts(self):
|
|
"""Host mapped volumes"""
|
|
return set(mnt for mnt in self.gen_volumes(VOLUME_TYPE_BIND))
|
|
|
|
def print_all(self):
|
|
print("Backup container:")
|
|
print(json.dumps(self.backup_container.to_dict(), indent=2))
|
|
|
|
print("All containers:")
|
|
print(json.dumps([cnt.to_dict() for cnt in self.containers], indent=2))
|