def kickstart_finder(self, distros_added):
"""
For all of the profiles in the config w/o a kickstart, use the
given kickstart file, or look at the kernel path, from that,
see if we can guess the distro, and if we can, assign a kickstart
if one is available for it.
"""
for profile in self.profiles:
distro = self.distros.find(
name=profile.get_conceptual_parent().name)
if distro is None or not (distro in distros_added):
continue
kdir = os.path.dirname(distro.kernel)
if self.kickstart_file == None:
for file in self.get_release_files():
results = self.scan_pkg_filename(file)
# FIXME : If os is not found on tree but set with CLI, no kickstart is searched
if results is None:
self.logger.warning("skipping %s" % file)
continue
(flavor, major, minor, release) = results
# Why use set_variance()? scan_pkg_filename() does everything we need now - jcammarata
#version , ks = self.set_variance(flavor, major, minor, distro.arch)
if self.os_version:
if self.os_version != flavor:
utils.die(
self.logger,
"CLI version differs from tree : %s vs. %s" %
(self.os_version, flavor))
distro.set_comment(
"%s %s (%s.%s.%s) %s" %
(self.breed, flavor, major, minor, release, self.arch))
distro.set_os_version(flavor)
# is this even valid for debian/ubuntu? - jcammarata
#ds = self.get_datestamp()
#if ds is not None:
# distro.set_tree_build_time(ds)
profile.set_kickstart(
"/var/lib/cobbler/kickstarts/sample.seed")
self.profiles.add(profile, save=True)
self.configure_tree_location(distro)
self.distros.add(distro, save=True) # re-save
self.api.serialize()
def kickstart_finder(self,distros_added):
"""
For all of the profiles in the config w/o a kickstart, use the
given kickstart file, or look at the kernel path, from that,
see if we can guess the distro, and if we can, assign a kickstart
if one is available for it.
"""
for profile in self.profiles:
distro = self.distros.find(name=profile.get_conceptual_parent().name)
if distro is None or not (distro in distros_added):
continue
kdir = os.path.dirname(distro.kernel)
if self.kickstart_file == None:
for file in self.get_release_files():
results = self.scan_pkg_filename(file)
# FIXME : If os is not found on tree but set with CLI, no kickstart is searched
if results is None:
self.logger.warning("skipping %s" % file)
continue
(flavor, major, minor, release) = results
# Why use set_variance()? scan_pkg_filename() does everything we need now - jcammarata
#version , ks = self.set_variance(flavor, major, minor, distro.arch)
if self.os_version:
if self.os_version != flavor:
utils.die(self.logger,"CLI version differs from tree : %s vs. %s" % (self.os_version,flavor))
distro.set_comment("%s %s (%s.%s.%s) %s" % (self.breed,flavor,major,minor,release,self.arch))
distro.set_os_version(flavor)
# is this even valid for debian/ubuntu? - jcammarata
#ds = self.get_datestamp()
#if ds is not None:
# distro.set_tree_build_time(ds)
profile.set_kickstart("/var/lib/cobbler/kickstarts/sample.seed")
self.profiles.add(profile,save=True)
self.configure_tree_location(distro)
self.distros.add(distro,save=True) # re-save
self.api.serialize()
def add_entry(self,dirname,kernel,initrd):
"""
When we find a directory with a valid kernel/initrd in it, create the distribution objects
as appropriate and save them. This includes creating xen and rescue distros/profiles
if possible.
"""
proposed_name = self.get_proposed_name(dirname,kernel)
proposed_arch = self.get_proposed_arch(dirname)
if self.arch and proposed_arch and self.arch != proposed_arch:
self.logger.error("Arch from pathname (%s) does not match with supplied one (%s)"%(proposed_arch,self.arch))
return
archs = self.learn_arch_from_tree()
if not archs:
if self.arch:
archs.append( self.arch )
else:
if self.arch and self.arch not in archs:
utils.die(self.logger, "Given arch (%s) not found on imported tree %s"%(self.arch,self.get_pkgdir()))
if proposed_arch:
if archs and proposed_arch not in archs:
self.logger.warning("arch from pathname (%s) not found on imported tree %s" % (proposed_arch,self.get_pkgdir()))
return
archs = [ proposed_arch ]
if len(archs)>1:
self.logger.warning("- Warning : Multiple archs found : %s" % (archs))
distros_added = []
for pxe_arch in archs:
name = proposed_name + "-" + pxe_arch
existing_distro = self.distros.find(name=name)
if existing_distro is not None:
self.logger.warning("skipping import, as distro name already exists: %s" % name)
continue
else:
self.logger.info("creating new distro: %s" % name)
distro = self.config.new_distro()
if name.find("-autoboot") != -1:
# this is an artifact of some EL-3 imports
continue
distro.set_name(name)
distro.set_kernel(kernel)
distro.set_initrd(initrd)
distro.set_arch(pxe_arch)
distro.set_breed(self.breed)
# If a version was supplied on command line, we set it now
if self.os_version:
distro.set_os_version(self.os_version)
self.distros.add(distro,save=True)
distros_added.append(distro)
existing_profile = self.profiles.find(name=name)
# see if the profile name is already used, if so, skip it and
# do not modify the existing profile
if existing_profile is None:
self.logger.info("creating new profile: %s" % name)
#FIXME: The created profile holds a default kickstart, and should be breed specific
profile = self.config.new_profile()
else:
self.logger.info("skipping existing profile, name already exists: %s" % name)
continue
# save our minimal profile which just points to the distribution and a good
# default answer file
profile.set_name(name)
profile.set_distro(name)
profile.set_kickstart(self.kickstart_file)
# depending on the name of the profile we can define a good virt-type
# for usage with koan
if name.find("-xen") != -1:
profile.set_virt_type("xenpv")
elif name.find("vmware") != -1:
profile.set_virt_type("vmware")
else:
profile.set_virt_type("qemu")
# save our new profile to the collection
self.profiles.add(profile,save=True)
return distros_added
def add_entry(self, dirname, kernel, initrd):
"""
When we find a directory with a valid kernel/initrd in it, create the distribution objects
as appropriate and save them. This includes creating xen and rescue distros/profiles
if possible.
"""
proposed_name = self.get_proposed_name(dirname, kernel)
proposed_arch = self.get_proposed_arch(dirname)
if self.arch and proposed_arch and self.arch != proposed_arch:
self.logger.error(
"Arch from pathname (%s) does not match with supplied one (%s)"
% (proposed_arch, self.arch))
return
archs = self.learn_arch_from_tree()
if not archs:
if self.arch:
archs.append(self.arch)
else:
if self.arch and self.arch not in archs:
utils.die(
self.logger,
"Given arch (%s) not found on imported tree %s" %
(self.arch, self.get_pkgdir()))
if proposed_arch:
if archs and proposed_arch not in archs:
self.logger.warning(
"arch from pathname (%s) not found on imported tree %s" %
(proposed_arch, self.get_pkgdir()))
return
archs = [proposed_arch]
if len(archs) > 1:
self.logger.warning("- Warning : Multiple archs found : %s" %
(archs))
distros_added = []
for pxe_arch in archs:
name = proposed_name + "-" + pxe_arch
existing_distro = self.distros.find(name=name)
if existing_distro is not None:
self.logger.warning(
"skipping import, as distro name already exists: %s" %
name)
continue
else:
self.logger.info("creating new distro: %s" % name)
distro = self.config.new_distro()
if name.find("-autoboot") != -1:
# this is an artifact of some EL-3 imports
continue
distro.set_name(name)
distro.set_kernel(kernel)
distro.set_initrd(initrd)
distro.set_arch(pxe_arch)
distro.set_breed(self.breed)
# If a version was supplied on command line, we set it now
if self.os_version:
distro.set_os_version(self.os_version)
self.distros.add(distro, save=True)
distros_added.append(distro)
existing_profile = self.profiles.find(name=name)
# see if the profile name is already used, if so, skip it and
# do not modify the existing profile
if existing_profile is None:
self.logger.info("creating new profile: %s" % name)
#FIXME: The created profile holds a default kickstart, and should be breed specific
profile = self.config.new_profile()
else:
self.logger.info(
"skipping existing profile, name already exists: %s" %
name)
continue
# save our minimal profile which just points to the distribution and a good
# default answer file
profile.set_name(name)
profile.set_distro(name)
profile.set_kickstart(self.kickstart_file)
# depending on the name of the profile we can define a good virt-type
# for usage with koan
if name.find("-xen") != -1:
profile.set_virt_type("xenpv")
elif name.find("vmware") != -1:
profile.set_virt_type("vmware")
else:
profile.set_virt_type("qemu")
# save our new profile to the collection
self.profiles.add(profile, save=True)
return distros_added
def add_entry(self,dirname,kernel,initrd):
"""
When we find a directory with a valid kernel/initrd in it, create the distribution objects
as appropriate and save them. This includes creating xen and rescue distros/profiles
if possible.
"""
# build a proposed name based on the directory structure
proposed_name = self.get_proposed_name(dirname,kernel)
# build a list of arches found in the packages directory
archs = self.learn_arch_from_tree()
if not archs and self.arch:
archs.append( self.arch )
else:
if self.arch and self.arch not in archs:
utils.die(self.logger, "Given arch (%s) not found on imported tree %s"%(self.arch,self.path))
if len(archs) == 0:
self.logger.error("No arch could be detected in %s, and none was specified via the --arch option" % dirname)
return []
elif len(archs) > 1:
self.logger.warning("- Warning : Multiple archs found : %s" % (archs))
distros_added = []
for pxe_arch in archs:
name = proposed_name + "-" + pxe_arch
existing_distro = self.distros.find(name=name)
if existing_distro is not None:
self.logger.warning("skipping import, as distro name already exists: %s" % name)
continue
else:
self.logger.info("creating new distro: %s" % name)
distro = self.config.new_distro()
if name.find("-autoboot") != -1:
# this is an artifact of some EL-3 imports
continue
distro.set_name(name)
distro.set_kernel(kernel)
distro.set_initrd(initrd)
distro.set_arch(pxe_arch)
distro.set_breed(self.breed)
distro.set_os_version(self.os_version)
distro.set_kernel_options(self.signature["kernel_options"])
distro.set_kernel_options_post(self.signature["kernel_options_post"])
boot_files = ''
for boot_file in self.signature["boot_files"]:
boot_files += '$img_path/%s=%s/%s ' % (boot_file,self.path,boot_file)
distro.set_boot_files(boot_files.strip())
self.configure_tree_location(distro)
self.distros.add(distro,save=True)
distros_added.append(distro)
# see if the profile name is already used, if so, skip it and
# do not modify the existing profile
existing_profile = self.profiles.find(name=name)
if existing_profile is None:
self.logger.info("creating new profile: %s" % name)
profile = self.config.new_profile()
else:
self.logger.info("skipping existing profile, name already exists: %s" % name)
continue
profile.set_name(name)
profile.set_distro(name)
profile.set_kickstart(self.kickstart_file)
# depending on the name of the profile we can
# define a good virt-type for usage with koan
if name.find("-xen") != -1:
profile.set_virt_type("xenpv")
elif name.find("vmware") != -1:
profile.set_virt_type("vmware")
else:
profile.set_virt_type("kvm")
self.profiles.add(profile,save=True)
return distros_added
def add_entry(self, dirname, kernel, initrd):
"""
When we find a directory with a valid kernel/initrd in it, create the distribution objects
as appropriate and save them. This includes creating xen and rescue distros/profiles
if possible.
"""
# build a proposed name based on the directory structure
proposed_name = self.get_proposed_name(dirname, kernel)
# build a list of arches found in the packages directory
archs = self.learn_arch_from_tree()
if not archs and self.arch:
archs.append(self.arch)
else:
if self.arch and self.arch not in archs:
utils.die(
self.logger,
"Given arch (%s) not found on imported tree %s" %
(self.arch, self.path))
if len(archs) == 0:
self.logger.error(
"No arch could be detected in %s, and none was specified via the --arch option"
% dirname)
return []
elif len(archs) > 1:
self.logger.warning("- Warning : Multiple archs found : %s" %
(archs))
distros_added = []
for pxe_arch in archs:
name = proposed_name + "-" + pxe_arch
existing_distro = self.distros.find(name=name)
if existing_distro is not None:
self.logger.warning(
"skipping import, as distro name already exists: %s" %
name)
continue
else:
self.logger.info("creating new distro: %s" % name)
distro = self.config.new_distro()
if name.find("-autoboot") != -1:
# this is an artifact of some EL-3 imports
continue
distro.set_name(name)
distro.set_kernel(kernel)
distro.set_initrd(initrd)
distro.set_arch(pxe_arch)
distro.set_breed(self.breed)
distro.set_os_version(self.os_version)
distro.set_kernel_options(self.signature.get("kernel_options", ""))
distro.set_kernel_options_post(
self.signature.get("kernel_options_post", ""))
distro.set_template_files(self.signature.get("template_files", ""))
boot_files = ''
for boot_file in self.signature["boot_files"]:
boot_files += '$local_img_path/%s=%s/%s ' % (
boot_file, self.path, boot_file)
distro.set_boot_files(boot_files.strip())
self.configure_tree_location(distro)
self.distros.add(distro, save=True)
distros_added.append(distro)
# see if the profile name is already used, if so, skip it and
# do not modify the existing profile
existing_profile = self.profiles.find(name=name)
if existing_profile is None:
self.logger.info("creating new profile: %s" % name)
profile = self.config.new_profile()
else:
self.logger.info(
"skipping existing profile, name already exists: %s" %
name)
continue
profile.set_name(name)
profile.set_distro(name)
profile.set_kickstart(self.kickstart_file)
# depending on the name of the profile we can
# define a good virt-type for usage with koan
if name.find("-xen") != -1:
profile.set_virt_type("xenpv")
elif name.find("vmware") != -1:
profile.set_virt_type("vmware")
else:
profile.set_virt_type("kvm")
self.profiles.add(profile, save=True)
return distros_added