1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
# This file is part of cloud-init. See LICENSE file for license information.
"""Base LXD instance."""
from tests.cloud_tests.instances import base
from tests.cloud_tests import util
class LXDInstance(base.Instance):
"""LXD container backed instance."""
platform_name = "lxd"
def __init__(self, platform, name, properties, config, features,
pylxd_container):
"""Set up instance.
@param platform: platform object
@param name: hostname of instance
@param properties: image properties
@param config: image config
@param features: supported feature flags
"""
self._pylxd_container = pylxd_container
super(LXDInstance, self).__init__(
platform, name, properties, config, features)
@property
def pylxd_container(self):
"""Property function."""
self._pylxd_container.sync()
return self._pylxd_container
def execute(self, command, stdout=None, stderr=None, env={},
rcs=None, description=None):
"""Execute command in instance, recording output, error and exit code.
Assumes functional networking and execution as root with the
target filesystem being available at /.
@param command: the command to execute as root inside the image
@param stdout: file handler to write output
@param stderr: file handler to write error
@param env: environment variables
@param rcs: allowed return codes from command
@param description: purpose of command
@return_value: tuple containing stdout data, stderr data, exit code
"""
# ensure instance is running and execute the command
self.start()
res = self.pylxd_container.execute(command, environment=env)
# get out, exit and err from pylxd return
if hasattr(res, 'exit_code'):
# pylxd 2.2 returns ContainerExecuteResult, named tuple of
# (exit_code, out, err)
(exit, out, err) = res
else:
# pylxd 2.1.3 and earlier only return out and err, no exit
# LOG.warning('using pylxd version < 2.2')
(out, err) = res
exit = 0
# write data to file descriptors if needed
if stdout:
stdout.write(out)
if stderr:
stderr.write(err)
# if the command exited with a code not allowed in rcs, then fail
if exit not in (rcs if rcs else (0,)):
error_desc = ('Failed command to: {}'.format(description)
if description else None)
raise util.InTargetExecuteError(
out, err, exit, command, self.name, error_desc)
return (out, err, exit)
def read_data(self, remote_path, decode=False):
"""Read data from instance filesystem.
@param remote_path: path in instance
@param decode: return as string
@return_value: data as str or bytes
"""
data = self.pylxd_container.files.get(remote_path)
return data.decode() if decode and isinstance(data, bytes) else data
def write_data(self, remote_path, data):
"""Write data to instance filesystem.
@param remote_path: path in instance
@param data: data to write, either str or bytes
"""
self.pylxd_container.files.put(remote_path, data)
def console_log(self):
"""Console log.
@return_value: bytes of this instance’s console
"""
raise NotImplementedError
def reboot(self, wait=True):
"""Reboot instance."""
self.shutdown(wait=wait)
self.start(wait=wait)
def shutdown(self, wait=True):
"""Shutdown instance."""
if self.pylxd_container.status != 'Stopped':
self.pylxd_container.stop(wait=wait)
def start(self, wait=True, wait_for_cloud_init=False):
"""Start instance."""
if self.pylxd_container.status != 'Running':
self.pylxd_container.start(wait=wait)
if wait:
self._wait_for_system(wait_for_cloud_init)
def freeze(self):
"""Freeze instance."""
if self.pylxd_container.status != 'Frozen':
self.pylxd_container.freeze(wait=True)
def unfreeze(self):
"""Unfreeze instance."""
if self.pylxd_container.status == 'Frozen':
self.pylxd_container.unfreeze(wait=True)
def destroy(self):
"""Clean up instance."""
self.unfreeze()
self.shutdown()
self.pylxd_container.delete(wait=True)
if self.platform.container_exists(self.name):
raise OSError('container {} was not properly removed'
.format(self.name))
super(LXDInstance, self).destroy()
# vi: ts=4 expandtab
|
