#!/usr/bin/env python3 # -*- coding: utf-8 -*- # # 2010-2011 Nico Schottelius (nico-cdist at schottelius.org) # # This file is part of cdist. # # cdist 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, either version 3 of the License, or # (at your option) any later version. # # cdist 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 cdist. If not, see . # # import argparse import logging import os import subprocess import shutil import sys import tempfile BANNER = """ .. . .x+=:. s dF @88> z` ^% :8 '88bu. %8P . is an object if content == DOT_CDIST: object_paths.append(starting_point) return object_paths def get_type_from_object(self, cdist_object): """Returns the first part (i.e. type) of an object""" return cdist_object.split(os.sep)[0] def get_object_id_from_object(self, cdist_object): """Returns everything but the first part (i.e. object_id) of an object""" return os.sep.join(cdist_object.split(os.sep)[1:]) def object_dir(self, cdist_object): """Returns the full path to the object (including .cdist)""" return os.path.join(self.object_base_dir, cdist_object, DOT_CDIST) def remote_object_dir(self, cdist_object): """Returns the remote full path to the object (including .cdist)""" return os.path.join(REMOTE_OBJECT_DIR, cdist_object, DOT_CDIST) def object_parameter_dir(self, cdist_object): """Returns the dir to the object parameter""" return os.path.join(self.object_dir(cdist_object), "parameter") def remote_object_parameter_dir(self, cdist_object): """Returns the remote dir to the object parameter""" return os.path.join(self.remote_object_dir(cdist_object), "parameter") def object_code_paths(self, cdist_object): """Return paths to code scripts of object""" return [os.path.join(object_dir(cdist_object), "code-local"), os.path.join(object_dir(cdist_object), "code-remote")] def list_objects(self, starting_point = False): """Return list of existing objects""" if not starting_point: starting_point = self.object_base_dir object_paths = self.list_object_paths(starting_point) objects = [] log.debug("Paths recieved: %s", object_paths) for path in object_paths: objects.append(os.path.relpath(path, starting_point)) return objects def type_explorer_dir(self, type): """Return directory that holds the explorers of a type""" return os.path.join(TYPE_DIR, type, "explorer") def type_gencode_paths(self, type): """Return paths to gencode scripts of type""" return [os.path.join(TYPE_DIR, type, "gencode-local"), os.path.join(TYPE_DIR, type, "gencode-remote")] def type_manifest_path(self, type): """Return path to manifest of type""" return os.path.join(TYPE_DIR, type, "manifest") def remote_type_explorer_dir(self, type): """Return remote directory that holds the explorers of a type""" return os.path.join(REMOTE_TYPE_DIR, type, "explorer") def transfer_object_parameter(self, cdist_object): """Transfer the object parameter to the remote destination""" # Create base path before using mkdir -p self.remote_mkdir(self.remote_object_parameter_dir(cdist_object)) # Synchronise parameter dir afterwards self.transfer_dir(self.object_parameter_dir(cdist_object), self.remote_object_parameter_dir(cdist_object)) def transfer_global_explorers(self): """Transfer the global explorers""" self.transfer_dir(GLOBAL_EXPLORER_DIR, REMOTE_GLOBAL_EXPLORER_DIR) def transfer_type_explorers(self, type): """Transfer explorers of a type, but only once""" if type in self.type_explorers_transferred: log.debug("Skipping retransfer for %s", type) return else: # Do not retransfer self.type_explorers_transferred[type] = 1 src = self.type_explorer_dir(type) remote_base = os.path.join(REMOTE_TYPE_DIR, type) dst = self.remote_type_explorer_dir(type) # Only continue, if there is at least the directory if os.path.isdir(src): # Ensure that the path exists self.remote_mkdir(remote_base) self.transfer_dir(src, dst) def link_type_to_emulator(self): """Link type names to cdist-type-emulator""" for type in list_types(): source = os.path.join(LIB_DIR, "cdist-type-emulator") destination = os.path.join(self.bin_dir, type) log.debug("Linking %s to %s", source, destination) os.symlink(source, destination) def run_global_explores(self): """Run global explorers""" explorers = self.list_global_explorers() if(len(explorers) == 0): self.exit_error("No explorers found in", GLOBAL_EXPLORER_DIR) self.transfer_global_explorers() for explorer in explorers: output = self.global_explorer_output_path(explorer) output_fd = open(output, mode='w') cmd = [] cmd.append("__explorer=" + REMOTE_GLOBAL_EXPLORER_DIR) cmd.append(self.remote_global_explorer_path(explorer)) self.run_or_fail(cmd, stdout=output_fd, remote=True) output_fd.close() def run_type_explorer(self, cdist_object): """Run type specific explorers for objects""" # Based on bin/cdist-object-explorer-run # Transfering explorers for this type type = self.get_type_from_object(cdist_object) self.transfer_type_explorers(type) cmd = [] # FIXME: __global::__object_id::__self:: cmd.append("__explorer=" + REMOTE_GLOBAL_EXPLORER_DIR) cmd.append("__type_explorer=" + self.remote_type_explorer_dir(type)) # Need to transfer at least the parameters for objects to be useful self.transfer_object_parameter(cdist_object) cmd.append("__object=" + self.remote_object_dir(cdist_object)) explorers = self.list_type_explorers(type) for explorer in explorers: remote_cmd = cmd + [os.path.join(self.remote_type_explorer_dir(type), explorer)] output = os.path.join(self.type_explorer_output_dir(cdist_object), explorer) output_fd = open(output, mode='w') self.run_or_fail(remote_cmd, stdout=output_fd, remote=True) output_fd.close() def init_deploy(self): log.info("Creating clean directory structure") # Ensure there is no old stuff, neither local nor remote # remote_run_or_fail(hostname, ["rm -rf", "${__cdist_remote_base_dir}"]) # # # Create base directories # remote_run_or_fail(hostname,["mkdir -p", "${__cdist_remote_base_dir}"]) # # # Link configuraion source directory - consistent with remote # run_or_fail(["ln -sf", "$__cdist_conf_dir", "$__cdist_local_base_dir/$__cdist_name_conf_dir"]) def run_initial_manifest(self): """Run the initial manifest""" env = { "__manifest" : MANIFEST_DIR } self.run_manifest(self.initial_manifest, extra_env=env) def run_type_manifest(self, cdist_object): """Run manifest for a specific object""" type = self.get_type_from_object(cdist_object) manifest = self.type_manifest_path(type) # FIXME: add more sensible checks for manifest if os.path.exists(manifest): env = { "__object" : self.object_dir(cdist_object), "__object_id": self.get_object_id_from_object(cdist_object), "__object_fq": cdist_object, "__type": type } self.run_manifest(manifest, extra_env=env) def run_manifest(self, manifest, extra_env=None): """Run a manifest""" log.info("Running manifest %s, env=%s", manifest, extra_env) env = os.environ.copy() env['PATH'] = self.bin_dir + ":" + env['PATH'] env['__target_host'] = self.target_host env['__global'] = self.out_dir # Legacy stuff to make cdist-type-emulator work env['__cdist_conf_dir'] = CONF_DIR env['__cdist_core_dir'] = os.path.join(BASE_DIR, "core") env['__cdist_local_base_dir'] = self.temp_dir env['__cdist_manifest'] = self.initial_manifest # Other environment stuff if extra_env: env.update(extra_env) self.shell_run_or_debug_fail(manifest, [manifest], env=env) def run_object_gencode(self, cdist_object): """Run the gencode scripts for the object""" log.info("Running manifest %s, env=%s", manifest, extra_env) env = os.environ.copy() env['__target_host'] = self.target_host env['__global'] = self.out_dir # FIXME: if -local, -remote... # Other environment stuff if extra_env: env.update(extra_env) self.shell_run_or_debug_fail(manifest, [manifest], env=env) def object_run(self, cdist_object, mode): """Run gencode or code for an object""" # FIXME: Check requirements and execute those before requirements = list_object_requirements(cdist_object) for requirement in requirements: object_run(requirement, mode=mode) # Find and run all available gencode scripts if mode == "gencode": base_path = object_dir if mode == "code": # FIXME: to be implemented # cdist-object-gencode-run "$__cdist_target_host" "$__cdist_object_self" # cdist-object-code-run "$__cdist_target_host" "$__cdist_object_self" self.run_type_explorer(cdist_object) self.run_type_manifest(cdist_object) def deploy_to(self): """Mimic the old deploy to: Deploy to one host""" log.info("Deploying to host " + self.target_host) self.init_deploy() self.run_global_explores() self.run_initial_manifest() old_objects = [] objects = self.list_objects() # Continue process until no new objects are created anymore while old_objects != objects: log.debug("Prepare stage") old_objects = list(objects) # FIXME: do not rerun existing objects! for cdist_object in objects: self.run_type_explorer(cdist_object) self.run_type_manifest(cdist_object) objects = self.list_objects() # Now do the final steps over the existing objects for cdist_object in objects: object_run(cdist_object, mode="gencode") object_run(cdist_object, mode="code") if __name__ == "__main__": parser = argparse.ArgumentParser(description='cdist ' + VERSION) parser.add_argument('host', nargs='*', help='one or more hosts to operate on') parser.add_argument('-b', '--banner', help='Show cdist banner', action='store_true', dest='banner') parser.add_argument('-d', '--debug', help='Set log level to debug', action='store_true') parser.add_argument('-i', '--initial-manifest', help='Path to a cdist manifest or - to read from stdin', dest='manifest', required=False) parser.add_argument('-p', '--parallel', help='Operate on multiple hosts in parallel', action='store_true', dest='parallel') parser.add_argument('-s', '--sequential', help='Operate on multiple hosts sequentially', action='store_false', dest='parallel') args = parser.parse_args(sys.argv[1:]) if args.debug: logging.root.setLevel(logging.DEBUG) if args.banner: banner() sys.exit(0) try: log.debug(args) for host in args.host: c = Cdist(host, initial_manifest=args.manifest) c.deploy_to() c.cleanup() except KeyboardInterrupt: sys.exit(0)