def initialize_config(config_file_path):
"""
Checks the given config and initializes it if it is not set and does not
exist.
@param config_file_path The path to config file, or None in case the
default onw should be used.
"""
help_url = "http://confluence.rnd.samsung.ru/display/TC/Config+file+format"
global default_path
if config_file_path is None:
config_file_path = os.path.expanduser(default_path)
if not os.path.isfile(config_file_path):
logging.warning("Default config {0} does not exist! It will "
"be generated, but you should complete it with "
"repository paths, package names and other "
" options.".format(config_file_path))
config = configparser.SafeConfigParser(allow_no_value=True)
config.add_section('general')
config.set('general', '# See documentation about combirepo '
'config file format at page {0}'.format(help_url))
with open(config_file_path, 'wb') as config_file:
config.write(config_file)
else:
config_file_path = os.path.expanduser(config_file_path)
check.file_exists(config_file_path)
default_path = config_file_path
def __disable_all():
"""
Disables or registered binary formats
"""
binfmt_status_path = os.path.join(binfmt_directory, "status")
check.file_exists(binfmt_status_path)
with open(binfmt_status_path, 'w') as binfmt_status:
binfmt_status.write("-1\n")
def __do_idle_tasks(self):
"""
Does idle tasks, i. e. just copies RPMs in case when RPM patching is
totally disabled.
"""
tasks = []
for task in self._tasks:
package_name, package_path, target, _, _ = task
check.file_exists(package_path)
tasks.append((package_name, package_path, target))
hidden_subprocess.function_call_list("Copying w/o patching",
shutil.copy, tasks)
def create_symlink(package_name, location_from, directory_to):
"""
Creates symlink from file to the file with the same name in the another
directory.
@param package The name of package
@param location_from Source of the symlink
@param directory_to Destination directory of the symlink
"""
check.file_exists(location_from)
location_to = os.path.join(directory_to, os.path.basename(location_from))
logging.debug("Creating symlink from {0} to {1}".format(
location_from, location_to))
os.symlink(location_from, location_to)
def prepare_repositories(parameters):
"""
Prepares repository pairs for use.
@param parameters The combirepo run-time parameters (for
explanation, see combirepo/parameters.py).
@return The path to the used kickstart file.
"""
repository_pairs = parameters.repository_pairs
kickstart_file_path = parameters.kickstart_file_path
if len(repository_pairs) == 0:
raise Exception("No repository pairs given!")
# Check that user has given correct arguments for repository names:
names = [repository_pair.name for repository_pair in repository_pairs]
logging.debug("Repository names: {0}".format(names))
if kickstart_file_path is not None and os.path.isfile(kickstart_file_path):
logging.info("Kickstart file {0} specified by user will be "
"used".format(kickstart_file_path))
check_repository_names(names, kickstart_file_path)
global repository_cache_directory_path
repository_manager = RepositoryManager(repository_cache_directory_path,
check_rpm_name)
authenticator = base64.encodestring("{0}:{1}".format(
parameters.user, parameters.password))
authenticator = authenticator.replace('\n', '')
path = repository_manager.prepare(parameters.sup_repo_url, authenticator)
parameters.sup_repo_url = path
for repository_pair in repository_pairs:
path = repository_manager.prepare(repository_pair.url, authenticator)
repository_pair.url = path
path_marked = repository_manager.prepare(repository_pair.url_marked,
authenticator)
repository_pair.url_marked = path_marked
if repodata_regeneration_enabled:
for repository_pair in parameters.repository_pairs:
regenerate_repodata(repository_pair.url,
repository_pair.url_marked)
if kickstart_file_path is None or not os.path.isfile(kickstart_file_path):
kickstart_file_path = get_kickstart_from_repos(repository_pairs,
kickstart_file_path)
check.file_exists(kickstart_file_path)
check_repository_names(names, kickstart_file_path)
logging.info("The following kickstart file will be used: "
"{0}".format(kickstart_file_path))
return kickstart_file_path
def unrpm(rpm_path, destination_path):
"""
Unpacks the RPM package from the given location to the given directory.
@param rpm_path The path to the RPM file.
@param destination_path The path to the destination directory.
"""
check.file_exists(rpm_path)
check.directory_exists(destination_path)
if not rpm_path.endswith(".rpm"):
logging.error("Given file {0} is not an RPM package!".format(rpm_path))
initial_directory = os.getcwd()
os.chdir(destination_path)
hidden_subprocess.silent_pipe_call(["rpm2cpio", rpm_path], [
"cpio", "--extract", "--unconditional", "--preserve-modification-time",
"--make-directories"
])
os.chdir(initial_directory)
def __register(architecture, qemu_executable_path):
"""
Register the binary format for the given architecture.
@param architecture The architecture.
@param qemu_executable_path The absolute path to qemu binary INSIDE the
chroot directory (after chrooting to it). It
must always begin with '/'.
"""
qemu_type = "qemu"
if os.path.basename(qemu_executable_path).endswith("-binfmt"):
qemu_type = "qemu-wrapper"
binfmt_register_path = os.path.join(binfmt_directory, "register")
check.file_exists(binfmt_register_path)
binfmt_name = __get_name(architecture)
binary_format = ":{0}:M::{1}:{2}:{3}:{4}".format(binfmt_name,
binfmt_magic[binfmt_name],
binfmt_mask[binfmt_name],
qemu_executable_path,
binfmt_flag[qemu_type])
with open(binfmt_register_path, 'w') as binfmt_register:
binfmt_register.write(binary_format)
def parse(self):
"""
Parses the given config file and returns the properties structure.
@return The parameters structure of combirepo tool.
"""
check.file_exists(self.path)
self.parser.read(self.path)
parameters = RepositoryCombinerParameters()
# Parse general section:
self.__check_section_exists("general")
self.__check_option_exists("general", "profile")
parameters.profile_name = self.parser.get("general", "profile")
if self.parser.has_option("general", "tmp_dir"):
path = self.parser.get("general", "tmp_dir")
parameters.temporary_directory_path = path
# Parse profile section:
profile_name = parameters.profile_name
self.__check_section_exists(profile_name)
logging.debug("Detected profile "
"{0}".format(profile_name))
self.__check_option_exists(profile_name, "repos")
repository_aliases = self.__get_list(profile_name, "repos")
if self.parser.has_option(profile_name, "user"):
parameters.user = self.parser.get(profile_name, "user")
if self.parser.has_option(profile_name, "password"):
parameters.password = self.parser.get(profile_name, "password")
if self.parser.has_option(profile_name, "passwordx"):
logging.error("Both password and passwordx present!")
sys.exit("Error.")
self.parser.remove_option(profile_name, "password")
passwordx = base64.b64encode(parameters.password.encode('bz2'))
self.parser.set(profile_name, "passwordx", passwordx)
elif self.parser.has_option(profile_name, "passwordx"):
passwordx = self.parser.get(profile_name, "passwordx")
parameters.password = base64.b64decode(passwordx).decode('bz2')
if self.parser.has_option(profile_name, "repo_supplementary"):
parameters.sup_repo_url = self.parser.get(profile_name,
"repo_supplementary")
if self.parser.has_option(profile_name, "architecture"):
parameters.architecture = self.parser.get(profile_name,
"architecture")
if self.parser.has_option(profile_name, "kickstart"):
kickstart_file_path = self.parser.get(profile_name, "kickstart")
parameters.kickstart_file_path = kickstart_file_path
if self.parser.has_option(profile_name, "out_dir"):
output_directory_path = self.parser.get(profile_name, "out_dir")
parameters.output_directory_path = output_directory_path
mic_options = self.__get_list(profile_name, "mic_options")
if self.parser.has_option(profile_name, "greedy"):
greedy_mode = self.parser.getboolean(profile_name, "greedy")
parameters.greedy_mode = greedy_mode
if self.parser.has_option(profile_name, "mirror"):
mirror_mode = self.parser.getboolean(profile_name, "mirror")
parameters.mirror_mode = mirror_mode
if self.parser.has_option(profile_name, "preferring_strategy"):
preferring_strategy = self.parser.get(profile_name,
"preferring_strategy")
parameters.preferring_strategy = preferring_strategy
package_names = {}
for key in valid_package_keys:
names = self.__get_list(parameters.profile_name,
"{0}_packages".format(key))
package_names[key] = names
parameters.package_names = package_names
logging.debug("Package names from config: "
"{0}".format(parameters.package_names))
repository_pairs = self.__build_repository_pairs(repository_aliases)
parameters.repository_pairs = repository_pairs
with open(self.path, 'wb') as config_file:
self.parser.write(config_file)
return parameters
