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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
|
# Copyright (C) 2013 Codethink Limited
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
import cliapp
import gzip
import os
import shutil
import stat
import tarfile
import tempfile
import urlparse
import uuid
import morphlib
# UGLY HACK: We need to re-use some code from the branch and merge
# plugin, so we import and instantiate that plugin. This needs to
# be fixed by refactoring the codebase so the shared code is in
# morphlib, not in a plugin. However, this hack lets us re-use
# code without copying it.
import morphlib.plugins.branch_and_merge_plugin
class DeployPlugin(cliapp.Plugin):
def enable(self):
self.app.add_subcommand(
'deploy', self.deploy,
arg_synopsis='TYPE SYSTEM LOCATION [KEY=VALUE]')
self.other = \
morphlib.plugins.branch_and_merge_plugin.BranchAndMergePlugin()
self.other.app = self.app
def disable(self):
pass
def deploy(self, args):
'''Deploy a built system image.
Command line arguments:
* `TYPE` is the type of deployment: to a raw disk image,
VirtualBox, or something else. See below.
* `SYSTEM` is the name of the system morphology to deploy.
* `LOCATION` is where the deployed system should end up at. The
syntax depends on the deployment type. See below.
* `KEY=VALUE` is a configuration parameter to pass onto the
configuration extension. See below.
Morph can deploy a system image. The deployment mechanism is
quite flexible, and can be extended by the user. "Deployment"
here is quite a general concept: it covers anything where a system
image is taken, configured, and then put somewhere where it can
be run.
`TYPE` specifies the exact way in which the deployment happens.
Morph provides four deployment types:
* `rawdisk` where Morph builds a raw disk image at `LOCATION`,
and sets up the image with a bootloader and configuration
so that it can be booted. Disk size is set with `DISK_SIZE`
(see below).
* `virtualbox-ssh` where Morph creates a VirtualBox disk image,
and creates a new virtual machine on a remote host, accessed
over ssh. Disk and RAM size are set with `DISK_SIZE` and
`RAM_SIZE` (see below).
* `kvm`, which is similar to `virtualbox-ssh`, but uses libvirt
and KVM instead of VirtualBox. Disk and RAM size are set with
`DISK_SIZE` and `RAM_SIZE` (see below).
* `nfsboot` where Morph creates a system to be booted over
a network
The following `KEY=VALUE` parameters are supported for all
deployment types:
* `DISK_SIZE=X` to set the size of the disk image. `X`
should use a suffix of `K`, `M`, or `G` (in upper or lower
case) to indicate kilo-, mega-, or gigabytes. For example,
`DISK_SIZE=100G` would create a 100 gigabyte disk image. **This
parameter is mandatory**.
* `RAM_SIZE=X` to set the size of virtual RAM for the virtual
machine. `X` is interpreted in the same was as `DISK_SIZE`,
and defaults to `1G`.
The `kvm` and `virtualbox-ssh` deployment types support an
additional parameter:
* `AUTOSTART=<VALUE>` - allowed values are `yes` and `no`
(default)
The syntax of the `LOCATION` depends on the deployment types. The
deployment types provided by Morph use the following syntaxes:
* `rawdisk`: pathname to the disk image to be created; for
example, `/home/alice/testsystem.img`
* `virtualbox-ssh` and `kvm`: a custom URL scheme that
provides the target host machine (the one that runs
VirtualBox or `kvm`), the name of the new virtual machine,
and the location on the target host of the virtual disk
file. The target host is accessed over ssh. For example,
`vbox+ssh://alice@192.168.122.1/testsys/home/alice/testsys.vdi`
or `kvm+ssh://alice@192.168.122.1/testsys/home/alice/testys.img`
where
* `alice@192.168.122.1` is the target as given to ssh,
**from within the development host** (which may be
different from the target host's normal address);
* `testsys` is the new VM's name;
* `/home/alice/testsys.vdi` and `/home/alice/testys.img` are
the pathnames of the disk image files on the target host.
For the `nfsboot` write extension,
* LOCATION is the address of the nfsboot server. (Note this
is just the _address_ of the trove, _not_ `user@...`, since
`root@` will automatically be prepended to the server address.)
* the following KEY=VALUE PAIRS are mandatory
* NFSBOOT_CONFIGURE=yes (or any non-empty value). This
enables the `nfsboot` configuration extension (see
below) which MUST be used when using the `nfsboot`
write extension.
* HOSTNAME=<STRING> a unique identifier for that system's
`nfs` root when it's deployed on the nfsboot server - the
extension creates a directory with that name for the `nfs`
root, and stores kernels by that name for the tftp server.
* the following KEY=VALUE PAIRS are optional
* VERSION_LABEL=<STRING> - set the name of the system
version being deployed, when upgrading. Defaults to
"factory".
An example command line using `morph deploy with the nfsboot`
type is
morph deploy nfsboot devel-system-x86_64-generic \
customer-trove \
NFSBOOT_CONFIGURE=yes \
HOSTNAME=test-deployment-1 \
VERSION_LABEL=inital-test
Each deployment type is implemented by a **write extension**. The
ones provided by Morph are listed above, but users may also
create their own by adding them in the same git repository
and branch as the system morphology. A write extension is a
script that does whatever is needed for the deployment. A write
extension is passed two command line parameters: the name of an
unpacked directory tree that contains the system files (after
configuration, see below), and the `LOCATION` argument. Any
additional `KEY=VALUE` arguments given to `morph deploy` are
set as environment variables when the write extension runs.
Regardless of the type of deployment, the image may be
configured for a specific deployment by using **configuration
extensions**. The extensions are listed in the system morphology
file:
...
configuration-extensions:
- set-hostname
The above specifies that the extension `set-hostname` is to
be run. Morph will run all the configuration extensions listed
in the system morphology, and no others. (This way, configuration
is more easily tracked in git.)
Configuration extensions are scripts that get the unpacked
directory tree of the system as their parameter, and do whatever
is needed to configure the tree.
Morph provides the following configuration extension built in:
* `set-hostname` sets the hostname of the system to the value
of the `HOSTNAME` variable.
* `nfsboot` configures the system for nfsbooting. This MUST
be used when deploying with the `nfsboot` write extension.
Any `KEY=VALUE` parameters given to `morph deploy` are set as
environment variables when either the configuration or the write
extension runs.
'''
if len(args) < 3:
raise cliapp.AppException(
'Too few arguments to deploy command (see help)')
# Raise an exception if there is not enough space in tempdir
# / for the path and 0 for the minimum size is a no-op
# it exists because it is complicated to check the available
# disk space given dirs may be on the same device
morphlib.util.check_disk_available(
self.app.settings['tempdir'],
self.app.settings['tempdir-min-space'],
'/', 0)
deployment_type = args[0]
system_name = args[1]
location = args[2]
env_vars = args[3:]
# Deduce workspace and system branch and branch root repository.
workspace = self.other.deduce_workspace()
branch, branch_dir = self.other.deduce_system_branch()
branch_root = self.other.get_branch_config(branch_dir, 'branch.root')
branch_uuid = self.other.get_branch_config(branch_dir, 'branch.uuid')
# Generate a UUID for the build.
build_uuid = uuid.uuid4().hex
build_command = morphlib.buildcommand.BuildCommand(self.app)
build_command = self.app.hookmgr.call('new-build-command',
build_command)
push = self.app.settings['push-build-branches']
self.app.status(msg='Starting build %(uuid)s', uuid=build_uuid)
self.app.status(msg='Collecting morphologies involved in '
'building %(system)s from %(branch)s',
system=system_name, branch=branch)
# Find system branch root repository on the local disk.
root_repo = self.other.get_branch_config(branch_dir, 'branch.root')
root_repo_dir = self.other.find_repository(branch_dir, root_repo)
# Get repositories of morphologies involved in building this system
# from the current system branch.
build_repos = self.other.get_system_build_repos(
branch, branch_dir, branch_root, system_name)
# Generate temporary build ref names for all these repositories.
self.other.generate_build_ref_names(build_repos, branch_uuid)
# Create the build refs for all these repositories and commit
# all uncommitted changes to them, updating all references
# to system branch refs to point to the build refs instead.
self.other.update_build_refs(build_repos, branch, build_uuid, push)
if push:
self.other.push_build_refs(build_repos)
build_branch_root = branch_root
else:
dirname = build_repos[branch_root]['dirname']
build_branch_root = urlparse.urljoin('file://', dirname)
# Run the build.
build_ref = build_repos[branch_root]['build-ref']
srcpool = build_command.create_source_pool(
build_branch_root,
build_ref,
system_name + '.morph')
artifact = build_command.resolve_artifacts(srcpool)
if push:
self.other.delete_remote_build_refs(build_repos)
# Unpack the artifact (tarball) to a temporary directory.
self.app.status(msg='Unpacking system for configuration')
system_tree = tempfile.mkdtemp(
dir=os.path.join(self.app.settings['tempdir'], 'deployments'))
if build_command.lac.has(artifact):
f = build_command.lac.get(artifact)
elif build_command.rac.has(artifact):
f = build_command.rac.get(artifact)
else:
raise cliapp.AppException('Deployment failed as system is not yet'
' built.\nPlease ensure system is built'
' before deployment.')
tf = tarfile.open(fileobj=f)
tf.extractall(path=system_tree)
self.app.status(
msg='System unpacked at %(system_tree)s',
system_tree=system_tree)
# Set up environment for running extensions.
env = dict(os.environ)
for spec in env_vars:
name, value = spec.split('=', 1)
if name in env:
raise morphlib.Error(
'%s is already set in the enviroment' % name)
env[name] = value
if 'TMPDIR' not in env:
# morphlib.app already took care of ensuring the tempdir setting
# is good, so use it if we don't have one already set.
env['TMPDIR'] = os.path.join(self.app.settings['tempdir'],
'deployments')
# Run configuration extensions.
self.app.status(msg='Configure system')
names = artifact.source.morphology['configuration-extensions']
for name in names:
self._run_extension(
root_repo_dir,
build_ref,
name,
'.configure',
[system_tree],
env)
# Run write extension.
self.app.status(msg='Writing to device')
self._run_extension(
root_repo_dir,
build_ref,
deployment_type,
'.write',
[system_tree, location],
env)
# Cleanup.
self.app.status(msg='Cleaning up')
shutil.rmtree(system_tree)
self.app.status(msg='Finished deployment')
def _run_extension(self, repo_dir, ref, name, kind, args, env):
'''Run an extension.
The ``kind`` should be either ``.configure`` or ``.write``,
depending on the kind of extension that is sought.
The extension is found either in the git repository of the
system morphology (repo, ref), or with the Morph code.
'''
# Look for extension in the system morphology's repository.
ext = self._cat_file(repo_dir, ref, name + kind)
if ext is None:
# Not found: look for it in the Morph code.
code_dir = os.path.dirname(morphlib.__file__)
ext_filename = os.path.join(code_dir, 'exts', name + kind)
if not os.path.exists(ext_filename):
raise morphlib.Error(
'Could not find extension %s%s' % (name, kind))
if not self._is_executable(ext_filename):
raise morphlib.Error(
'Extension not executable: %s' % ext_filename)
delete_ext = False
else:
# Found it in the system morphology's repository.
fd, ext_filename = tempfile.mkstemp()
os.write(fd, ext)
os.close(fd)
os.chmod(ext_filename, 0700)
delete_ext = True
self.app.status(msg='Running extension %(name)s%(kind)s',
name=name, kind=kind)
self.app.runcmd(
[ext_filename] + args,
['sh', '-c', 'while read l; do echo `date "+%F %T"` $l; done'],
env=env, stdout=None, stderr=None)
if delete_ext:
os.remove(ext_filename)
def _is_executable(self, filename):
st = os.stat(filename)
mask = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
return (stat.S_IMODE(st.st_mode) & mask) != 0
def _cat_file(self, repo_dir, ref, pathname):
'''Retrieve contents of a file from a git repository.'''
argv = ['git', 'cat-file', 'blob', '%s:%s' % (ref, pathname)]
try:
return self.app.runcmd(argv, cwd=repo_dir)
except cliapp.AppException:
return None
|