def versions():
"""
Display all the versions
"""
import pkg_resources
"""print versions of all installed modules"""
print "* Archipel Agent version :"
format_version(("archipelagent", pkg_resources.get_distribution("archipel-agent").version))
print "\n* Installed plugins versions :"
for version_method in pkg_resources.iter_entry_points(group="archipel.plugin", name="version"):
try:
method = version_method.load()
format_version(method())
except Exception as ex:
error("unable to get the version of one plugin: %s" % ex, exit=False)
sys.exit(ARCHIPEL_INIT_SUCCESS)
def initialize_config(paths, cmdline_path="/proc/cmdline", prepare_only=False):
"""
Initialize the ConfigParser object
@type paths: list
@param paths: list of the path of the config files
@type cmdline_path: string
@param cmdline_path: the path of kernel param file
@type prepare_only: Boolean
@param prepare_only: if True, we will exit after preparing the config.
@rtype: ConfigParser
@return: ready to use config object
"""
# Read the local config file(s)
try:
config = init_conf(paths)
except Exception as ex:
error("Unable to read local configuration file(s) %s : %s" % (str(paths), str(ex)), code=ARCHIPEL_INIT_ERROR_NO_CONFIG)
# If we are in a stateless mode, read the stateless node configuration from the kernel parameters
if config.has_option("GLOBAL", "stateless_node") and config.getboolean("GLOBAL", "stateless_node"):
try:
msg("Archipel is configured to start in stateless mode")
# Get Kernel parameters
stateless_mode_parameters = stateless_read_kernel_parameters(cmdline_path)
p_mount_type = stateless_mode_parameters["ARCHIPEL_MOUNT_TYPE"]
p_mount_address = stateless_mode_parameters["ARCHIPEL_MOUNT_ADDRESS"]
p_mount_options = stateless_mode_parameters["ARCHIPEL_MOUNT_OPTIONS"]
p_mount_mountpoint = stateless_mode_parameters["ARCHIPEL_MOUNT_MOUNTPOINT"]
p_stateless_path = stateless_mode_parameters["ARCHIPEL_STATELESS_PATH"]
p_stateless_lib_path = stateless_mode_parameters["ARCHIPEL_STATELESS_LIB_PATH"]
p_stateless_qemu_path = stateless_mode_parameters["ARCHIPEL_STATELESS_QEMU_PATH"]
p_stateless_config_path = stateless_mode_parameters["ARCHIPEL_STATELESS_CONFIG_PATH"]
p_stateless_config_path_general = stateless_mode_parameters["ARCHIPEL_STATELESS_CONFIG_PATH_GENERAL"]
p_stateless_config_path_local = stateless_mode_parameters["ARCHIPEL_STATELESS_CONFIG_PATH_LOCAL"]
p_selinux_enforce = stateless_mode_parameters["ARCHIPEL_SELINUX_MODE"]
p_post_script = stateless_mode_parameters["ARCHIPEL_POST_SCRIPT"]
# selinux
msg("Setting selinux in mode %s" % p_selinux_enforce)
os.system("if test -x `which setenforce`; then setenforce %s; fi" % p_selinux_enforce)
# Print informations
msg("Information from /proc/cmdline read:")
for k, v in stateless_mode_parameters.items():
msg(" - %s: %s" % (k, v))
# get current state
current_mounts = file.read(open("/proc/mounts"))
# Mount remote filestem
was_not_stateless_mounted = stateless_mount_storage(current_mounts, p_mount_type, p_mount_address, p_mount_options, p_mount_mountpoint)
# Create remote folders if needed
paths = [p_stateless_path, p_stateless_lib_path, p_stateless_qemu_path, p_stateless_config_path]
for path in paths:
if not os.path.exists(path):
msg("Creating solid state path %s" % path)
os.makedirs(path)
# Mount --bind the /etc/libvirt/qemu to the solid state path
if was_not_stateless_mounted and "/etc/libvirt/qemu" in current_mounts:
msg("Umounting /etc/libvirt/qemu")
subprocess.check_call(["umount", "/etc/libvirt/qemu"])
if not "/etc/libvirt/qemu" in current_mounts or was_not_stateless_mounted:
msg("Mounting /etc/libvirt/qemu on %s" % p_stateless_qemu_path)
subprocess.check_call(["mount", "--bind", p_stateless_qemu_path, "/etc/libvirt/qemu"])
# We reload the libvirt
try:
if os.path.exists("/bin/systemctl") or os.path.exists("/sbin/systemctl"):
subprocess.check_call(["systemctl", "reload", "libvirtd.service"])
msg("Libvirt restarted using systemctl")
elif os.path.exists("/sbin/service"):
subprocess.check_call(["service", "libvirtd", "restart"])
msg("Libvirt restarted using service")
elif os.path.exists("/etc/init.d/libvirtd"):
subprocess.check_call(["/etc/init.d/libvirtd", "restart"])
msg("Libvirt restarted using /etc/init.d/libvirtd")
except:
msg("Libvirtd: Not any service file found. Restarted libvirtd like a boss")
os.system("killall libvirtd")
os.system("libvirtd --daemon")
else:
msg("/etc/libvirt/qemu is already mounted on %s. Ignored" % p_stateless_qemu_path)
# We start the post script if any
if p_post_script and os.path.exists(p_post_script):
msg("Running post mount script from %s" % p_post_script)
subprocess.check_call("%s %s %s" % (p_post_script, socket.gethostname(), " ".join(stateless_mode_parameters)), shell=True)
msg("Post mount script sucessfully ran")
# We set the hostname here because the post mount script may have changed it.
if not p_stateless_config_path_local:
p_stateless_config_path_local = os.path.join(p_stateless_config_path, "archipel.%s.conf" % socket.gethostname())
# Reinitialize the configuration according to the kernel parameters about remote config
msg("Re-read the configuration files %s" % (str([p_stateless_config_path_general, p_stateless_config_path_local])))
config_files = [p_stateless_config_path_general]
if os.path.exists(p_stateless_config_path_local):
msg("Found local config file at %s" % p_stateless_config_path_local)
config_files.append(p_stateless_config_path_local)
else:
msg("Local config file at %s doesn't exist. ignoring it." % p_stateless_config_path_local)
config = init_conf(config_files)
msg("Configuration reloaded")
if prepare_only:
success("Prepare only mode. exiting")
sys.exit(ARCHIPEL_INIT_SUCCESS)
success("Stateless configuration ready")
except Exception as ex:
error("Stateless node initialization error: %s" % str(ex), code=ARCHIPEL_INIT_ERROR_STATELESS_MODE)
return config