Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def rsync_sync(self, repo):
"""
Handle copying of rsync:// and rsync-over-ssh repos.
"""
if not repo.mirror_locally:
utils.die(self.logger, "rsync:// urls must be mirrored locally, yum cannot access them directly")
if repo.rpm_list != "" and repo.rpm_list != []:
self.logger.warning("--rpm-list is not supported for rsync'd repositories")
# FIXME: don't hardcode
dest_path = os.path.join(self.settings.webdir + "/repo_mirror", repo.name)
spacer = ""
if not repo.mirror.startswith("rsync://") and not repo.mirror.startswith("/"):
spacer = "-e ssh"
if not repo.mirror.strip().endswith("/"):
repo.mirror = "%s/" % repo.mirror
# FIXME: wrapper for subprocess that logs to logger
cmd = "rsync -rltDv --copy-unsafe-links --delete-after %s --delete --exclude-from=/etc/cobbler/rsync.exclude %s %s" % (spacer, pipes.quote(repo.mirror), pipes.quote(dest_path))
rc = utils.subprocess_call(self.logger, cmd)
def apt_sync(self, repo):
"""
Handle copying of http:// and ftp:// debian repos.
"""
# warn about not having mirror program.
mirror_program = "/usr/bin/debmirror"
if not os.path.exists(mirror_program):
utils.die(self.logger, "no %s found, please install it" % (mirror_program))
cmd = "" # command to run
# detect cases that require special handling
if repo.rpm_list != "" and repo.rpm_list != []:
utils.die(self.logger, "has_rpm_list not yet supported on apt repos")
if not repo.arch:
utils.die(self.logger, "Architecture is required for apt repositories")
# built destination path for the repo
dest_path = os.path.join("/var/www/cobbler/repo_mirror", repo.name)
if repo.mirror_locally:
# NOTE: Dropping @@suite@@ replace as it is also dropped from
# if building standalone, we only want --distro and --profiles (optional),
# systems are disallowed
if standalone:
if systems is not None:
utils.die(self.logger, "When building a standalone ISO, use --distro and --profiles only, not --systems")
elif distro is None:
utils.die(self.logger, "When building a standalone ISO, you must specify a --distro")
if source is not None and not os.path.exists(source):
utils.die(self.logger, "The source specified (%s) does not exist" % source)
# insure all profiles specified are children of the distro
if profiles:
which_profiles = self.filter_systems_or_profiles(profiles, 'profile')
for profile in which_profiles:
if profile.distro != distro:
utils.die(self.logger, "When building a standalone ISO, all --profiles must be under --distro")
# if iso is none, create it in . as "autoinst.iso"
if iso is None:
iso = "autoinst.iso"
if buildisodir is None:
buildisodir = self.settings.buildisodir
else:
if not os.path.isdir(buildisodir):
utils.die(self.logger, "The --tempdir specified is not a directory")
(buildisodir_head, buildisodir_tail) = os.path.split(os.path.normpath(buildisodir))
if buildisodir_tail != "buildiso":
buildisodir = os.path.join(buildisodir, "buildiso")
self.logger.info("using/creating buildisodir: %s" % buildisodir)
def run(self, name=None, verbose=True):
"""
Syncs the current repo configuration file with the filesystem.
"""
self.logger.info("run, reposync, run!")
try:
self.tries = int(self.tries)
except:
utils.die(self.logger, "retry value must be an integer")
self.verbose = verbose
report_failure = False
for repo in self.repos:
if name is not None and repo.name != name:
# invoked to sync only a specific repo, this is not the one
continue
elif name is None and not repo.keep_updated:
# invoked to run against all repos, but this one is off
self.logger.info("%s is set to not be updated" % repo.name)
continue
repo_mirror = os.path.join(self.settings.webdir, "repo_mirror")
repo_path = os.path.join(repo_mirror, repo.name)
@param str user power management user. If user and password are not
supplied, environment variables COBBLER_POWER_USER and
COBBLER_POWER_PASS will be used.
@param str password power management password
@param Logger logger logger
@return bool/None if power operation is 'status', return if system is on;
otherwise, return None
@raise CX if there are errors
"""
if logger is None:
logger = self.logger
power_command = get_power_command(system.power_type)
if not power_command:
utils.die(logger, "no power type set for system")
meta = utils.blender(self.api, False, system)
meta["power_mode"] = power_operation
logger.info("cobbler power configuration is:")
logger.info(" type : %s" % system.power_type)
logger.info(" address: %s" % system.power_address)
logger.info(" user : %s" % system.power_user)
logger.info(" id : %s" % system.power_id)
logger.info(" options: %s" % system.power_options)
logger.info("identity_file: %s" % system.power_identity_file)
# if no username/password data, check the environment
if not system.power_user and not user:
user = os.environ.get("COBBLER_POWER_USER", "")
if not system.power_pass and not password:
utils.die(self.logger, "Invalid list_type argument: " + list_type)
all_objs.sort(key=lambda profile: profile.name)
# no profiles/systems selection is made, let's process everything
if not selected_items:
return all_objs
which_objs = []
selected_list = utils.input_string_or_list(selected_items)
for obj in all_objs:
if obj.name in selected_list:
which_objs.append(obj)
if not which_objs:
utils.die(self.logger, "No valid systems or profiles were specified.")
return which_objs
@param str user power management user
@param str password power management password
@param Logger logger logger
@return bool if operation was successful
"""
if power_operation == "on":
self.power_mgr.power_on(system, user=user, password=password, logger=logger)
elif power_operation == "off":
self.power_mgr.power_off(system, user=user, password=password, logger=logger)
elif power_operation == "status":
return self.power_mgr.get_power_status(system, user=user, password=password, logger=logger)
elif power_operation == "reboot":
self.power_mgr.reboot(system, user=user, password=password, logger=logger)
else:
utils.die(self.logger, "invalid power operation '%s', expected on/off/status/reboot" % power_operation)
return None
def filter_systems_or_profiles(self, selected_items, list_type):
"""
Return a list of valid profile or system objects selected from all profiles
or systems by name, or everything if selected_items is empty
"""
if list_type == 'profile':
all_objs = [profile for profile in self.api.profiles()]
elif list_type == 'system':
all_objs = [system for system in self.api.systems()]
else:
utils.die(self.logger, "Invalid list_type argument: " + list_type)
all_objs.sort(key=lambda profile: profile.name)
# no profiles/systems selection is made, let's process everything
if not selected_items:
return all_objs
which_objs = []
selected_list = utils.input_string_or_list(selected_items)
for obj in all_objs:
if obj.name in selected_list:
which_objs.append(obj)
if not which_objs:
utils.die(self.logger, "No valid systems or profiles were specified.")
self.arch = None
if self.name == "":
self.name = None
if self.autoinstall_file == "":
self.autoinstall_file = None
if self.os_version == "":
self.os_version = None
if self.network_root == "":
self.network_root = None
if self.os_version and not self.breed:
utils.die(self.logger, "OS version can only be specified when a specific breed is selected")
self.signature = self.scan_signatures()
if not self.signature:
error_msg = "No signature matched in %s" % path
self.logger.error(error_msg)
raise CX(error_msg)
# now walk the filesystem looking for distributions that match certain patterns
self.logger.info("Adding distros from path %s:" % self.path)
distros_added = []
import_walker(self.path, self.distro_adder, distros_added)
if len(distros_added) == 0:
self.logger.warning("No distros imported, bailing out")
return