class Snapshot(model.Model):
"""A container snapshot."""
name = model.Attribute()
stateful = model.Attribute()
container = model.Parent()
@property
def api(self):
return self.client.api.containers[self.container.name].snapshots[
self.name]
@classmethod
def get(cls, client, container, name):
try:
response = client.api.containers[
container.name].snapshots[name].get()
except exceptions.LXDAPIException as e:
if e.response.status_code == 404:
raise exceptions.NotFound()
raise
snapshot = cls(client,
container=container,
**response.json()['metadata'])
# Snapshot names are namespaced in LXD, as
# container-name/snapshot-name. We hide that implementation
# detail.
snapshot.name = snapshot.name.split('/')[-1]
return snapshot
@classmethod
def all(cls, client, container):
response = client.api.containers[container.name].snapshots.get()
return [
cls(client, name=snapshot.split('/')[-1], container=container)
for snapshot in response.json()['metadata']
]
@classmethod
def create(cls, client, container, name, stateful=False, wait=False):
response = client.api.containers[container.name].snapshots.post(
json={
'name': name,
'stateful': stateful
})
snapshot = cls(client, container=container, name=name)
if wait:
Operation.wait_for_operation(client, response.json()['operation'])
return snapshot
def rename(self, new_name, wait=False):
"""Rename a snapshot."""
response = self.api.post(json={'name': new_name})
if wait:
Operation.wait_for_operation(self.client,
response.json()['operation'])
self.name = new_name
class Item(model.Model):
"""A fake model."""
name = model.Attribute(readonly=True)
age = model.Attribute(int)
data = model.Attribute()
@property
def api(self):
return self.client.api.items[self.name]
class Profile(model.Model):
"""A LXD profile."""
name = model.Attribute(readonly=True)
description = model.Attribute()
config = model.Attribute()
devices = model.Attribute()
@classmethod
def get(cls, client, name):
"""Get a profile."""
try:
response = client.api.profiles[name].get()
except exceptions.LXDAPIException as e:
if e.response.status_code == 404:
raise exceptions.NotFound()
raise
return cls(client, **response.json()['metadata'])
@classmethod
def all(cls, client):
"""Get all profiles."""
response = client.api.profiles.get()
profiles = []
for url in response.json()['metadata']:
name = url.split('/')[-1]
profiles.append(cls(client, name=name))
return profiles
@classmethod
def create(cls, client, name, config=None, devices=None):
"""Create a profile."""
profile = {'name': name}
if config is not None:
profile['config'] = config
if devices is not None:
profile['devices'] = devices
try:
client.api.profiles.post(json=profile)
except exceptions.LXDAPIException as e:
raise exceptions.CreateFailed(e.response.json())
return cls.get(client, name)
@property
def api(self):
return self.client.api.profiles[self.name]
def rename(self, new_name):
"""Rename the profile."""
self.api.post(json={'name': new_name})
return Profile.get(self.client, new_name)
class Certificate(model.Model):
"""A LXD certificate."""
certificate = model.Attribute()
fingerprint = model.Attribute()
type = model.Attribute()
@classmethod
def get(cls, client, fingerprint):
"""Get a certificate by fingerprint."""
response = client.api.certificates[fingerprint].get()
return cls(client, **response.json()['metadata'])
@classmethod
def all(cls, client):
"""Get all certificates."""
response = client.api.certificates.get()
certs = []
for cert in response.json()['metadata']:
fingerprint = cert.split('/')[-1]
certs.append(cls(client, fingerprint=fingerprint))
return certs
@classmethod
def create(cls, client, password, cert_data):
"""Create a new certificate."""
cert = x509.load_pem_x509_certificate(cert_data, default_backend())
base64_cert = cert.public_bytes(Encoding.PEM).decode('utf-8')
# STRIP OUT CERT META "-----BEGIN CERTIFICATE-----"
base64_cert = '\n'.join(base64_cert.split('\n')[1:-2])
data = {
'type': 'client',
'certificate': base64_cert,
'password': password,
}
client.api.certificates.post(json=data)
# XXX: rockstar (08 Jun 2016) - Please see the open lxd bug here:
# https://github.com/lxc/lxd/issues/2092
fingerprint = binascii.hexlify(cert.fingerprint(
hashes.SHA256())).decode('utf-8')
return cls.get(client, fingerprint)
@property
def api(self):
return self.client.api.certificates[self.fingerprint]
class Network(model.Model):
"""A LXD network."""
name = model.Attribute()
type = model.Attribute()
used_by = model.Attribute()
@classmethod
def get(cls, client, name):
"""Get a network by name."""
response = client.api.networks[name].get()
network = cls(client, **response.json()['metadata'])
return network
@classmethod
def all(cls, client):
"""Get all networks."""
response = client.api.networks.get()
networks = []
for url in response.json()['metadata']:
name = url.split('/')[-1]
networks.append(cls(client, name=name))
return networks
@property
def api(self):
return self.client.api.networks[self.name]
def save(self, wait=False):
"""Save is not available for networks."""
raise NotImplementedError('save is not implemented')
def delete(self):
"""Delete is not available for networks."""
raise NotImplementedError('delete is not implemented')
class Container(model.Model):
"""An LXD Container.
This class is not intended to be used directly, but rather to be used
via `Client.containers.create`.
"""
architecture = model.Attribute()
config = model.Attribute()
created_at = model.Attribute()
devices = model.Attribute()
ephemeral = model.Attribute()
expanded_config = model.Attribute()
expanded_devices = model.Attribute()
name = model.Attribute(readonly=True)
profiles = model.Attribute()
status = model.Attribute(readonly=True)
status_code = model.Attribute(readonly=True)
stateful = model.Attribute(readonly=True)
snapshots = model.Manager()
files = model.Manager()
@property
def api(self):
return self.client.api.containers[self.name]
class FilesManager(object):
"""A pseudo-manager for namespacing file operations."""
def __init__(self, client, container):
self._client = client
self._container = container
def put(self, filepath, data):
response = self._client.api.containers[
self._container.name].files.post(params={'path': filepath},
data=data)
return response.status_code == 200
def get(self, filepath):
try:
response = self._client.api.containers[
self._container.name].files.get(params={'path': filepath})
except exceptions.LXDAPIException as e:
# LXD 2.0.3+ return 404, not 500,
if e.response.status_code in (500, 404):
raise exceptions.NotFound()
raise
return response.content
@classmethod
def get(cls, client, name):
"""Get a container by name."""
try:
response = client.api.containers[name].get()
except exceptions.LXDAPIException as e:
if e.response.status_code == 404:
raise exceptions.NotFound()
raise
container = cls(client, **response.json()['metadata'])
return container
@classmethod
def all(cls, client):
"""Get all containers.
Containers returned from this method will only have the name
set, as that is the only property returned from LXD. If more
information is needed, `Container.sync` is the method call
that should be used.
"""
response = client.api.containers.get()
containers = []
for url in response.json()['metadata']:
name = url.split('/')[-1]
containers.append(cls(client, name=name))
return containers
@classmethod
def create(cls, client, config, wait=False):
"""Create a new container config."""
try:
response = client.api.containers.post(json=config)
except exceptions.LXDAPIException as e:
raise exceptions.CreateFailed(e.response)
if wait:
Operation.wait_for_operation(client, response.json()['operation'])
return cls(client, name=config['name'])
def __init__(self, *args, **kwargs):
super(Container, self).__init__(*args, **kwargs)
self.snapshots = managers.SnapshotManager(self.client, self)
self.files = self.FilesManager(self.client, self)
# XXX: rockstar (28 Mar 2016) - This method was named improperly
# originally. It's being kept here for backwards compatibility.
reload = deprecated(
"Container.reload is deprecated. Please use Container.sync")(
model.Model.sync)
def rename(self, name, wait=False):
"""Rename a container."""
response = self.api.post(json={'name': name})
if wait:
Operation.wait_for_operation(self.client,
response.json()['operation'])
self.name = name
def _set_state(self, state, timeout=30, force=True, wait=False):
response = self.api.state.put(json={
'action': state,
'timeout': timeout,
'force': force
})
if wait:
Operation.wait_for_operation(self.client,
response.json()['operation'])
self.sync()
def state(self):
response = self.api.state.get()
state = ContainerState(**response.json()['metadata'])
return state
def start(self, timeout=30, force=True, wait=False):
"""Start the container."""
return self._set_state('start',
timeout=timeout,
force=force,
wait=wait)
def stop(self, timeout=30, force=True, wait=False):
"""Stop the container."""
return self._set_state('stop', timeout=timeout, force=force, wait=wait)
def restart(self, timeout=30, force=True, wait=False):
"""Restart the container."""
return self._set_state('restart',
timeout=timeout,
force=force,
wait=wait)
def freeze(self, timeout=30, force=True, wait=False):
"""Freeze the container."""
return self._set_state('freeze',
timeout=timeout,
force=force,
wait=wait)
def unfreeze(self, timeout=30, force=True, wait=False):
"""Unfreeze the container."""
return self._set_state('unfreeze',
timeout=timeout,
force=force,
wait=wait)
@deprecated(
'Container.snapshot is deprecated. Please use Container.snapshots.create'
) # NOQA
def snapshot(self, name, stateful=False, wait=False): # pragma: no cover
"""Take a snapshot of the container."""
self.snapshots.create(name, stateful, wait)
@deprecated(
'Container.list_snapshots is deprecated. Please use Container.snapshots.all'
) # NOQA
def list_snapshots(self): # pragma: no cover
"""List all container snapshots."""
return [s.name for s in self.snapshots.all()]
@deprecated(
'Container.rename_snapshot is deprecated. Please use Snapshot.rename'
) # NOQA
def rename_snapshot(self, old, new, wait=False): # pragma: no cover
"""Rename a snapshot."""
snapshot = self.snapshots.get(old)
snapshot.rename(new, wait=wait)
@deprecated(
'Container.delete_snapshot is deprecated. Please use Snapshot.delete'
) # NOQA
def delete_snapshot(self, name, wait=False): # pragma: no cover
"""Delete a snapshot."""
snapshot = self.snapshots.get(name)
snapshot.delete(wait=wait)
@deprecated(
'Container.get_file is deprecated. Please use Container.files.get'
) # NOQA
def get_file(self, filepath): # pragma: no cover
"""Get a file from the container."""
return self.files.get(filepath)
@deprecated(
'Container.put_file is deprecated. Please use Container.files.put'
) # NOQA
def put_file(self, filepath, data): # pragma: no cover
"""Put a file on the container."""
return self.files.put(filepath, data)
def execute(self, commands, environment={}):
"""Execute a command on the container."""
if isinstance(commands, six.string_types):
raise TypeError("First argument must be a list.")
response = self.api['exec'].post(
json={
'command': commands,
'environment': environment,
'wait-for-websocket': True,
'interactive': False,
})
fds = response.json()['metadata']['metadata']['fds']
operation_id = response.json()['operation'].split('/')[-1]
parsed = parse.urlparse(
self.client.api.operations[operation_id].websocket._api_endpoint)
manager = WebSocketManager()
stdin = _StdinWebsocket(manager, self.client.websocket_url)
stdin.resource = '{}?secret={}'.format(parsed.path, fds['0'])
stdin.connect()
stdout = _CommandWebsocketClient(manager, self.client.websocket_url)
stdout.resource = '{}?secret={}'.format(parsed.path, fds['1'])
stdout.connect()
stderr = _CommandWebsocketClient(manager, self.client.websocket_url)
stderr.resource = '{}?secret={}'.format(parsed.path, fds['2'])
stderr.connect()
manager.start()
while True: # pragma: no cover
for websocket in manager.websockets.values():
if not websocket.terminated:
break
else:
break
time.sleep(1)
return stdout.data, stderr.data
def migrate(self, new_client, wait=False):
"""Migrate a container.
Destination host information is contained in the client
connection passed in.
If the container is running, it either must be shut down
first or criu must be installed on the source and destination
machines.
"""
self.sync() # Make sure the object isn't stale
response = self.api.post(json={'migration': True})
operation = self.client.operations.get(response.json()['operation'])
operation_url = self.client.api.operations[operation.id]._api_endpoint
secrets = response.json()['metadata']['metadata']
cert = self.client.host_info['environment']['certificate']
config = {
'name': self.name,
'architecture': self.architecture,
'config': self.config,
'devices': self.devices,
'epehemeral': self.ephemeral,
'default': self.profiles,
'source': {
'type': 'migration',
'operation': operation_url,
'mode': 'pull',
'certificate': cert,
'secrets': secrets,
}
}
return new_client.containers.create(config, wait=wait)
class Image(model.Model):
"""A LXD Image."""
aliases = model.Attribute()
auto_update = model.Attribute()
architecture = model.Attribute()
cached = model.Attribute()
created_at = model.Attribute()
expires_at = model.Attribute()
filename = model.Attribute()
fingerprint = model.Attribute()
last_used_at = model.Attribute()
properties = model.Attribute()
public = model.Attribute()
size = model.Attribute()
uploaded_at = model.Attribute()
@property
def api(self):
return self.client.api.images[self.fingerprint]
@classmethod
def get(cls, client, fingerprint):
"""Get an image."""
try:
response = client.api.images[fingerprint].get()
except exceptions.LXDAPIException as e:
if e.response.status_code == 404:
raise exceptions.NotFound()
raise
image = cls(client, **response.json()['metadata'])
return image
@classmethod
def all(cls, client):
"""Get all images."""
response = client.api.images.get()
images = []
for url in response.json()['metadata']:
fingerprint = url.split('/')[-1]
images.append(cls(client, fingerprint=fingerprint))
return images
@classmethod
def create(cls, client, image_data, public=False, wait=False):
"""Create an image."""
fingerprint = hashlib.sha256(image_data).hexdigest()
headers = {}
if public:
headers['X-LXD-Public'] = '1'
try:
response = client.api.images.post(data=image_data, headers=headers)
except exceptions.LXDAPIException as e:
raise exceptions.CreateFailed(e.response.json())
if wait:
Operation.wait_for_operation(client, response.json()['operation'])
return cls(client, fingerprint=fingerprint)
def export(self):
"""Export the image."""
try:
response = self.api.export.get()
except exceptions.LXDAPIException as e:
if e.response.status_code == 404:
raise exceptions.NotFound()
raise
return response.content