Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

379 lignes
14 KiB

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from __future__ import print_function
import argparse
import fs.tempfs
import fs.path
import ipaddress
import json
import os
import subprocess
import sys
import uuid
__VERSION__ = '0.1'
class ConfigDrive:
def __init__(self, genisoimage='/usr/bin/genisoimage', verbose=False):
self._tmpfs = None
self._genisoimage = genisoimage
self._user_data = {} # {"system_info": {"default_user": None}}
self._interfaces = []
self._pubkeys = []
self._verbose = verbose
self._clean_metadata = False
self._added_resolv_module_call = False
if not os.path.exists(genisoimage):
print("Error: %s does not exist, no genisoimage found!" % genisoimage, file=sys.stderr)
sys.exit(1)
self.open()
def set_hostname(self, hostname):
self._hostname = hostname
def conf_network(self, interface, address=None, gateway=None, *extra_routes):
if not address and gateway:
raise ValueError("You cannot define a gateway, but supply no address")
if not self._interfaces:
self._interfaces.extend([
"auto lo",
"iface lo inet loopback",
])
if address:
if address == "dhcp":
address = None
method = "dhcp"
elif "/" in address:
address = ipaddress.ip_interface(address)
method = "static"
else:
raise ValueError("IP Interface is not a subnet")
else:
method = "manual"
self._interfaces.extend([
"",
"auto %s" % interface,
"iface %s inet%s %s" % (interface, "" if not address or address.version == 4 else "6", method),
])
if address:
self._interfaces.append(" address %s" % address)
if gateway:
self._interfaces.append(" gateway %s" % str(ipaddress.ip_address(gateway)))
for routedef in extra_routes:
if "-" not in routedef:
raise ValueError("Route {} is missing a gateway separated by a -".format(routedef))
route, gw = routedef.split('-')
if "/" not in route:
raise ValueError("Route {} is not a subnet".format(route))
route = ipaddress.ip_interface(route)
gw = ipaddress.ip_address(gw)
self._interfaces.append(" up ip route add {} via {}".format(route, gw))
def conf_resolve(self, resolvers):
if not self._hostname:
raise ValueError("Please set a hostname before calling this function")
for n, resolver in enumerate(resolvers, 1):
try:
ipaddress.ip_address(resolver)
except ValueError as e:
print("Nameserver argument %s: %s" % (n, e), file=sys.stderr)
sys.exit(1)
self._user_data["manage_resolv_conf"] = True
self._user_data["resolv_conf"] = {
"nameservers": resolvers,
}
if "." in self._hostname:
self._user_data["domain"] = ".".join(self._hostname.split(".")[1:])
# debian, by default, does not call the cc_resolv_conf module
if not self._added_resolv_module_call:
self.add_command("cloud-init single --name cc_resolv_conf", True)
self._added_resolv_module_call = True
def set_clean_metadata(self, do_clean_metadata):
self._clean_metadata = do_clean_metadata
def add_user(self, name, keys=None, gecos=None, sudo=False, password=None):
if "users" not in self._user_data:
self._user_data["users"] = []
user = {
"name": name,
"shell": "/bin/bash",
"home": "/home/%s" % name
}
if keys:
if type(keys) == str:
keys = [keys]
user["ssh_authorized_keys"] = keys
if gecos:
user["gecos"] = gecos
if sudo:
user["sudo"] = "ALL=(ALL) NOPASSWD:ALL"
if password:
raise NotImplementedError("crypt, salt, $6$ something")
self._user_data["users"].append(user)
def add_fp(self, path, fp):
self.add_text(path, fp.read())
def add_text(self, path, content):
dir_path = fs.path.dirname(path)
if dir_path and not self._tmpfs.exists(dir_path):
self._tmpfs.makedirs(dir_path)
self._tmpfs.settext(path, content)
if self._verbose:
print(" >>", path)
print(content)
print()
def open(self):
if not self._tmpfs:
self._tmpfs = fs.tempfs.TempFS("genconfdrv", auto_clean=True)
def _write_metadata(self):
if not self._hostname:
raise ValueError("No hostname set")
meta_data = {
# "availability_zone": "cat",
"files": [],
"hostname": self._hostname,
"name": self._hostname.split(".")[0],
# "meta": {
# "role": "webservers",
# "essential": False,
# }
"uuid": str(uuid.uuid4()),
}
if self._interfaces:
# add the source-directory to interfaces
self._interfaces.extend([
"",
"source-directory /etc/network/interfaces.d/",
"",
])
meta_data["files"].append({"content_path": "/content/0000", "path": "/etc/network/interfaces"})
self.add_text("/openstack/content/0000", "\n".join(self._interfaces))
meta_data["files"].append({"content_path": "/content/0001",
"path": "/etc/cloud/cloud.cfg.d/99-disable-network-config.cfg"})
self.add_text("/openstack/content/0001", "network: {config: disabled}")
# do not look for datasource on every boot
if self._clean_metadata:
meta_data["files"].append({"content_path": "/content/0002",
"path": "/etc/cloud/cloud.cfg.d/99-manual-cache-clean.cfg"})
self.add_text("/openstack/content/0002", "manual_cache_clean: True")
if self._pubkeys:
meta_data["public_keys"] = {}
for n, key in enumerate(self._pubkeys):
meta_data["public_keys"]["key-%02d" % n] = key
self.add_text("/openstack/latest/meta_data.json", json.dumps(meta_data, indent=4))
def enable_upgrades(self):
self._user_data["package_update"] = True
self._user_data["package_upgrade"] = True
def add_command(self, command, boot=True):
key = "bootcmd" if boot else "runcmd"
if key not in self._user_data:
self._user_data[key] = []
self._user_data[key].append(command)
def add_pubkey(self, pubkey):
self._pubkeys.append(pubkey)
def set_password(self, user, password):
if "chpasswd" not in self._user_data:
self._user_data["chpasswd"] = {}
self._user_data["chpasswd"]["list"] = ""
# self._user_data["chpasswd"]["list"] = []
# self._user_data["chpasswd"]["list"].append("%s:%s" % (user, password))
self._user_data["chpasswd"]["list"] += "%s:%s\n" % (user, password)
def _write_userdata(self):
self.add_text("/openstack/latest/user_data", "#cloud-config\n" + json.dumps(self._user_data, indent=4))
def write_drive(self, path, fmt):
self._write_metadata()
self._write_userdata()
if fmt == "iso":
self._write_iso(path)
elif fmt == "tgz":
self._write_tgz(path)
else:
raise ValueError("Unknown format")
def _write_iso(self, path):
p = subprocess.Popen([self._genisoimage,
"-J", "-r", "-q",
"-V", "config-2",
"-publisher", "seba-genconfdrv"
"-l", "-ldots", "-allow-lowercase", "-allow-multidot",
"-input-charset", "utf-8",
"-o", path,
self._tmpfs.getsyspath(""),
])
return p.wait()
def _write_tgz(self, path):
p = subprocess.Popen(["tar", "cfz", path, "-C", self._tmpfs.getsyspath(""), "."])
return p.wait()
def close(self):
if self._tmpfs:
self._tmpfs.close()
# defaults for testing
# cfgdrv.set_hostname("foo.someserver.de")
# cfgdrv.conf_network("ens3", "172.23.0.4/24", "172.23.0.1")
# cfgdrv.conf_resolve(["1.1.1.1", "8.8.8.8"])
# cfgdrv.enable_upgrades()
# cfgdrv.add_command("rm -rf /home/debian/; userdel debian; groupdel debian", True)
# cfgdrv.add_command("cloud-init single --name cc_resolv_conf", True)
# cfgdrv.add_command("rm -f /etc/network/interfaces.d/eth*.cfg", True)
# cfgdrv.add_command("sed -rni '/^([^#]|## template)/p' /etc/cloud/templates/sources.list.*.tmpl; "
# "rm /etc/apt/sources.list.d/*", True)
# #cfgdrv.add_command("(whoami; date) > /root/bleep", False)
# cfgdrv.add_pubkey("ssh-rsa bleep foo")
# cfgdrv.set_password("root", "kitteh")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-H", "--hostname", required=True, help="Hostname")
parser.add_argument("-o", "--output", required=True, help="Path to write iso to")
parser.add_argument("-n", "--nameservers", "--ns", default=["1.1.1.1", "8.8.8.8"], nargs="+", help="Nameservers")
parser.add_argument("-i", "--networks", "--net", default=[], nargs="+",
help="Specify all networks, in format of interface[:address[:gateway[:route-gateway[:...]]]]. "
"Both : and ; can be used as delimiter (but only one per net config). "
"Address MUST be a network in CIDR notation or dhcp for DHCP mode. "
"Additional routes can be added in the form of cidr-gateway, e.g. "
"10.0.0.0/8-10.0.0.1")
parser.add_argument("-u", "--disable-upgrades", action="store_true", default=False)
parser.add_argument("-v", "--verbose", action="store_true", default=False)
parser.add_argument("--no-debian-cleanup", "--ndc", action="store_true", default=False)
parser.add_argument("--no-debian-sources-cleanup", "--ndsc", action="store_true", default=False)
parser.add_argument("--no-remove-cloud-init", action="store_true", default=False,
help="Do not purge cloud-init from system after execution")
parser.add_argument("--set-root-password", "--srp", default=None)
parser.add_argument("-a", "--add-user", default=[], nargs="+",
help="Add users, format is username:key?:sudo?:gecos?:password?, "
"sudo is a bool, key is either an ssh key or a path to an ssh key")
parser.add_argument("-f", "--format", default=None, choices=('tgz', 'iso'),
help="Specify output format, default is to infer from output file extension")
args = parser.parse_args()
if not args.format:
if args.output.endswith(".tar.gz") or args.output.endswith(".tgz"):
args.format = "tgz"
elif args.output.endswith(".iso"):
args.format = "iso"
else:
parser.error("Could not infer output format from output file extension")
cfgdrv = None
try:
cfgdrv = ConfigDrive(verbose=args.verbose)
cfgdrv.set_hostname(args.hostname)
for net in args.networks:
if ";" in net:
net = net.split(";")
else:
net = net.split(":")
cfgdrv.conf_network(*net)
if args.nameservers:
cfgdrv.conf_resolve(args.nameservers)
if not args.disable_upgrades:
cfgdrv.enable_upgrades()
if not args.no_debian_cleanup:
cfgdrv.add_command("rm -f /etc/network/interfaces.d/eth*", True)
cfgdrv.add_command("sed -rni '/^([^#]|## template)/p' /etc/cloud/templates/sources.list.*.tmpl", True)
cfgdrv.add_command("sed -rni '/^([^#]|## template)/p' "
"/etc/resolv.conf /etc/cloud/templates/resolv.conf.tmpl", True)
if not args.no_debian_sources_cleanup:
cfgdrv.add_command("rm /etc/apt/sources.list.d/*", True)
if args.set_root_password:
cfgdrv.set_password("root", args.set_root_password)
if args.add_user:
for user in args.add_user:
user = user.split(":")
# user key sudo gecos password
if len(user) < 2:
parser.error("Missing key parameter for user")
keys = ""
if len(user) >= 2:
if user[1].startswith("ssh-"):
keys = [user[1]]
else:
with open(os.path.expanduser(user[1])) as keyfile:
keys = keyfile.read().split("\n")
sudo = True
if len(user) >= 3:
sudo = user[2] not in (False, 0, "0", "no", "false", "False")
gecos = None
if len(user) >= 4:
gecos = user[3]
password = None
if len(user) >= 5:
password = user[4]
cfgdrv.add_user(user[0], keys, sudo=sudo, gecos=gecos, password=password)
if not args.no_remove_cloud_init:
cfgdrv.add_command("apt remove -y cloud-init")
if args.output:
cfgdrv.write_drive(args.output, args.format)
finally:
if cfgdrv:
cfgdrv.close()
if __name__ == '__main__':
main()