def op_remove_build(): validate_input() if not Utils.confirm("You are about to remove Marathon build for {}.".format( MarathonConfig.marathon_version() )): LOG.info("You have cancelled the action.") exit(0) Utils.cmd("rm -rf {}/{}".format( MarathonConfig.packages_dir(), MarathonConfig.marathon_version()))
def op_remove_build(): validate_input() if not Utils.confirm("You are about to remove Mesos build for {} {}.".format( MesosConfig.mesos_version(), MesosConfig.operating_system() )): exit(0) Utils.cmd("rm -rf {}/{}-{}".format( MesosConfig.packages_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-")))
def op_build(): validate_input() if Utils.ensure_sources(LOG, MesosConfig.mesos_repository_dir(), MesosConfig.mesos_git_repository()) and ensure_deb_packaging(): # create temp work dir: build_dir_mesos = "{}/{}-{}".format( MesosConfig.work_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-") ) build_dir_packaging = "{}/{}-{}-packaging".format( MesosConfig.work_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-") ) packages_dir = "{}/{}-{}".format( MesosConfig.packages_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-") ) if os.path.exists(packages_dir): if not Utils.confirm("Mesos build for {} {} already exists. To rebuild, continue.".format( MesosConfig.mesos_version(), MesosConfig.operating_system() )): LOG.info("You have cancelled the action.") exit(0) build_log_file = "{}.{}.log".format(build_dir_mesos, str(int(time.time()))) LOG.info("Recording build process to {}.".format(build_log_file)) Config.set_cmd_log(build_log_file) # cleanup old data: Utils.cmd("rm -rf {}".format(packages_dir)) Utils.cmd("rm -rf {}".format(build_dir_mesos)) Utils.cmd("rm -rf {}".format(build_dir_packaging)) # copy sources LOG.info("Fetching Mesos {} sources...".format(MesosConfig.mesos_git_repository())) Utils.cmd("cp -R {} {}".format( MesosConfig.mesos_repository_dir(), build_dir_mesos )) Utils.cmd("cp -R {} {}".format( MesosConfig.deb_packaging_repository_dir(), build_dir_packaging )) apply_packaging_patches(build_dir_packaging) # ensure branch / tag Utils.exit_if_git_release_not_set( LOG, build_dir_mesos, MesosConfig.mesos_version(), MesosConfig.mesos_master_branch(), MesosConfig.mesos_git_repository() ) apply_mesos_patches(build_dir_mesos) # We have the right sources now: if MesosConfig.operating_system() == "osx": build_with_osx( build_dir_mesos, build_dir_packaging, packages_dir ) else: build_with_docker( build_dir_mesos, build_dir_packaging, packages_dir )
def apply_mesos_patches(build_dir_mesos): ## LOOKUP order: # - <mesos-version>-<os-family>-<os-version> # - <mesos-version>-<os-family> # - <mesos-version> patch_files = [ "{}/{}-{}.patch".format( MesosConfig.mesos_patches_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-") ), "{}/{}-{}.patch".format( MesosConfig.mesos_patches_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().split(":")[0] ), "{}/{}.patch".format( MesosConfig.mesos_patches_dir(), MesosConfig.mesos_version() ) ] patch_file_to_use = None for patch_file in patch_files: if os.path.isfile(patch_file): patch_file_to_use = patch_file break if patch_file_to_use != None: LOG.info("Found a patch file {} for mesos. Applying...".format( patch_file_to_use )) result = Utils.cmd("cd {} && git apply {}".format(build_dir_mesos, patch_file_to_use)) if result['ExitCode'] != 0: Utils.print_result_error(LOG, "Patch could not be applied to {}.".format( build_dir_mesos ), result) exit(105) else: LOG.info("Patch applied.") else: LOG.info("No patches for mesos {}.".format( MesosConfig.deb_packaging_sha() ))
def list_releases(): result = Utils.cmd("cd {} && git tag -l".format(MesosConfig.mesos_repository_dir())) if result['ExitCode'] == 0: releases = result['StdOut'].split("\n") releases.append(MesosConfig.mesos_master_branch()) return releases else: Utils.print_result_error(LOG, "Failed listing releases.", result) return []
def ensure_sources(): path = MesosConfig.mesos_repository_dir() if os.path.isdir("{}/.git".format(path)): LOG.info("Updating sources for {}...".format(MesosConfig.mesos_git_repository())) result = Utils.cmd("cd {} && git fetch origin".format(path)) if result['ExitCode'] == 0: LOG.info("Done.") return True else: Utils.print_result_error(LOG, "Failed.", result) return False else: LOG.info("No sources for {} found. Cloning...".format(MesosConfig.mesos_git_repository())) result = Utils.cmd("cd {} && git clone {} .".format(path, MesosConfig.mesos_git_repository())) if result['ExitCode'] == 0: LOG.info("Done.") return True else: Utils.print_result_error(LOG, "Failed.", result) return False
def vagrant_command(cmd): validate_input() signal.signal(signal.SIGINT, signal_handler) base = os.path.dirname(os.path.abspath(__file__)) command = "cd {}/vagrant".format(base) exports = get_exports_from_config() first_master_ip = exports['MASTER_IPS'].split(',')[0] for key, value in exports.iteritems(): command = "{}; export {}={}".format(command, key, value) command = "{}; vagrant {}".format(command, cmd) if VagrantConfig.machine() != "": command = "{} {}".format(command, VagrantConfig.machine()) result = Utils.cmd(command, True) if result['ExitCode'] != 0: Utils.print_result_error(LOG, "Vagrant command execution has failed.", result) else: if cmd == "up": LOG.info("You cluster is up and running \\o/.") LOG.info("- to access the Mesos UI, point your browser to: http://{}:5050".format(first_master_ip)) LOG.info("- to access the Consul UI, point your browser to: http://{}:8500".format(first_master_ip)) LOG.info("- to access the Marathon UI, point your browser to: http://{}:8080".format(first_master_ip))
def ensure_deb_packaging(): path = MesosConfig.deb_packaging_repository_dir() if os.path.isdir("{}/.git".format(path)): LOG.info("Updating sources for {}...".format(MesosConfig.deb_packaging_repository())) # TODO: compare given sha and repo sha # TODO: if different, reset, pull, checkout # TODO: apply patches for deb-packaging, if any... LOG.info("Done.") return True else: LOG.info("No sources for {} found. Cloning...".format(MesosConfig.deb_packaging_repository())) result = Utils.cmd("cd {} && git clone {} . && git fetch origin && git checkout {}".format( path, MesosConfig.deb_packaging_repository(), MesosConfig.deb_packaging_sha() )) if result['ExitCode'] == 0: LOG.info("Done.") # TODO: apply patches for deb-packaging, if any... return True else: Utils.print_result_error(LOG, "Failed.", result) return False
def build_with_docker(build_dir_mesos, build_dir_packaging, packages_dir): image_name = "mesos-docker-build-{}".format(MesosConfig.operating_system().replace(":","-")) if not Utils.is_docker_image(LOG, image_name): LOG.info("Docker image not found. Building...") Utils.exit_if_docker_image_not_built( LOG, MesosConfig.docker_templates_dir(), MesosConfig.operating_system().replace(":", "\\:"), image_name ) mesos_build_command = "docker run -ti -v {}:/mesos-deb-packaging -v {}:/mesos-src {} /bin/bash -c 'cd /mesos-deb-packaging && ./build_mesos --build-version {} --src-dir /mesos-src; exit $?'".format( build_dir_packaging, build_dir_mesos, image_name, MesosConfig.mesos_build_version() ) Utils.cmd("echo '{}'".format(mesos_build_command.replace("'", "\\'"))) LOG.info("Building Mesos {} for {}. This will take a while...".format(MesosConfig.mesos_version(), MesosConfig.operating_system())) build_start_time = int(time.time()) build_status = Utils.cmd(mesos_build_command) build_end_time = int(time.time()) if build_status['ExitCode'] == 0: Utils.cmd("mkdir -p {0} && rm -Rf {0}/*".format( packages_dir )) Utils.cmd("mv {}/*.deb {}/ 2>/dev/null".format( build_dir_packaging, packages_dir )) Utils.cmd("mv {}/*.rpm {}/ 2>/dev/null".format( build_dir_packaging, packages_dir )) Utils.cmd("mv {}/*.egg {}/ 2>/dev/null".format( build_dir_packaging, packages_dir ))# LOG.info( "Mesos {} for {} built successfully. Build took {} seconds. Output available in {}. Cleaning up...".format( MesosConfig.mesos_version(), MesosConfig.operating_system(), str( build_end_time - build_start_time ), packages_dir )) Utils.cmd("rm -rf {}".format(build_dir_mesos)) Utils.cmd("rm -rf {}".format(build_dir_packaging)) else: LOG.error( "Mesos build failed. Leaving build log and temp directories for inspection. mesos={}; packaging={}".format( build_dir_mesos, build_dir_packaging ) ) exit(107)
def op_build(): if Utils.ensure_sources(LOG, MesosConfig.mesos_repository_dir(), MesosConfig.mesos_git_repository()) and ensure_deb_packaging(): validate_input() # create temp work dir: build_dir_mesos = "{}/{}-{}".format( MesosConfig.work_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-") ) build_dir_packaging = "{}/{}-{}-packaging".format( MesosConfig.work_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-") ) packages_dir = "{}/{}-{}".format( MesosConfig.packages_dir(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-") ) ## LOOKUP order: # - <sha>-<mesos-version>-<os-family>-<os-version> # - <sha>-<mesos-version>-<os-family> # - <sha>-<os-family>-<os-version> # - <sha>-<os-family> # - <sha> patch_files = [ "{}/{}-{}-{}.patch".format( MesosConfig.packages_patches_dir(), MesosConfig.deb_packaging_sha(), MesosConfig.mesos_version(), MesosConfig.operating_system().replace(":", "-") ), "{}/{}-{}-{}.patch".format( MesosConfig.packages_patches_dir(), MesosConfig.deb_packaging_sha(), MesosConfig.mesos_version(), MesosConfig.operating_system().split(":")[0] ), "{}/{}-{}.patch".format( MesosConfig.packages_patches_dir(), MesosConfig.deb_packaging_sha(), MesosConfig.operating_system().replace(":", "-") ), "{}/{}-{}.patch".format( MesosConfig.packages_patches_dir(), MesosConfig.deb_packaging_sha(), MesosConfig.operating_system().split(":")[0] ), "{}/{}.patch".format( MesosConfig.packages_patches_dir(), MesosConfig.deb_packaging_sha() ) ] if os.path.exists(packages_dir): if not Utils.confirm("Mesos build for {} {} already exists. To rebuild, continue.".format( MesosConfig.mesos_version(), MesosConfig.operating_system() )): exit(0) build_log_file = "{}.{}.log".format(build_dir_mesos, str(int(time.time()))) LOG.info("Recording build process to {}.".format(build_log_file)) Config.set_cmd_log(build_log_file) # cleanup old data: Utils.cmd("rm -rf {}".format(packages_dir)) Utils.cmd("rm -rf {}".format(build_dir_mesos)) Utils.cmd("rm -rf {}".format(build_dir_packaging)) # copy sources LOG.info("Fetching Mesos {} sources...".format(MesosConfig.mesos_git_repository())) Utils.cmd("cp -R {} {}".format( MesosConfig.mesos_repository_dir(), build_dir_mesos )) Utils.cmd("cp -R {} {}".format( MesosConfig.deb_packaging_repository_dir(), build_dir_packaging )) patch_file_to_use = None for patch_file in patch_files: if os.path.isfile(patch_file): patch_file_to_use = patch_file break if patch_file_to_use != None: LOG.info("Found a patch file {} for mesos-deb-packaging. Applying...".format( patch_file_to_use )) result = Utils.cmd("cd {} && git apply {}".format(build_dir_packaging, patch_file_to_use)) if result['ExitCode'] != 0: Utils.print_result_error(LOG, "Patch could not be applied to {}.".format( build_dir_packaging ), result) exit(105) else: LOG.info("Patch applied.") else: LOG.info("No patches for mesos-deb-packaging {}.".format( MesosConfig.deb_packaging_sha() )) # ensure branch / tag Utils.exit_if_git_release_not_set( LOG, build_dir_mesos, MesosConfig.mesos_version(), MesosConfig.mesos_master_branch(), MesosConfig.mesos_git_repository() ) # We have the right sources now: if MesosConfig.operating_system() == "osx": build_with_osx( build_dir_mesos, build_dir_packaging, packages_dir ) else: build_with_docker( build_dir_mesos, build_dir_packaging, packages_dir )
def mesos_repository_dir(): from lib.config import Config path = "{}/mesos/{}".format( Config.args().source_dir, MesosConfig.mesos_git_repository_md5() ) Utils.cmd("mkdir -p {}".format(path)) return path
def packages_dir(): from lib.config import Config path = "{}/mesos".format(Config.args().packages_dir) Utils.cmd("mkdir -p {}".format(path)) return path
def op_remove_sources(): if not Utils.confirm("You are about to remove Marathon sources for {}.".format( MarathonConfig.marathon_git_repository() )): exit(0) Utils.cmd("rm -rf {}".format( MarathonConfig.marathon_repository_dir() ))
def op_build(): validate_input() if Utils.ensure_sources(LOG, ChronosConfig.chronos_repository_dir(), ChronosConfig.chronos_git_repository()): image_name = "chronos-docker-build" if not Utils.is_docker_image(LOG, image_name): LOG.info("Docker image not found. Building...") Utils.exit_if_docker_image_not_built( LOG, ChronosConfig.docker_templates_dir(), "default", image_name ) build_dir = "{}/{}".format( ChronosConfig.work_dir(), ChronosConfig.chronos_version() ) packages_dir = "{}/{}".format( ChronosConfig.packages_dir(), ChronosConfig.chronos_version() ) if os.path.exists(packages_dir): if not Utils.confirm("Chronos build for {} already exists. To rebuild, continue.".format( ChronosConfig.chronos_version() )): LOG.info("You have cancelled the action.") exit(0) build_log_file = "{}.{}.log".format(build_dir, str(int(time.time()))) LOG.info("Recording build process to {}.".format(build_log_file)) Config.set_cmd_log(build_log_file) # cleanup old data: Utils.cmd("rm -rf {}".format(packages_dir)) Utils.cmd("rm -rf {}".format(build_dir)) # copy sources LOG.info("Fetching Chronos {} sources...".format(ChronosConfig.chronos_git_repository())) Utils.cmd("cp -R {} {}".format( ChronosConfig.chronos_repository_dir(), build_dir )) # ensure branch / tag Utils.exit_if_git_release_not_set( LOG, build_dir, ChronosConfig.chronos_version(), ChronosConfig.chronos_master_branch(), ChronosConfig.chronos_git_repository() ) chronos_mvn_version = None if os.path.exists("{}/pom.xml".format( build_dir )): chronos_res = Utils.cmd("cat {}/pom.xml | grep '<version>' | head -n1 | sed 's/.*>\\(.*\\)<.*/\\1/' 2>/dev/null".format( build_dir )) if chronos_res['ExitCode'] != 0: LOG.error("Not able to establish Chronos version from the POM file. Can't continue.") exit(112) chronos_mvn_version = chronos_res['StdOut'].strip() else: LOG.error("No pom.xml file for Chronos {}. Can't continue.".format( ChronosConfig.chronos_version() )) exit(110) if chronos_mvn_version == None: LOG.error("Version could not be reliably established from the pom.xml file. Can't continue.") exit(111) LOG.info("Chronos version from Maven: {}".format( chronos_mvn_version )) docker_command = list() docker_command.append("docker run -ti ") docker_command.append("-v {}:/output ".format( os.path.dirname(packages_dir) )) docker_command.append("-v {}:/chronos-src ".format( build_dir )) docker_command.append("-v {}:/root/.m2 ".format( ChronosConfig.m2_dir() )) docker_command.append("-e \"BUILD_CHRONOS_VERSION={}\" ".format( ChronosConfig.chronos_version() )) docker_command.append("-e \"FPM_OUTPUT_VERSION={}\" ".format( chronos_mvn_version )) docker_command.append("-e \"ASSEMBLY_WITH_TESTS={}\" ".format( ChronosConfig.with_tests() )) docker_command.append("{} ".format( image_name )) docker_command.append("/bin/bash -c 'cd /chronos-build && ./chronos-build.sh; exit $?'") build_command = "".join( docker_command ) LOG.info("Docker command: {}".format(build_command)) LOG.info("Building Chronos {}. This will take a while...".format(ChronosConfig.chronos_version())) LOG.info("You can monitor the build with: tail -F {}".format(build_log_file)) build_start_time = int(time.time()) build_status = Utils.cmd(build_command) build_end_time = int(time.time()) if build_status['ExitCode'] == 0: LOG.info( "Chronos {} built successfully. Build took {} seconds. Output available in {}. Cleaning up...".format( ChronosConfig.chronos_version(), str( build_end_time - build_start_time ), packages_dir )) Utils.cmd("rm -rf {}".format(build_dir)) else: LOG.error( "Chronos build failed. Leaving build log and temp directory for inspection. chronos={}".format( build_dir ) ) exit(107)
def op_remove_sources(): if not Utils.confirm("You are about to remove Chronos sources for {}.".format( ChronosConfig.chronos_git_repository() )): LOG.info("You have cancelled the action.") exit(0) Utils.cmd("rm -rf {}".format( ChronosConfig.chronos_repository_dir() ))
def build_with_docker(build_dir_mesos, build_dir_packaging, packages_dir): image_name = "mesos-docker-build-{}".format(MesosConfig.operating_system().replace(":","-")) # Do we have the Docker image? LOG.info("Checking for Docker image...") result = Utils.cmd("docker images") # Simply make sure we have docker operational if result['ExitCode'] != 0: Utils.print_result_error(LOG, "Not able to list Docker images. Is Docker installed and running?", result) exit(105) # repeat, grep returns 1 if text not found result = Utils.cmd("docker images | grep {}".format(image_name)) if result['StdOut'] == "": LOG.info("Docker image not found. Building...") result = Utils.cmd( "cd {}/{} && docker build --no-cache --force-rm=true -t {} .".format( MesosConfig.docker_templates_dir(), MesosConfig.operating_system().replace(":", "\\:"), image_name ) ) if result['ExitCode'] != 0: Utils.print_result_error(LOG, "Docker image creation failed. Is Docker installed and running?", result) exit(106) mesos_build_command = "docker run -ti -v {}:/mesos-deb-packaging -v {}:/mesos-src {} /bin/bash -c 'cd /mesos-deb-packaging && ./build_mesos --build-version {} --src-dir /mesos-src; exit $?'".format( build_dir_packaging, build_dir_mesos, image_name, MesosConfig.mesos_build_version() ) Utils.cmd("echo '{}'".format(mesos_build_command)) LOG.info("Building Mesos {} for {}. This will take a while...".format(MesosConfig.mesos_version(), MesosConfig.operating_system())) build_start_time = int(time.time()) build_status = Utils.cmd(mesos_build_command) build_end_time = int(time.time()) if build_status['ExitCode'] == 0: Utils.cmd("mkdir -p {0} && rm -Rf {0}/*".format( packages_dir )) Utils.cmd("mv {}/*.deb {}/ 2>/dev/null".format( build_dir_packaging, packages_dir )) Utils.cmd("mv {}/*.rpm {}/ 2>/dev/null".format( build_dir_packaging, packages_dir )) Utils.cmd("mv {}/*.egg {}/ 2>/dev/null".format( build_dir_packaging, packages_dir ))# LOG.info( "Mesos {} for {} built successfully. Build took {} seconds. Output available in {}. Cleaning up...".format( MesosConfig.mesos_version(), MesosConfig.operating_system(), str( build_end_time - build_start_time ), packages_dir )) Utils.cmd("rm -rf {}".format(build_dir_mesos)) Utils.cmd("rm -rf {}".format(build_dir_packaging)) else: LOG.error( "Mesos build failed. Leaving build log and temp directories for inspection. mesos={}; packaging={}".format( build_dir_mesos, build_dir_packaging ) ) exit(107)
def build_with_osx(build_dir_mesos, build_dir_packaging, packages_dir): # TODO: provide correct implementation Utils.cmd( "cd {} && ./build_mesos --build-version {} --src-dir {}".format( Config.deb_packaging_repository_dir(), Config.args().mesos_build_version, Config.mesos_repository_dir() ) )
def op_remove_sources(): if not Utils.confirm("You are about to remove Marathon sources for {}.".format( MarathonConfig.marathon_git_repository() )): LOG.info("You have cancelled the action.") exit(0) Utils.cmd("rm -rf {}".format( MarathonConfig.marathon_repository_dir() ))
def op_build(): if Utils.ensure_sources(LOG, MarathonConfig.marathon_repository_dir(), MarathonConfig.marathon_git_repository()): validate_input() image_name = "marathon-docker-build" if not Utils.is_docker_image(LOG, image_name): LOG.info("Docker image not found. Building...") Utils.exit_if_docker_image_not_built( LOG, MarathonConfig.docker_templates_dir(), "default", image_name ) build_dir = "{}/{}".format( MarathonConfig.work_dir(), MarathonConfig.marathon_version() ) packages_dir = "{}/{}".format( MarathonConfig.packages_dir(), MarathonConfig.marathon_version() ) if os.path.exists(packages_dir): if not Utils.confirm("Marathon build for {} already exists. To rebuild, continue.".format( MarathonConfig.marathon_version() )): exit(0) build_log_file = "{}.{}.log".format(build_dir, str(int(time.time()))) LOG.info("Recording build process to {}.".format(build_log_file)) Config.set_cmd_log(build_log_file) # cleanup old data: Utils.cmd("rm -rf {}".format(packages_dir)) Utils.cmd("rm -rf {}".format(build_dir)) # copy sources LOG.info("Fetching Marathon {} sources...".format(MarathonConfig.marathon_git_repository())) Utils.cmd("cp -R {} {}".format( MarathonConfig.marathon_repository_dir(), build_dir )) # ensure branch / tag Utils.exit_if_git_release_not_set( LOG, build_dir, MarathonConfig.marathon_version(), MarathonConfig.marathon_master_branch(), MarathonConfig.marathon_git_repository() ) marathon_sbt_version = None raw_sbt_file_content = None if os.path.exists("{}/version.sbt".format( build_dir )): with open("{}/version.sbt".format( build_dir ), 'r') as sbt_file: raw_sbt_file_content = sbt_file.read().replace('\n', '') match_obj = re.match(r'.*"(.*)".*', raw_sbt_file_content) if match_obj: marathon_sbt_version = match_obj.group(1) else: LOG.error("No version.sbt file for Marathon {}. Can't continue.".format( MarathonConfig.marathon_version() )) exit(110) if marathon_sbt_version == None: LOG.error("Version could not be reliably established from the version.sbt file. Raw content: {}. Can't continue.".format( raw_sbt_file_content )) exit(111) LOG.info("Marathon version from SBT: {}".format( marathon_sbt_version )) # TODO: Actual build build_command = "docker run -ti -v {}:/output -v {}:/marathon-src -v {}:/root/.ivy2 -e \"BUILD_MARATHON_VERSION={}\" -e \"FPM_OUTPUT_VERSION={}\" -e \"ASSEMBLY_WITH_TESTS={}\" {} /bin/bash -c 'cd /marathon-build && ./marathon-build.sh; exit $?'".format( os.path.dirname(packages_dir), build_dir, MarathonConfig.ivy2_dir(), MarathonConfig.marathon_version(), marathon_sbt_version, MarathonConfig.with_tests(), image_name ) Utils.cmd("echo '{}'".format(build_command.replace("'", "\\'"))) LOG.info("Building Marathon {}. This will take a while...".format(MarathonConfig.marathon_version())) build_start_time = int(time.time()) build_status = Utils.cmd(build_command) build_end_time = int(time.time()) if build_status['ExitCode'] == 0: LOG.info( "Marathon {} built successfully. Build took {} seconds. Output available in {}. Cleaning up...".format( MarathonConfig.marathon_version(), str( build_end_time - build_start_time ), packages_dir )) Utils.cmd("rm -rf {}".format(build_dir)) else: LOG.error( "Marathon build failed. Leaving build log and temp directory for inspection. marathon={}".format( build_dir ) ) exit(107)
def marathon_packages_dir(): from lib.config import Config path = "{}/".format(Config.args().marathon_packages_dir) Utils.cmd("mkdir -p {}".format(path)) return path
def marathon_repository_dir(): from lib.config import Config path = "{}/marathon/{}".format( Config.args().source_dir, MarathonConfig.marathon_git_repository_md5() ) Utils.cmd("mkdir -p {}".format(path)) return path
def op_remove_mesos_sources(): if not Utils.confirm("You are about to remove Mesos sources for {}.".format( MesosConfig.mesos_git_repository() )): exit(0) Utils.cmd("rm -rf {}".format( MesosConfig.mesos_repository_dir() ))
def work_dir(): from lib.config import Config Utils.cmd("mkdir -p {}".format(Config.args().work_dir)) return Config.args().work_dir
def op_remove_packaging_sources(): if not Utils.confirm("You are about to remove mesos-deb-packaging sources for {}.".format( MesosConfig.deb_packaging_repository() )): exit(0) Utils.cmd("rm -rf {}".format( MesosConfig.deb_packaging_repository_dir() ))
def deb_packaging_repository_dir(): from lib.config import Config path = "{}/mesos-packaging/{}".format( Config.args().source_dir, MesosConfig.deb_packaging_repository_md5() ) Utils.cmd("mkdir -p {}".format(path)) return path
def op_remove_packaging_sources(): if not Utils.confirm("You are about to remove mesos-deb-packaging sources for {}.".format( MesosConfig.deb_packaging_repository() )): LOG.info("You have cancelled the action.") exit(0) Utils.cmd("rm -rf {}".format( MesosConfig.deb_packaging_repository_dir() ))