Initial commit
commit
6dbc137b3a
|
|
@ -0,0 +1,4 @@
|
|||
/dist/
|
||||
*.egg-info/
|
||||
__pycache__/
|
||||
*.py[co]
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
from setuptools import find_packages, setup
|
||||
|
||||
setup(
|
||||
name='mkvm',
|
||||
version='0.1',
|
||||
description='Virtual Machine Image Creator',
|
||||
author='Dustin C. Hatch',
|
||||
author_email='dustin@hatch.name',
|
||||
url='http://bitbucket.org/AdmiralNemo/imgmaker',
|
||||
license='GPL-3+',
|
||||
packages=find_packages('src'),
|
||||
package_dir={'': 'src'},
|
||||
entry_points={
|
||||
'console_scripts': [
|
||||
'mkvm=mkvm.mkvm:main',
|
||||
],
|
||||
},
|
||||
)
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
import glob
|
||||
import logging
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
CUSTOM_SCRIPT_ENV = {
|
||||
'PATH': os.pathsep.join((
|
||||
'/usr/local/sbin',
|
||||
'/usr/sbin',
|
||||
'/sbin',
|
||||
'/usr/local/bin',
|
||||
'/usr/bin',
|
||||
'/bin',
|
||||
)),
|
||||
}
|
||||
|
||||
FIX_LINKS = [
|
||||
('/etc/mtab', '/proc/self/mounts'),
|
||||
('/etc/resolv.conf', '/run/resolv.conf'),
|
||||
('/etc/ntp.conf', '/run/ntp.conf'),
|
||||
]
|
||||
|
||||
|
||||
def fix_runtime_symlinks(mountpoint):
|
||||
for link, target in FIX_LINKS:
|
||||
path = os.path.join(mountpoint, link[1:])
|
||||
if os.path.exists(path):
|
||||
os.unlink(path)
|
||||
os.symlink(target, path)
|
||||
|
||||
|
||||
def set_timezone(mountpoint, timezone):
|
||||
path = os.path.join(mountpoint, 'etc/localtime')
|
||||
if os.path.exists(path):
|
||||
os.unlink(path)
|
||||
os.symlink(os.path.join('/usr/share/zoneinfo', timezone), path)
|
||||
|
||||
|
||||
def set_hostname(mountpoint, hostname):
|
||||
hostname = hostname.split('.')[0]
|
||||
path = os.path.join(mountpoint, 'etc/conf.d/hostname')
|
||||
with open(path) as f:
|
||||
lines = f.readlines()
|
||||
with open(path, 'w') as f:
|
||||
for line in lines:
|
||||
if line.lstrip().startswith('hostname='):
|
||||
f.write('hostname="{}"\n'.format(hostname))
|
||||
else:
|
||||
f.write(line)
|
||||
|
||||
|
||||
def run_custom_script(mountpoint, script):
|
||||
cmd = ['chroot', mountpoint, '/bin/sh']
|
||||
env = CUSTOM_SCRIPT_ENV.copy()
|
||||
p = subprocess.Popen(cmd, env=env, stdin=subprocess.PIPE,
|
||||
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
out, err = p.communicate(script.encode())
|
||||
for line in out.decode().splitlines():
|
||||
log.info(line.strip())
|
||||
for line in err.decode().splitlines():
|
||||
log.error(line.strip())
|
||||
if p.returncode != 0:
|
||||
log.error('Custom script exited with return '
|
||||
'code {}'.format(p.returncode))
|
||||
|
||||
|
||||
def configure(vm):
|
||||
fix_runtime_symlinks(vm.mountpoint)
|
||||
if vm.timezone:
|
||||
set_timezone(vm.mountpoint, vm.timezone)
|
||||
if vm.fqdn:
|
||||
set_hostname(vm.mountpoint, vm.fqdn)
|
||||
if vm.customize:
|
||||
run_custom_script(vm.mountpoint, vm.customize)
|
||||
|
||||
|
||||
def inject_ssh_keys(filename, *keys):
|
||||
log.debug('Injecting SSH keys into {}'.format(filename))
|
||||
keys = set(keys)
|
||||
try:
|
||||
keys.remove(None)
|
||||
except KeyError:
|
||||
pass
|
||||
else:
|
||||
keys.update(glob.glob(os.path.expanduser('~/.ssh/id_*.pub')))
|
||||
|
||||
dirname = os.path.dirname(filename)
|
||||
if not os.path.isdir(dirname):
|
||||
os.makedirs(dirname)
|
||||
|
||||
with open(filename, 'a') as f:
|
||||
for key in keys:
|
||||
log.info('Adding SSH key {}'.format(key))
|
||||
with open(key) as k:
|
||||
f.write(k.read())
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
#!/usr/bin/env python3
|
||||
from . import configure, stage3, storage, virt, vmdesc
|
||||
import argparse
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
|
||||
|
||||
log = logging.getLogger('mkvm')
|
||||
|
||||
|
||||
def parse_args():
|
||||
parser = argparse.ArgumentParser()
|
||||
|
||||
gstage = parser.add_argument_group('stage3 tarball options')
|
||||
gstage.add_argument('--arch',
|
||||
help='Architecture to use when fetching a stage3 '
|
||||
'tarball')
|
||||
gstage.add_argument('--subtype',
|
||||
help='stage3 subtype/profile (e.g. nomultilib)')
|
||||
gstagefile = gstage.add_mutually_exclusive_group(required=True)
|
||||
gstagefile.add_argument('--latest', action='store_true', default=False,
|
||||
help='Fetch the latest stage3 tarball, optionally '
|
||||
'selecting an alternate flavor such as '
|
||||
'nomultilib or hardened')
|
||||
gstagefile.add_argument('--stage', '-s', metavar='FILENAME',
|
||||
help='stage3 tarball to install')
|
||||
|
||||
gfetch = parser.add_argument_group('download options')
|
||||
gfetch.add_argument('--mirror', metavar='URI',
|
||||
help='Base URI of download mirror')
|
||||
gfetch.add_argument('--cache-dir', metavar='PATH',
|
||||
help='Cache location for fetched stage3 tarballs')
|
||||
|
||||
gvirt = parser.add_argument_group('libvirt options')
|
||||
gvirt.add_argument('--connect', '-c', metavar='URI', dest='uri',
|
||||
help='libvirt connection URI')
|
||||
gvirt.add_argument('--pool', '-p', default='default',
|
||||
help='storage pool for the new disk')
|
||||
|
||||
parser.add_argument('--verbose', '-v', action='store_true', default=False,
|
||||
help='Print additional messages')
|
||||
parser.add_argument('--inject-ssh-key', '-i', action='append', nargs='?',
|
||||
metavar='FILENAME',
|
||||
help='Authorize SSH public key in the VM')
|
||||
parser.add_argument('--no-autostart', action='store_false', default=True,
|
||||
dest='autostart',
|
||||
help='Do not automatically start the new VM')
|
||||
parser.add_argument('description',
|
||||
help='Path to VM description document')
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
def main():
|
||||
args = parse_args()
|
||||
|
||||
# prevent libvirt from writing error messages to stderr
|
||||
sys.stderr.flush()
|
||||
newstderr = os.dup(sys.stderr.fileno())
|
||||
devnull = os.open(os.devnull, os.O_WRONLY)
|
||||
os.dup2(devnull, sys.stderr.fileno())
|
||||
os.close(devnull)
|
||||
sys.stderr = os.fdopen(newstderr, 'w')
|
||||
|
||||
logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO)
|
||||
|
||||
vm = vmdesc.VirtualMachine.from_yaml(args.description)
|
||||
v = virt.Virt(args.uri)
|
||||
|
||||
if args.latest:
|
||||
try:
|
||||
fetcher = stage3.Fetcher(args.cache_dir)
|
||||
stagetbz = fetcher.fetch_stage(args.arch, args.subtype)
|
||||
fetcher.verify(stagetbz + '.DIGESTS.asc')
|
||||
except KeyboardInterrupt:
|
||||
print('')
|
||||
raise SystemExit(os.EX_TEMPFAIL)
|
||||
except (OSError, stage3.FetchError, stage3.VerifyError) as e:
|
||||
log.error('Failed to fetch stage3 tarball: {}'.format(e))
|
||||
raise SystemExit(os.EX_UNAVAILABLE)
|
||||
else:
|
||||
try:
|
||||
os.stat(args.stage)
|
||||
except OSError as e:
|
||||
log.error('Cannot read stage3 tarball: {}'.format(e))
|
||||
raise SystemExit(os.EX_OSFILE)
|
||||
stagetbz = args.stage
|
||||
|
||||
try:
|
||||
pool = v.get_pool(args.pool)
|
||||
vm.create_disk(pool)
|
||||
vm.partition_disk()
|
||||
vm.format_filesystems()
|
||||
except ValueError as e:
|
||||
log.error(e)
|
||||
raise SystemExit(os.EX_CONFIG)
|
||||
except (OSError, virt.VirtError, storage.DiskError) as e:
|
||||
log.error(e)
|
||||
raise SystemExit(os.EX_SOFTWARE)
|
||||
|
||||
try:
|
||||
vm.mount_filesystems()
|
||||
except ValueError as e:
|
||||
log.error(e)
|
||||
raise SystemExit(os.EX_CONFIG)
|
||||
except storage.MountError as e:
|
||||
log.error(e)
|
||||
raise SystemExit(os.EX_OSERR)
|
||||
|
||||
try:
|
||||
stage3.extract_stage(stagetbz, vm.mountpoint)
|
||||
except (OSError, stage3.ExtractError) as e:
|
||||
log.error(e)
|
||||
raise SystemExit(os.EX_SOFTWARE)
|
||||
|
||||
vm.write_fstab()
|
||||
configure.configure(vm)
|
||||
if args.inject_ssh_key:
|
||||
filename = os.path.join(vm.mountpoint, 'root/.ssh/authorized_keys')
|
||||
configure.inject_ssh_keys(filename, *args.inject_ssh_key)
|
||||
|
||||
vm.unmount_filesystems()
|
||||
|
||||
dom = v.create_domain(vm)
|
||||
if args.autostart:
|
||||
dom.create()
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
|
|
@ -0,0 +1,204 @@
|
|||
import codecs
|
||||
import gpgme
|
||||
import logging
|
||||
import hashlib
|
||||
import io
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import time
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
XDG_CACHE_DIR = os.environ.get('XDG_CACHE_DIR', '~/.cache')
|
||||
|
||||
ARCH_NAMES = {
|
||||
'i386': 'x86',
|
||||
'i486': 'x86',
|
||||
'i586': 'x86',
|
||||
'i686': 'x86',
|
||||
'x86_64': 'amd64',
|
||||
'em64t': 'amd64',
|
||||
}
|
||||
|
||||
|
||||
class FetchError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class VerifyError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class ExtractError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class Fetcher(object):
|
||||
|
||||
DEFAULT_MIRROR = 'http://distfiles.gentoo.org/'
|
||||
LIST_CACHE_LIFE = 86400
|
||||
|
||||
log = log.getChild('fetch')
|
||||
|
||||
def __init__(self, cache_dir=None, mirror=DEFAULT_MIRROR):
|
||||
if cache_dir is None:
|
||||
self.cache_dir = os.path.join(
|
||||
os.path.expanduser(XDG_CACHE_DIR),
|
||||
'stage3s',
|
||||
)
|
||||
else:
|
||||
self.cache_dir = cache_dir
|
||||
if not os.path.isdir(self.cache_dir):
|
||||
os.makedirs(self.cache_dir)
|
||||
self.mirror = mirror
|
||||
if not self.mirror.endswith('/'):
|
||||
self.mirror += '/'
|
||||
|
||||
@staticmethod
|
||||
def verify(filename):
|
||||
log.debug('Verifying PGP signature for {}'.format(filename))
|
||||
ctx = gpgme.Context()
|
||||
plaintext = io.BytesIO()
|
||||
with open(filename, 'rb') as f:
|
||||
sigs = ctx.verify(f, None, plaintext)
|
||||
for sig in sigs:
|
||||
if sig.status:
|
||||
raise VerifyError(sig.status.args[2])
|
||||
if sig.wrong_key_usage:
|
||||
raise VerifyError('wrong key usage')
|
||||
log.info('Successfully verified PGP signature')
|
||||
plaintext.seek(0)
|
||||
buf = codecs.getreader('utf-8')(plaintext)
|
||||
dirname = os.path.dirname(filename)
|
||||
for line in buf:
|
||||
if not line.lstrip().startswith('#'):
|
||||
continue
|
||||
if 'SHA512' in line:
|
||||
h = hashlib.sha512()
|
||||
else:
|
||||
continue
|
||||
line = buf.readline()
|
||||
try:
|
||||
digest, filename = line.split()
|
||||
except ValueError:
|
||||
pass
|
||||
path = os.path.join(dirname, filename)
|
||||
log.debug('Verifying checksum of {}'.format(path))
|
||||
with open(path, 'rb') as f:
|
||||
for data in iter(lambda: f.read(4096), b''):
|
||||
h.update(data)
|
||||
if h.hexdigest() != digest.lower():
|
||||
raise VerifyError(
|
||||
'{} checksum mismatch: {}'.format(h.name, filename))
|
||||
log.info('Verified checksum of {}'.format(filename))
|
||||
|
||||
def wget(self, *uris):
|
||||
cmd = ['wget', '--continue']
|
||||
cmd += uris
|
||||
log.debug('Running command: {}'.format(' '.join(cmd)))
|
||||
try:
|
||||
p = subprocess.Popen(cmd, cwd=self.cache_dir)
|
||||
except OSError as e:
|
||||
raise FetchError('Failed to run wget: {}'.format(e))
|
||||
if p.wait() != 0:
|
||||
raise FetchError('wget returned status {}'.format(p.returncode))
|
||||
|
||||
def fetch_stage(self, arch=None, subtype=None):
|
||||
if not arch:
|
||||
arch = os.uname().machine
|
||||
try:
|
||||
arch = ARCH_NAMES[arch]
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
want = 'stage3-{}-'.format(subtype if subtype else arch)
|
||||
with self._get_latest_list(arch) as latest_list:
|
||||
for line in latest_list:
|
||||
line = line.split('#')[0]
|
||||
if not line:
|
||||
continue
|
||||
try:
|
||||
path, size = line.split(None, 1)
|
||||
except ValueError:
|
||||
log.warning('Unexpected value: {}'.format(line))
|
||||
continue
|
||||
filename = os.path.basename(path)
|
||||
if filename.startswith(want):
|
||||
break
|
||||
else:
|
||||
raise FetchError(
|
||||
'No stage3 tarballs for {}'.format(subtype or arch))
|
||||
log.info('Found latest stage3 tarball: {}'.format(filename))
|
||||
full_path = 'releases/{}/autobuilds/{}'.format(arch, path)
|
||||
uri = urllib.parse.urljoin(self.mirror, full_path)
|
||||
local_path = os.path.join(self.cache_dir, filename)
|
||||
to_fetch = [
|
||||
uri,
|
||||
uri + '.CONTENTS',
|
||||
uri + '.DIGESTS.asc',
|
||||
]
|
||||
try:
|
||||
st = os.stat(local_path)
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
if st.st_size == int(size):
|
||||
log.info('Cached copy of {} is complete'.format(filename))
|
||||
to_fetch.remove(uri)
|
||||
for fn in to_fetch[-2:]:
|
||||
c_fn = os.path.join(self.cache_dir, os.path.basename(fn))
|
||||
try:
|
||||
st = os.stat(c_fn)
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
if st.st_size > 0:
|
||||
to_fetch.remove(fn)
|
||||
if to_fetch:
|
||||
self.wget(*to_fetch)
|
||||
return local_path
|
||||
|
||||
def _get_latest_list(self, arch):
|
||||
cache_fname = os.path.join(
|
||||
self.cache_dir,
|
||||
'latest-stage3-{}.txt'.format(arch),
|
||||
)
|
||||
try:
|
||||
st = os.stat(cache_fname)
|
||||
except OSError:
|
||||
pass
|
||||
else:
|
||||
if st.st_mtime > time.time() - self.LIST_CACHE_LIFE:
|
||||
return open(cache_fname)
|
||||
|
||||
path = 'releases/{}/autobuilds/latest-stage3.txt'.format(arch)
|
||||
url = urllib.parse.urljoin(self.mirror, path)
|
||||
log.debug('Fetching URL: {}'.format(url))
|
||||
try:
|
||||
response = urllib.request.urlopen(url)
|
||||
except urllib.error.HTTPError as e:
|
||||
log.error('Failed to fetch latest stage3 list: {}'.format(e))
|
||||
raise FetchError('Could not fetch latest stage3 list')
|
||||
with open(cache_fname, 'wb') as f:
|
||||
for line in response:
|
||||
f.write(line)
|
||||
return open(cache_fname)
|
||||
|
||||
|
||||
def extract_stage(tbz, directory):
|
||||
log.debug('Extracting {} to {}'.format(tbz, directory))
|
||||
cmd = ['tar', '-xaf', tbz, '--numeric-owner', '-C', directory]
|
||||
try:
|
||||
subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise ExtractError('Failed to extract stage tarball: {}'.format(msg))
|
||||
openrc_run = os.path.join(directory, 'run/openrc')
|
||||
if os.path.isdir(openrc_run):
|
||||
shutil.rmtree(openrc_run)
|
||||
log.info('Successfully extracted {}'.format(os.path.basename(tbz)))
|
||||
|
|
@ -0,0 +1,246 @@
|
|||
import logging
|
||||
import os
|
||||
import pyudev
|
||||
import subprocess
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
udev = pyudev.Context()
|
||||
|
||||
|
||||
class MountError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class DiskError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def mount(source, target=None, fstype=None, options=None):
|
||||
cmd = ['mount']
|
||||
if fstype:
|
||||
cmd += ('-t', fstype)
|
||||
if options:
|
||||
cmd += ('-o', ','.join(options))
|
||||
cmd.append(source)
|
||||
if target:
|
||||
cmd.append(target)
|
||||
try:
|
||||
subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise MountError(msg)
|
||||
log.info('Mounted {} at {}'.format(source, target))
|
||||
|
||||
|
||||
def umount(target):
|
||||
log.debug('Unmounting {}'.format(target))
|
||||
cmd = ['umount', target]
|
||||
try:
|
||||
subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise MountError(msg)
|
||||
log.info('Successfully unmounted {}'.format(target))
|
||||
|
||||
|
||||
def find_next_nbd():
|
||||
cmd = ['pgrep', '-a', '^nbd[0-9]+$']
|
||||
p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
|
||||
nbds = p.communicate()[0]
|
||||
|
||||
devs = []
|
||||
for line in nbds.splitlines():
|
||||
devs.append(line.split()[1])
|
||||
devs.sort()
|
||||
log.debug('Found {} nbd nodes in use'.format(len(devs)))
|
||||
|
||||
try:
|
||||
last = devs[-1]
|
||||
except IndexError:
|
||||
return 'nbd0'
|
||||
return 'nbd' + str(int(last[3:]) + 1)
|
||||
|
||||
|
||||
def setup_loop(filename):
|
||||
cmd = ['losetup', '-f', '--show', filename]
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
dev = output.decode().strip()
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to set up loopback: {}'.format(msg))
|
||||
log.info('Connected {} to {}'.format(filename, dev))
|
||||
return dev
|
||||
|
||||
|
||||
def detach_loop(dev):
|
||||
cmd = ['losetup', '-d', dev]
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
if output:
|
||||
log.info(output.decode().strip())
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to detach loopback: {}'.format(msg))
|
||||
log.info('Disconnected {}'.format(dev))
|
||||
|
||||
|
||||
def setup_nbd(filename):
|
||||
dev = os.path.join('/dev', find_next_nbd())
|
||||
cmd = ['qemu-nbd', '-c', dev, filename]
|
||||
try:
|
||||
subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to set up nbd: {}'.format(msg))
|
||||
log.info('Connected {} to {}'.format(filename, dev))
|
||||
return dev
|
||||
|
||||
|
||||
def detach_nbd(dev):
|
||||
cmd = ['qemu-nbd', '-d', dev]
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
if output:
|
||||
log.info(output.decode().strip())
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to detach nbd: {}'.format(msg))
|
||||
|
||||
|
||||
def get_partitions(blockdev):
|
||||
dev = pyudev.Device.from_device_file(udev, blockdev)
|
||||
for child in dev.children:
|
||||
yield child.device_node
|
||||
|
||||
|
||||
def partition_gpt(blockdev, partitions):
|
||||
log.debug('Partitioning {} with GPT'.format(blockdev))
|
||||
cmd = ['sgdisk', '-a', '4096', '-Z', '-g']
|
||||
for idx, part in enumerate(partitions):
|
||||
partnum = idx + 1
|
||||
cmd += ('-n', '{}::{}'.format(partnum, part.get('size', '')))
|
||||
if 'type' in part:
|
||||
cmd += ('-t', '{}:{:X}'.format(partnum, part['type']))
|
||||
if 'name' in part:
|
||||
cmd += ('-c', '{}:{}'.format(partnum, part['name']))
|
||||
cmd.append(blockdev)
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
for line in output.decode().rstrip().splitlines():
|
||||
log.info(line)
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to partition disk: {}'.format(msg))
|
||||
|
||||
|
||||
def pvscan():
|
||||
try:
|
||||
output = subprocess.check_output(['pvscan'], stderr=subprocess.STDOUT)
|
||||
if output:
|
||||
log.debug('pvscan:\n{}'.format(output.decode().rstrip()))
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('pvscan failed: {}'.format(msg))
|
||||
|
||||
|
||||
def create_lvm_pv(*pvs):
|
||||
cmd = ['pvcreate']
|
||||
cmd += pvs
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
if output:
|
||||
log.info(output.decode().strip())
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to create lvm pv: {}'.format(msg))
|
||||
|
||||
|
||||
def create_lvm_vg(name, *pvs):
|
||||
cmd = ['vgcreate', name]
|
||||
cmd += pvs
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
log.info(output.decode().strip())
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to create lvm vg: {}'.format(msg))
|
||||
|
||||
|
||||
def create_lvm_lv(vg_name, name, size):
|
||||
cmd = ['lvcreate', '-n', name]
|
||||
size = str(size)
|
||||
if '%' in size:
|
||||
cmd += ('-l', size)
|
||||
else:
|
||||
cmd += ('-L', size)
|
||||
cmd.append(vg_name)
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
log.info(output.decode().strip())
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to create lvm lv: {}'.format(msg))
|
||||
|
||||
|
||||
def get_lv_blockdev(vg_name, lv_name):
|
||||
cmd = ['lvs', '-o', 'lv_name,lv_kernel_major,lv_kernel_minor',
|
||||
'--noheadings', '/'.join((vg_name, lv_name))]
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Could not get info for lv: {}'.format(msg))
|
||||
major, minor = output.split()[1:]
|
||||
devnum = os.makedev(int(major), int(minor))
|
||||
dev = pyudev.Device.from_device_number(udev, 'block', devnum)
|
||||
return dev.device_node
|
||||
|
||||
|
||||
def mkfs(fstype, device, label=None):
|
||||
log.debug(
|
||||
'Creating {fstype} filesystem on {device} '
|
||||
'with label "{label}"'.format(
|
||||
fstype=fstype,
|
||||
device=device,
|
||||
label=label,
|
||||
)
|
||||
)
|
||||
if fstype == 'swap':
|
||||
cmd = ['mkswap']
|
||||
else:
|
||||
cmd = ['mkfs.{}'.format(fstype), '-q']
|
||||
if label:
|
||||
cmd += ('-L', label)
|
||||
cmd.append(device)
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
if output:
|
||||
log.info(output.decode().strip())
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError(
|
||||
'Failed to create filesystem: {}'.format(msg))
|
||||
log.info('Successfully created {} filesystem on {}'.format(fstype, device))
|
||||
|
||||
|
||||
def get_fs_uuid(blockdev):
|
||||
cmd = ['blkid', '-c', os.devnull, '-o', 'value', '-s', 'UUID', blockdev]
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Could not get fs uuid: {}'.format(msg))
|
||||
return output.decode().strip()
|
||||
|
||||
|
||||
def deactivate_vg(name):
|
||||
cmd = ['vgchange', '-an', name]
|
||||
try:
|
||||
output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
||||
if output:
|
||||
log.info(output.decode().strip())
|
||||
except subprocess.CalledProcessError as e:
|
||||
msg = e.output.decode().strip() if e.output else e
|
||||
raise DiskError('Failed to deactivate vg: {}'.format(msg))
|
||||
|
|
@ -0,0 +1,130 @@
|
|||
from . import storage
|
||||
from xml.etree import ElementTree as etree
|
||||
import libvirt
|
||||
import logging
|
||||
import os
|
||||
import stat
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
VirtError = libvirt.libvirtError
|
||||
|
||||
|
||||
class Virt(object):
|
||||
|
||||
def __init__(self, uri=None):
|
||||
self.conn = libvirt.open(uri)
|
||||
log.debug('Successfully connected to {}'.format(self.conn.getURI()))
|
||||
|
||||
def get_pool(self, name):
|
||||
return VirtPool.from_virpool(self.conn.storagePoolLookupByName(name))
|
||||
|
||||
def create_domain(self, vm):
|
||||
return self.conn.defineXML(vm.to_xml())
|
||||
|
||||
|
||||
class VirtPool(object):
|
||||
|
||||
DEFAULT_EXTENSION = '.img'
|
||||
EXTENSIONS = {
|
||||
'qcow2': '.qcow2',
|
||||
'vdi': '.vdi',
|
||||
'vmdk': '.vmdk',
|
||||
}
|
||||
|
||||
def __init__(self, name=None):
|
||||
self._pool = None
|
||||
self.name = name
|
||||
self.path = None
|
||||
self.type = None
|
||||
|
||||
@classmethod
|
||||
def from_virpool(cls, pool):
|
||||
root = etree.fromstring(pool.XMLDesc())
|
||||
self = cls(pool.name())
|
||||
self._pool = pool
|
||||
self.type = root.attrib['type']
|
||||
self.path = root.find('target').find('path').text
|
||||
return self
|
||||
|
||||
def create_volume(self, name, size, fmt=None):
|
||||
assert self._pool
|
||||
if self.type == 'logical':
|
||||
name = name.lower()
|
||||
fmt = None
|
||||
else:
|
||||
name += self.EXTENSIONS.get(fmt, self.DEFAULT_EXTENSION)
|
||||
|
||||
vol = VirtVolume()
|
||||
vol.name = name
|
||||
vol.capacity = size
|
||||
vol.path = os.path.join(self.path, name)
|
||||
vol.format = fmt
|
||||
self._pool.createXML(vol.to_xml())
|
||||
log.info('Created volume {} ({} bytes)'.format(vol.name, vol.capacity))
|
||||
return vol
|
||||
|
||||
|
||||
class VirtVolume(object):
|
||||
|
||||
def __init__(self):
|
||||
self.name = None
|
||||
self.capacity = None
|
||||
self.path = None
|
||||
self.format = None
|
||||
|
||||
@property
|
||||
def blockdev(self):
|
||||
try:
|
||||
return self.__blockdev
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
if self.disk_type == 'block':
|
||||
self.__blockdev = self.path
|
||||
elif self.format == 'raw':
|
||||
self.__blockdev = storage.setup_loop(self.path)
|
||||
else:
|
||||
self.__blockdev = storage.setup_nbd(self.path)
|
||||
return self.__blockdev
|
||||
|
||||
@property
|
||||
def disk_type(self):
|
||||
try:
|
||||
return self.__disk_type
|
||||
except AttributeError:
|
||||
pass
|
||||
|
||||
st = os.stat(self.path)
|
||||
if stat.S_ISBLK(st.st_mode):
|
||||
self.__disk_type = 'block'
|
||||
else:
|
||||
self.__disk_type = 'file'
|
||||
return self.__disk_type
|
||||
|
||||
@property
|
||||
def partitions(self):
|
||||
return list(storage.get_partitions(self.blockdev))
|
||||
|
||||
def to_xml(self):
|
||||
root = etree.Element('volume')
|
||||
elm_name = etree.SubElement(root, 'name')
|
||||
elm_name.text = self.name
|
||||
elm_capacity = etree.SubElement(root, 'capacity')
|
||||
elm_capacity.attrib['unit'] = 'bytes'
|
||||
elm_capacity.text = str(self.capacity)
|
||||
elm_target = etree.SubElement(root, 'target')
|
||||
elm_path = etree.SubElement(elm_target, 'path')
|
||||
elm_path.text = self.path
|
||||
if self.format:
|
||||
elm_format = etree.SubElement(elm_target, 'format')
|
||||
elm_format.attrib['type'] = self.format
|
||||
return etree.tostring(root, encoding='unicode')
|
||||
|
||||
def deactivate(self):
|
||||
if 'nbd' in self.blockdev:
|
||||
storage.detach_nbd(self.blockdev)
|
||||
elif 'loop' in self.blockdev:
|
||||
storage.detach_loop(self.blockdev)
|
||||
|
|
@ -0,0 +1,388 @@
|
|||
from . import storage
|
||||
from xml.etree import ElementTree as etree
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import tempfile
|
||||
import yaml
|
||||
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
UNITS = {
|
||||
'k': 2 ** 10,
|
||||
'kb': 10 ** 3,
|
||||
'kib': 2 ** 10,
|
||||
'm': 2 ** 20,
|
||||
'mb': 10 ** 6,
|
||||
'mib': 2 ** 20,
|
||||
'g': 2 ** 30,
|
||||
'gb': 10 ** 9,
|
||||
'gib': 2 ** 30,
|
||||
't': 2 ** 40,
|
||||
'tb': 10 ** 12,
|
||||
'tib': 2 ** 40,
|
||||
'p': 2 ** 50,
|
||||
'pb': 10 ** 15,
|
||||
'pib': 2 ** 50,
|
||||
'e': 2 ** 60,
|
||||
'eb': 10 ** 18,
|
||||
'eib': 2 ** 60,
|
||||
'z': 2 ** 70,
|
||||
'zb': 10 ** 21,
|
||||
'zib': 2 ** 70,
|
||||
'y': 2 ** 80,
|
||||
'yb': 10 ** 24,
|
||||
'yib': 2 ** 80,
|
||||
}
|
||||
|
||||
SIZE_RE = re.compile(
|
||||
r'^(?P<value>[0-9]+)\s*'
|
||||
r'(?P<unit>\w+)?\s*$'
|
||||
)
|
||||
|
||||
|
||||
try:
|
||||
YamlLoader = yaml.CLoader
|
||||
except AttributeError:
|
||||
YamlLoader = yaml.Loader
|
||||
|
||||
|
||||
def parse_size(size):
|
||||
if isinstance(size, int):
|
||||
return size
|
||||
|
||||
m = SIZE_RE.match(size.lower())
|
||||
if not m:
|
||||
raise ValueError('Invalid size: {}'.format(size))
|
||||
parts = m.groupdict()
|
||||
if parts['unit'] in (None, 'b', 'byte', 'bytes'):
|
||||
factor = 1
|
||||
else:
|
||||
try:
|
||||
factor = UNITS[parts['unit']]
|
||||
except KeyError:
|
||||
raise ValueError('Invalid size : {}'.format(size))
|
||||
return int(parts['value']) * factor
|
||||
|
||||
|
||||
class VirtualMachine(object):
|
||||
|
||||
__slots__ = (
|
||||
'name',
|
||||
'fqdn',
|
||||
'ram',
|
||||
'vcpus',
|
||||
'net_ifaces',
|
||||
'console',
|
||||
'graphics',
|
||||
'video',
|
||||
'guest_agent',
|
||||
'image_format',
|
||||
'disk_size',
|
||||
'disk_label',
|
||||
'partitions',
|
||||
'volumes',
|
||||
'tmpfs_tmp',
|
||||
'install_grub',
|
||||
'kernel',
|
||||
'initrd',
|
||||
'kcmdline',
|
||||
'boot',
|
||||
'timezone',
|
||||
'customize',
|
||||
'_disk',
|
||||
'_mountpoint',
|
||||
)
|
||||
|
||||
def __init__(self, name=None):
|
||||
self.name = name
|
||||
self.fqdn = None
|
||||
self.ram = 256 * 2 ** 20
|
||||
self.vcpus = 1
|
||||
self.net_ifaces = []
|
||||
self.console = 'virtio'
|
||||
self.graphics = 'spice'
|
||||
self.video = 'qxl'
|
||||
self.guest_agent = True
|
||||
self.image_format = 'raw'
|
||||
self.disk_size = 3 * 2 ** 30
|
||||
self.disk_label = 'gpt'
|
||||
self.partitions = []
|
||||
self.volumes = []
|
||||
self.tmpfs_tmp = True
|
||||
self.install_grub = False
|
||||
self.kernel = None
|
||||
self.initrd = None
|
||||
self.kcmdline = None
|
||||
self.boot = None
|
||||
self.timezone = 'UTC'
|
||||
self.customize = None
|
||||
self._disk = None
|
||||
self._mountpoint = None
|
||||
|
||||
@property
|
||||
def mountpoint(self):
|
||||
return self._mountpoint
|
||||
|
||||
@property
|
||||
def vg_name(self):
|
||||
return self.name.lower()
|
||||
|
||||
@classmethod
|
||||
def from_yaml(cls, filename):
|
||||
with open(filename) as f:
|
||||
data = yaml.load(f, Loader=YamlLoader)
|
||||
self = cls()
|
||||
for key, value in data.items():
|
||||
if key in ('disk_size', 'ram'):
|
||||
value = parse_size(value)
|
||||
try:
|
||||
setattr(self, key, value)
|
||||
except AttributeError:
|
||||
pass
|
||||
return self
|
||||
|
||||
def create_disk(self, pool):
|
||||
self._disk = pool.create_volume(
|
||||
name=self.name,
|
||||
size=self.disk_size,
|
||||
fmt=self.image_format,
|
||||
)
|
||||
|
||||
def partition_disk(self):
|
||||
if self.partitions:
|
||||
if not self.disk_label:
|
||||
raise ValueError('Cannot partition without disk label')
|
||||
elif self.disk_label == 'gpt':
|
||||
self._partition_gpt()
|
||||
# TODO: support msdos disk labels
|
||||
else:
|
||||
raise ValueError(
|
||||
'Unsupported disk label {}'.format(self.disk_label))
|
||||
if self.volumes:
|
||||
self._partition_lvm()
|
||||
|
||||
def format_filesystems(self):
|
||||
def lv_block(name):
|
||||
return storage.get_lv_blockdev(self.vg_name, name)
|
||||
|
||||
partitions = self._disk.partitions
|
||||
for idx, part in enumerate(self.partitions):
|
||||
try:
|
||||
storage.mkfs(part['fstype'], partitions[idx],
|
||||
part.get('label'))
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
for vol in self.volumes:
|
||||
try:
|
||||
storage.mkfs(vol['fstype'], lv_block(vol['name']), vol['name'])
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
def mount_filesystems(self):
|
||||
mountpoint = tempfile.mkdtemp(prefix='mkvm-')
|
||||
partitions = self._disk.partitions
|
||||
|
||||
mounts = {}
|
||||
for idx, part in enumerate(self.partitions):
|
||||
try:
|
||||
mounts[part['mountpoint']] = partitions[idx]
|
||||
except KeyError:
|
||||
pass
|
||||
for vol in self.volumes:
|
||||
try:
|
||||
mounts[vol['mountpoint']] = storage.get_lv_blockdev(
|
||||
self.vg_name, vol['name'])
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
try:
|
||||
storage.mount(mounts.pop('/'), mountpoint)
|
||||
except KeyError:
|
||||
raise ValueError('No root filesystem defined')
|
||||
|
||||
for dirname, device in sorted(mounts.items()):
|
||||
target = os.path.join(mountpoint, dirname[1:])
|
||||
if not os.path.isdir(target):
|
||||
os.makedirs(target)
|
||||
storage.mount(device, target)
|
||||
self._mountpoint = mountpoint
|
||||
|
||||
def write_fstab(self):
|
||||
def get_kwargs(mountpoint, fstype):
|
||||
kwargs = {
|
||||
'fsopts': 'sw' if fstype == 'swap' else 'defaults',
|
||||
'mountpoint': 'none',
|
||||
}
|
||||
if not mountpoint:
|
||||
kwargs['passno'] = 0
|
||||
elif mountpoint == '/':
|
||||
kwargs['passno'] = 1
|
||||
else:
|
||||
kwargs['passno'] = 2
|
||||
return kwargs
|
||||
|
||||
tmpl = '{source}\t{mountpoint}\t{fstype}\t{fsopts}\t0 {passno}\n'
|
||||
with open(os.path.join(self.mountpoint, 'etc', 'fstab'), 'w') as f:
|
||||
partitions = self._disk.partitions
|
||||
for idx, part in enumerate(self.partitions):
|
||||
if part.get('fstype'):
|
||||
kwargs = get_kwargs(part.get('mountpoint'), part['fstype'])
|
||||
if part.get('label'):
|
||||
kwargs['source'] = 'LABEL={}'.format(part['label'])
|
||||
else:
|
||||
fs_uuid = storage.get_fs_uuid(partitions[idx])
|
||||
kwargs['source'] = 'UUID={}'.format(fs_uuid)
|
||||
kwargs.update(part)
|
||||
f.write(tmpl.format(**kwargs))
|
||||
for vol in self.volumes:
|
||||
if vol.get('fstype'):
|
||||
kwargs = get_kwargs(vol.get('mountpoint'), vol['fstype'])
|
||||
kwargs['source'] = os.path.join('/dev', self.vg_name,
|
||||
vol['name'])
|
||||
kwargs.update(vol)
|
||||
f.write(tmpl.format(**kwargs))
|
||||
if self.tmpfs_tmp:
|
||||
f.write(tmpl.format(
|
||||
source='tmpfs',
|
||||
mountpoint='/tmp',
|
||||
fstype='tmpfs',
|
||||
fsopts='defaults',
|
||||
passno=0,
|
||||
))
|
||||
log.info('Successfully wrote fstab to {}'.format(f.name))
|
||||
|
||||
def unmount_filesystems(self):
|
||||
mounts = []
|
||||
with open('/proc/self/mountinfo') as f:
|
||||
for line in f:
|
||||
mountinfo = line.split()
|
||||
if mountinfo[4].startswith(self.mountpoint):
|
||||
mounts.append(mountinfo[4])
|
||||
for mount in reversed(mounts):
|
||||
storage.umount(mount)
|
||||
os.rmdir(self.mountpoint)
|
||||
if self.volumes:
|
||||
storage.deactivate_vg(self.vg_name)
|
||||
self._disk.deactivate()
|
||||
|
||||
def to_xml(self):
|
||||
root = etree.Element('domain', type='kvm')
|
||||
etree.SubElement(root, 'name').text = self.name
|
||||
|
||||
elm_memory = etree.SubElement(root, 'memory', unit='KiB')
|
||||
elm_memory.text = str(self.ram // 1024)
|
||||
elm_vcpu = etree.SubElement(root, 'vcpu', placement='static')
|
||||
elm_vcpu.text = str(self.vcpus)
|
||||
|
||||
elm_os = etree.SubElement(root, 'os')
|
||||
elm_type = etree.SubElement(elm_os, 'type', arch='x86_64')
|
||||
elm_type.text = 'hvm'
|
||||
if not self.boot:
|
||||
pass
|
||||
elif 'kernel' in self.boot:
|
||||
etree.SubElement(elm_os, 'kernel').text = self.kernel
|
||||
etree.SubElement(elm_os, 'initrd').text = self.initrd
|
||||
etree.SubElement(elm_os, 'cmdline').text = self.kcmdline
|
||||
else:
|
||||
for dev in self.boot:
|
||||
etree.SubElement(elm_os, 'boot', dev=dev)
|
||||
|
||||
elm_features = etree.SubElement(root, 'features')
|
||||
for feat in ('acpi', 'apic', 'pae'):
|
||||
etree.SubElement(elm_features, feat)
|
||||
|
||||
elm_devices = etree.SubElement(root, 'devices')
|
||||
|
||||
for iface in self.net_ifaces:
|
||||
elm_iface = etree.Element('interface')
|
||||
if 'bridge' in iface:
|
||||
elm_iface.attrib['type'] = 'bridge'
|
||||
elm_source = etree.SubElement(elm_iface, 'source')
|
||||
elm_source.attrib['bridge'] = iface['bridge']
|
||||
if 'mac' in iface:
|
||||
elm_mac = etree.SubElement(elm_iface, 'mac')
|
||||
elm_mac.attrib['address'] = iface['mac']
|
||||
elm_model = etree.SubElement(elm_iface, 'model')
|
||||
elm_model.attrib['type'] = iface.get('model', 'virtio')
|
||||
elm_devices.insert(0, elm_iface)
|
||||
|
||||
if self._disk:
|
||||
elm_disk = etree.Element('disk')
|
||||
elm_disk.attrib['type'] = self._disk.disk_type
|
||||
elm_disk.attrib['device'] = 'disk'
|
||||
elm_driver = etree.SubElement(elm_disk, 'driver')
|
||||
elm_driver.attrib['name'] = 'qemu'
|
||||
elm_driver.attrib['type'] = self._disk.format
|
||||
elm_source = etree.SubElement(elm_disk, 'source')
|
||||
source_type = 'dev' if self._disk.disk_type == 'block' else 'file'
|
||||
elm_source.attrib[source_type] = self._disk.path
|
||||
elm_target = etree.SubElement(elm_disk, 'target')
|
||||
elm_target.attrib['dev'] = 'vda'
|
||||
elm_target.attrib['bus'] = 'virtio'
|
||||
elm_devices.insert(0, elm_disk)
|
||||
|
||||
if self.console:
|
||||
elm_console = etree.SubElement(elm_devices, 'console', type='pty')
|
||||
elm_target = etree.SubElement(elm_console, 'target')
|
||||
elm_target.attrib['type'] = self.console
|
||||
|
||||
if self.guest_agent:
|
||||
elm_channel = etree.SubElement(elm_devices, 'channel')
|
||||
elm_channel.attrib['type'] = 'unix'
|
||||
elm_target = etree.SubElement(elm_channel, 'target')
|
||||
elm_target.attrib['type'] = 'virtio'
|
||||
elm_target.attrib['name'] = 'org.qemu.guest_agent.0'
|
||||
|
||||
if self.graphics == 'spice':
|
||||
elm_channel = etree.SubElement(elm_devices, 'channel')
|
||||
elm_channel.attrib['type'] = 'spicevmc'
|
||||
elm_target = etree.SubElement(elm_channel, 'target')
|
||||
elm_target.attrib['type'] = 'virtio'
|
||||
elm_target.attrib['name'] = 'com.redhat.spice.0'
|
||||
if self.graphics:
|
||||
elm_graphics = etree.SubElement(elm_devices, 'graphics')
|
||||
elm_graphics.attrib['type'] = self.graphics
|
||||
elm_graphics.attrib['autoport'] = 'yes'
|
||||
|
||||
if self.video == 'qxl':
|
||||
elm_video = etree.SubElement(elm_devices, 'video')
|
||||
elm_model = etree.SubElement(elm_video, 'model')
|
||||
elm_model.attrib.update(
|
||||
type=self.video,
|
||||
ram='65536',
|
||||
vram='65536',
|
||||
heads='1',
|
||||
)
|
||||
elif self.video:
|
||||
elm_video = etree.SubElement(elm_devices, 'video')
|
||||
elm_model = etree.SubElement(elm_video, 'model')
|
||||
elm_model.attrib.update(
|
||||
type=self.video,
|
||||
vram='9216',
|
||||
heads='1',
|
||||
)
|
||||
|
||||
return etree.tostring(root, encoding='unicode')
|
||||
|
||||
def _partition_gpt(self):
|
||||
storage.partition_gpt(self._disk.blockdev, self.partitions)
|
||||
|
||||
def _partition_lvm(self):
|
||||
blockdev = self._disk.blockdev
|
||||
storage.pvscan()
|
||||
pvs = []
|
||||
if self.partitions:
|
||||
partitions = self._disk.partitions
|
||||
for idx, part in enumerate(self.partitions):
|
||||
if part.get('type') == 0x8e00:
|
||||
pvs.append(partitions[idx])
|
||||
else:
|
||||
pvs.append(blockdev)
|
||||
storage.create_lvm_pv(*pvs)
|
||||
storage.create_lvm_vg(self.vg_name, *pvs)
|
||||
for vol in self.volumes:
|
||||
storage.create_lvm_lv(self.vg_name, vol['name'], vol['size'])
|
||||
Loading…
Reference in New Issue