Hi,

I have added SUSE support for "cobbler import", based on the red hat importer 
module. Only 2 new files were added.
- the importer modules
- an autoyast XML file in kickstarts/...

Patch attached and here:
https://github.com/ugansert/Cobbler

-- 
ciao, Uwe Gansert

Uwe Gansert
SUSE LINUX Products GmbH, GF: Markus Rex, HRB 16746 (AG N├╝rnberg)
Business: http://www.suse.de/~ug
From bc83f0065e155f4fd7c3343f88d38184cc06f980 Mon Sep 17 00:00:00 2001
From: Uwe Gansert <u...@suse.de>
Date: Tue, 5 Apr 2011 13:11:52 +0200
Subject: [PATCH] added support for suse-distro import

---
 cobbler/modules/manage_import_suse.py |  772 +++++++++++++++++++++++++++++++++
 kickstarts/autoyast_sample.xml        |   45 ++
 2 files changed, 817 insertions(+), 0 deletions(-)
 create mode 100644 cobbler/modules/manage_import_suse.py
 create mode 100644 kickstarts/autoyast_sample.xml

diff --git a/cobbler/modules/manage_import_suse.py b/cobbler/modules/manage_import_suse.py
new file mode 100644
index 0000000..802800e
--- /dev/null
+++ b/cobbler/modules/manage_import_suse.py
@@ -0,0 +1,772 @@
+"""
+--
+-- Copyright (c) 2011 Novell
+-- Uwe Gansert <u...@suse.de>
+--
+-- This software is licensed to you under the GNU General Public License,
+-- version 2 (GPLv2). There is NO WARRANTY for this software, express or
+-- implied, including the implied warranties of MERCHANTABILITY or FITNESS
+-- FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
+-- along with this software; if not, see
+-- http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+--
+--
+
+"""
+
+import os
+import os.path
+import shutil
+import time
+import sys
+import glob
+import traceback
+import errno
+from utils import popen2
+from shlex import shlex
+
+
+import utils
+from cexceptions import *
+import templar
+
+import item_distro
+import item_profile
+import item_repo
+import item_system
+
+from utils import _
+
+# FIXME: add --quiet depending on if not --verbose?
+RSYNC_CMD =  "rsync -a %s '%s' %s --exclude-from=/etc/cobbler/rsync.exclude --progress"
+
+def register():
+   """
+   The mandatory cobbler module registration hook.
+   """
+   return "manage/import"
+
+
+class ImportSuseManager:
+
+    def __init__(self,config,logger):
+        """
+        Constructor
+        """
+        self.logger        = logger
+        self.config        = config
+        self.api           = config.api
+        self.distros       = config.distros()
+        self.profiles      = config.profiles()
+        self.systems       = config.systems()
+        self.settings      = config.settings()
+        self.repos         = config.repos()
+        self.templar       = templar.Templar(config)
+
+    # required function for import modules
+    def what(self):
+        return "import/suse"
+
+    # required function for import modules
+    def check_for_signature(self,path,cli_breed):
+       signatures = [
+          'suse'
+       ]
+
+       #self.logger.info("scanning %s for a redhat-based distro signature" % path)
+       for signature in signatures:
+           d = os.path.join(path,signature)
+           if os.path.exists(d):
+               self.logger.info("Found a SUSE compatible signature: %s" % signature)
+               return (True,signature)
+
+       if cli_breed and cli_breed in self.get_valid_breeds():
+           self.logger.info("Warning: No distro signature for kernel at %s, using value from command line" % path)
+           return (True,None)
+
+       return (False,None)
+
+    # required function for import modules
+    def run(self,pkgdir,mirror,mirror_name,network_root=None,kickstart_file=None,rsync_flags=None,arch=None,breed=None,os_version=None):
+        self.pkgdir = pkgdir
+        self.mirror = mirror
+        self.mirror_name = mirror_name
+        self.network_root = network_root
+        self.kickstart_file = kickstart_file
+        self.rsync_flags = rsync_flags
+        self.arch = arch
+        self.breed = breed
+        self.os_version = os_version
+
+        # some fixups for the XMLRPC interface, which does not use "None"
+        if self.arch == "":           self.arch           = None
+        if self.mirror == "":         self.mirror         = None
+        if self.mirror_name == "":    self.mirror_name    = None
+        if self.kickstart_file == "": self.kickstart_file = None
+        if self.os_version == "":     self.os_version     = None
+        if self.rsync_flags == "":    self.rsync_flags    = None
+        if self.network_root == "":   self.network_root   = None
+
+        # If no breed was specified on the command line, set it to "suse" for this module
+        if self.breed == None:
+            self.breed = "suse"
+
+        # debug log stuff for testing
+        #self.logger.info("self.pkgdir = %s" % str(self.pkgdir))
+        #self.logger.info("self.mirror = %s" % str(self.mirror))
+        #self.logger.info("self.mirror_name = %s" % str(self.mirror_name))
+        #self.logger.info("self.network_root = %s" % str(self.network_root))
+        #self.logger.info("self.kickstart_file = %s" % str(self.kickstart_file))
+        #self.logger.info("self.rsync_flags = %s" % str(self.rsync_flags))
+        #self.logger.info("self.arch = %s" % str(self.arch))
+        #self.logger.info("self.breed = %s" % str(self.breed))
+        #self.logger.info("self.os_version = %s" % str(self.os_version))
+
+        # both --import and --name are required arguments
+
+        if self.mirror is None:
+            utils.die(self.logger,"import failed.  no --path specified")
+        if self.mirror_name is None:
+            utils.die(self.logger,"import failed.  no --name specified")
+
+        # if --arch is supplied, validate it to ensure it's valid
+
+        if self.arch is not None and self.arch != "":
+            self.arch = self.arch.lower()
+            if self.arch == "x86":
+                # be consistent
+                self.arch = "i386"
+            if self.arch in [ 'i486', 'i586', 'i686' ]:
+                self.arch = "i386"
+            if self.arch not in self.get_valid_arches():
+                utils.die(self.logger,"arch must be one of: %s" % string.join(self.get_valid_arches(),", "))
+
+        # if we're going to do any copying, set where to put things
+        # and then make sure nothing is already there.
+
+        self.path = os.path.normpath( "%s/ks_mirror/%s" % (self.settings.webdir, self.mirror_name) )
+        self.rootdir = os.path.normpath( "%s/ks_mirror/%s" % (self.settings.webdir, self.mirror_name) )
+        if os.path.exists(self.path) and self.arch is None:
+            # FIXME : Raise exception even when network_root is given ?
+            utils.die(self.logger,"Something already exists at this import location (%s).  You must specify --arch to avoid potentially overwriting existing files." % self.path)
+
+        # import takes a --kickstart for forcing selection that can't be used in all circumstances
+
+        if self.kickstart_file and not self.breed:
+            utils.die(self.logger,"Kickstart file can only be specified when a specific breed is selected")
+
+        if self.os_version and not self.breed:
+            utils.die(self.logger,"OS version can only be specified when a specific breed is selected")
+
+        if self.breed and self.breed.lower() not in self.get_valid_breeds():
+            utils.die(self.logger,"Supplied import breed is not supported by this module")
+
+        # if --arch is supplied, make sure the user is not importing a path with a different
+        # arch, which would just be silly.
+
+        if self.arch:
+            # append the arch path to the name if the arch is not already
+            # found in the name.
+            for x in self.get_valid_arches():
+                if self.path.lower().find(x) != -1:
+                    if self.arch != x :
+                        utils.die(self.logger,"Architecture found on pathname (%s) does not fit the one given in command line (%s)"%(x,self.arch))
+                    break
+            else:
+                # FIXME : This is very likely removed later at get_proposed_name, and the guessed arch appended again
+                self.path += ("-%s" % self.arch)
+
+        # make the output path and mirror content but only if not specifying that a network
+        # accessible support location already exists (this is --available-as on the command line)
+
+        if self.network_root is None:
+            # we need to mirror (copy) the files
+
+            utils.mkdir(self.path)
+
+            # prevent rsync from creating the directory name twice
+            # if we are copying via rsync
+
+            if not self.mirror.endswith("/"):
+                self.mirror = "%s/" % self.mirror
+
+            if self.mirror.startswith("http://";) or self.mirror.startswith("ftp://";) or self.mirror.startswith("nfs://"):
+
+                # http mirrors are kind of primative.  rsync is better.
+                # that's why this isn't documented in the manpage and we don't support them.
+                # TODO: how about adding recursive FTP as an option?
+
+                utils.die(self.logger,"unsupported protocol")
+
+            else:
+
+                # good, we're going to use rsync..
+                # we don't use SSH for public mirrors and local files.
+                # presence of user@host syntax means use SSH
+
+                spacer = ""
+                if not self.mirror.startswith("rsync://") and not self.mirror.startswith("/"):
+                    spacer = ' -e "ssh" '
+                rsync_cmd = RSYNC_CMD
+                if self.rsync_flags:
+                    rsync_cmd = rsync_cmd + " " + self.rsync_flags
+
+                # kick off the rsync now
+
+                utils.run_this(rsync_cmd, (spacer, self.mirror, self.path), self.logger)
+
+        else:
+
+            # rather than mirroring, we're going to assume the path is available
+            # over http, ftp, and nfs, perhaps on an external filer.  scanning still requires
+            # --mirror is a filesystem path, but --available-as marks the network path
+
+            if not os.path.exists(self.mirror):
+                utils.die(self.logger, "path does not exist: %s" % self.mirror)
+
+            # find the filesystem part of the path, after the server bits, as each distro
+            # URL needs to be calculated relative to this.
+
+            if not self.network_root.endswith("/"):
+                self.network_root = self.network_root + "/"
+            self.path = os.path.normpath( self.mirror )
+            valid_roots = [ "nfs://", "ftp://";, "http://"; ]
+            for valid_root in valid_roots:
+                if self.network_root.startswith(valid_root):
+                    break
+            else:
+                utils.die(self.logger, "Network root given to --available-as must be nfs://, ftp://, or http://";)
+            if self.network_root.startswith("nfs://"):
+                try:
+                    (a,b,rest) = self.network_root.split(":",3)
+                except:
+                    utils.die(self.logger, "Network root given to --available-as is missing a colon, please see the manpage example.")
+
+        # now walk the filesystem looking for distributions that match certain patterns
+
+        self.logger.info("adding distros")
+        distros_added = []
+        # FIXME : search below self.path for isolinux configurations or known directories from TRY_LIST
+        os.path.walk(self.path, self.distro_adder, distros_added)
+
+        # find out if we can auto-create any repository records from the install tree
+
+        if self.network_root is None:
+            self.logger.info("associating repos")
+            # FIXME: this automagic is not possible (yet) without mirroring
+            self.repo_finder(distros_added)
+
+        # find the most appropriate answer files for each profile object
+
+        self.logger.info("associating kickstarts")
+        self.kickstart_finder(distros_added)
+
+        # ensure bootloaders are present
+        self.api.pxegen.copy_bootloaders()
+
+        return True
+
+    # required function for import modules
+    def get_valid_arches(self):
+        return ["i386", "ia64", "ppc", "ppc64", "s390", "s390x", "x86_64", "x86",]
+
+    # required function for import modules
+    def get_valid_breeds(self):
+        return ["suse",]
+
+    # required function for import modules
+    def get_valid_os_versions(self):
+        return []
+
+    def get_valid_repo_breeds(self):
+        return ["yast", "rsync", "yum"]
+
+    def get_release_files(self):
+        data = glob.glob(os.path.join(self.get_pkgdir(), "*release-*"))
+        data2 = []
+        for x in data:
+            b = os.path.basename(x)
+# FIXME
+#            if b.find("fedora") != -1 or \
+#               b.find("redhat") != -1 or \
+#               b.find("centos") != -1:
+#                data2.append(x)
+        return data2
+
+    def get_tree_location(self, distro):
+        """
+        Once a distribution is identified, find the part of the distribution
+        that has the URL in it that we want to use for kickstarting the
+        distribution, and create a ksmeta variable $tree that contains this.
+        """
+
+        base = self.get_rootdir()
+
+        if self.network_root is None:
+            dest_link = os.path.join(self.settings.webdir, "links", distro.name)
+            # create the links directory only if we are mirroring because with
+            # SELinux Apache can't symlink to NFS (without some doing)
+            if not os.path.exists(dest_link):
+                try:
+                    os.symlink(base + "-" + distro.arch, dest_link)
+                except:
+                    # this shouldn't happen but I've seen it ... debug ...
+                    self.logger.warning("symlink creation failed: %(base)s, %(dest)s") % { "base" : base, "dest" : dest_link }
+            # how we set the tree depends on whether an explicit network_root was specified
+            tree = "http://@@http_server@@/cblr/links/%s"; % (distro.name)
+            self.set_install_tree(distro, tree)
+        else:
+            # where we assign the kickstart source is relative to our current directory
+            # and the input start directory in the crawl.  We find the path segments
+            # between and tack them on the network source path to find the explicit
+            # network path to the distro that Anaconda can digest.
+            tail = self.path_tail(self.path, base)
+            tree = self.network_root[:-1] + tail
+            self.set_install_tree(distro, tree)
+
+        return
+
+    def repo_finder(self, distros_added):
+        """
+        This routine looks through all distributions and tries to find
+        any applicable repositories in those distributions for post-install
+        usage.
+        """
+
+        for distro in distros_added:
+            self.logger.info("traversing distro %s" % distro.name)
+            # FIXME : Shouldn't decide this the value of self.network_root ?
+            if distro.kernel.find("ks_mirror") != -1:
+                basepath = os.path.dirname(distro.kernel)
+                top = self.get_rootdir()
+                self.logger.info("descent into %s" % top)
+                # FIXME : The location of repo definition is known from breed
+                os.path.walk(top, self.repo_scanner, distro)
+            else:
+                self.logger.info("this distro isn't mirrored")
+
+    def repo_scanner(self,distro,dirname,fnames):
+        """
+        This is an os.path.walk routine that looks for potential yum repositories
+        to be added to the configuration for post-install usage.
+        """
+
+        matches = {}
+        for x in fnames:
+            if x == "base" or x == "repodata":
+                self.logger.info("processing repo at : %s" % dirname)
+                # only run the repo scanner on directories that contain a comps.xml
+                gloob1 = glob.glob("%s/%s/*comps*.xml" % (dirname,x))
+                if len(gloob1) >= 1:
+                    if matches.has_key(dirname):
+                        self.logger.info("looks like we've already scanned here: %s" % dirname)
+                        continue
+                    self.logger.info("need to process repo/comps: %s" % dirname)
+                    matches[dirname] = 1
+                else:
+                    self.logger.info("directory %s is missing xml comps file, skipping" % dirname)
+                    continue
+
+    def distro_adder(self,distros_added,dirname,fnames):
+        """
+        This is an os.path.walk routine that finds distributions in the directory
+        to be scanned and then creates them.
+        """
+
+        # FIXME: If there are more than one kernel or initrd image on the same directory,
+        # results are unpredictable
+
+        initrd = None
+        kernel = None
+
+        # make sure we don't mismatch PAE and non-PAE types
+        pae_initrd = None
+        pae_kernel = None
+
+        for x in fnames:
+            adtls = []
+
+            fullname = os.path.join(dirname,x)
+            if os.path.islink(fullname) and os.path.isdir(fullname):
+                if fullname.startswith(self.path):
+                    # Prevent infinite loop with Sci Linux 5
+                    self.logger.warning("avoiding symlink loop")
+                    continue
+                self.logger.info("following symlink: %s" % fullname)
+                os.path.walk(fullname, self.distro_adder, distros_added)
+
+            if ( x.startswith("initrd") or x.startswith("ramdisk.image.gz") ) and x != "initrd.size":
+                if x.find("PAE") == -1:
+                    initrd = os.path.join(dirname,x)
+                else:
+                    pae_initrd = os.path.join(dirname, x)
+
+            if ( x.startswith("vmlinu") or x.startswith("kernel.img") or x.startswith("linux") ) and x.find("initrd") == -1:
+                if x.find("PAE") == -1:
+                    kernel = os.path.join(dirname,x)
+                else:
+                    pae_kernel = os.path.join(dirname, x)
+
+            # if we've collected a matching kernel and initrd pair, turn the in and add them to the list
+            if initrd is not None and kernel is not None and dirname.find("isolinux") == -1:
+                adtls.append(self.add_entry(dirname,kernel,initrd))
+                kernel = None
+                initrd = None
+            elif pae_initrd is not None and pae_kernel is not None and dirname.find("isolinux") == -1:
+                adtls.append(self.add_entry(dirname,pae_kernel,pae_initrd))
+                pae_kernel = None
+                pae_initrd = None
+
+            for adtl in adtls:
+                distros_added.extend(adtl)
+
+    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:
+            utils.die(self.logger,"Arch from pathname (%s) does not match with supplied one %s"%(proposed_arch,self.arch))
+
+        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:
+            if self.breed in [ "suse" ]:
+                self.logger.warning("directory %s holds multiple arches : %s" % (dirname, archs))
+                return
+            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_kernel_options("install=http://@@http_server@@/cblr/links/%s"; % (name))
+            # 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)
+
+            # Create a rescue image as well, if this is not a xen distro
+            # but only for red hat profiles
+
+            # this code disabled as it seems to be adding "-rescue" to
+            # distros that are /not/ rescue related, which is wrong.
+            # left as a FIXME for those who find this feature interesting.
+            #if name.find("-xen") == -1 and self.breed == "redhat":
+            #    rescue_name = 'rescue-' + name
+            #    existing_profile = self.profiles.find(name=rescue_name)
+            #
+            #    if existing_profile is None:
+            #        self.logger.info("creating new profile: %s" % rescue_name)
+            #        profile = self.config.new_profile()
+            #    else:
+            #        continue
+            #
+            #    profile.set_name(rescue_name)
+            #    profile.set_distro(name)
+            #    profile.set_virt_type("qemu")
+            #    profile.kernel_options['rescue'] = None
+            #    profile.kickstart = '/var/lib/cobbler/kickstarts/pxerescue.ks'
+            #
+            #    self.profiles.add(profile,save=True)
+
+        return distros_added
+
+    def get_proposed_name(self,dirname,kernel=None):
+        """
+        Given a directory name where we have a kernel/initrd pair, try to autoname
+        the distribution (and profile) object based on the contents of that path
+        """
+
+        if self.network_root is not None:
+            name = self.mirror_name + "-".join(self.path_tail(os.path.dirname(self.path),dirname).split("/"))
+        else:
+            # remove the part that says /var/www/cobbler/ks_mirror/name
+            name = "-".join(dirname.split("/")[5:])
+
+        if kernel is not None and kernel.find("PAE") != -1:
+            name = name + "-PAE"
+        if kernel is not None and kernel.find("xen") != -1:
+            name = name + "-xen"
+
+        # we have our kernel in ../boot/<arch>/vmlinuz-xen and
+        # .../boot/<arch>/loader/vmlinuz
+        #
+        name = name.replace("-loader","")
+        name = name.replace("-boot","")
+
+        # some paths above the media root may have extra path segments we want
+        # to clean up
+        name = name.replace("-os","")
+        name = name.replace("-tree","")
+        name = name.replace("srv-www-cobbler-", "")
+        name = name.replace("var-www-cobbler-", "")
+        name = name.replace("ks_mirror-","")
+        name = name.replace("--","-")
+
+        for separator in [ '-' , '_'  , '.' ] :
+            for arch in [ "i386" , "x86_64" , "ia64" , "ppc64", "ppc32", "ppc", "x86" , "s390x", "s390" , "386" , "amd" ]:
+                name = name.replace("%s%s" % ( separator , arch ),"")
+
+        return name
+
+    def get_proposed_arch(self,dirname):
+        """
+        Given an directory name, can we infer an architecture from a path segment?
+        """
+        if dirname.find("x86_64") != -1 or dirname.find("amd") != -1:
+            return "x86_64"
+        if dirname.find("ia64") != -1:
+            return "ia64"
+        if dirname.find("i386") != -1 or dirname.find("386") != -1 or dirname.find("x86") != -1:
+            return "i386"
+        if dirname.find("s390x") != -1:
+            return "s390x"
+        if dirname.find("s390") != -1:
+            return "s390"
+        if dirname.find("ppc64") != -1 or dirname.find("chrp") != -1:
+            return "ppc64"
+        if dirname.find("ppc32") != -1:
+            return "ppc"
+        if dirname.find("ppc") != -1:
+            return "ppc"
+        return None
+
+    def arch_walker(self,foo,dirname,fnames):
+        """
+        See docs on learn_arch_from_tree.
+
+        The TRY_LIST is used to speed up search, and should be dropped for default importer
+        Searched kernel names are kernel-header, linux-headers-, kernel-largesmp, kernel-hugemem
+
+        This method is useful to get the archs, but also to package type and a raw guess of the breed
+        """
+
+        # try to find a kernel header RPM and then look at it's arch.
+        for x in fnames:
+            if self.match_kernelarch_file(x):
+                for arch in self.get_valid_arches():
+                    if x.find(arch) != -1:
+                        foo[arch] = 1
+                for arch in [ "i686" , "amd64" ]:
+                    if x.find(arch) != -1:
+                        foo[arch] = 1
+
+    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 rpm in self.get_release_files():
+                    results = self.scan_pkg_filename(rpm)
+                    # FIXME : If os is not found on tree but set with CLI, no kickstart is searched
+                    if results is None:
+                        self.logger.warning("No version found on imported tree")
+                        continue
+                    (flavor, major, minor) = results
+                    version , ks = self.set_variance(flavor, major, minor, distro.arch)
+                    if self.os_version:
+                        if self.os_version != version:
+                            utils.die(self.logger,"CLI version differs from tree : %s vs. %s" % (self.os_version,version))
+                    ds = self.get_datestamp()
+                    distro.set_comment("%s.%s" % (version, int(minor)))
+                    distro.set_os_version(version)
+                    if ds is not None:
+                        distro.set_tree_build_time(ds)
+                    profile.set_kickstart(ks)
+                    self.profiles.add(profile,save=True)
+
+            self.configure_tree_location(distro)
+            self.distros.add(distro,save=True) # re-save
+            self.api.serialize()
+
+    def configure_tree_location(self, distro):
+        """
+        Once a distribution is identified, find the part of the distribution
+        that has the URL in it that we want to use for kickstarting the
+        distribution, and create a ksmeta variable $tree that contains this.
+        """
+
+        base = self.get_rootdir()
+
+        if self.network_root is None:
+            dest_link = os.path.join(self.settings.webdir, "links", distro.name)
+            # create the links directory only if we are mirroring because with
+            # SELinux Apache can't symlink to NFS (without some doing)
+            if not os.path.exists(dest_link):
+                try:
+                    os.symlink(base + "-" + distro.arch, dest_link)
+                except:
+                    # this shouldn't happen but I've seen it ... debug ...
+                    self.logger.warning("symlink creation failed: %(base)s, %(dest)s") % { "base" : base, "dest" : dest_link }
+            # how we set the tree depends on whether an explicit network_root was specified
+            tree = "http://@@http_server@@/cblr/links/%s"; % (distro.name)
+            self.set_install_tree( distro, tree)
+        else:
+            # where we assign the kickstart source is relative to our current directory
+            # and the input start directory in the crawl.  We find the path segments
+            # between and tack them on the network source path to find the explicit
+            # network path to the distro that Anaconda can digest.
+            tail = utils.path_tail(self.path, base)
+            tree = self.network_root[:-1] + tail
+            self.set_install_tree( distro, tree)
+
+    def get_rootdir(self):
+        return self.rootdir
+
+    def get_pkgdir(self):
+        if not self.pkgdir:
+            return None
+        return os.path.join(self.get_rootdir(),self.pkgdir)
+
+    def set_install_tree(self, distro, url):
+        distro.ks_meta["tree"] = url
+
+    def learn_arch_from_tree(self):
+        """
+        If a distribution is imported from DVD, there is a good chance the path doesn't
+        contain the arch and we should add it back in so that it's part of the
+        meaningful name ... so this code helps figure out the arch name.  This is important
+        for producing predictable distro names (and profile names) from differing import sources
+        """
+        result = {}
+        # FIXME : this is called only once, should not be a walk
+        if self.get_pkgdir():
+            os.path.walk(self.get_pkgdir(), self.arch_walker, result)
+        if result.pop("amd64",False):
+            result["x86_64"] = 1
+        if result.pop("i686",False):
+            result["i386"] = 1
+        return result.keys()
+
+    def match_kernelarch_file(self, filename):
+        """
+        Is the given filename a kernel filename?
+        """
+
+        if not filename.endswith("rpm") and not filename.endswith("deb"):
+            return False
+        for match in ["kernel-header", "kernel-source", "kernel-smp", "kernel-default", "kernel-desktop", "linux-headers-", "kernel-devel", "kernel-"]:
+            if filename.find(match) != -1:
+                return True
+        return False
+
+    def scan_pkg_filename(self, rpm):
+        """
+        Determine what the distro is based on the release package filename.
+        """
+
+        rpm = os.path.basename(rpm)
+
+        return ("suse", 1, 1)
+
+    def get_datestamp(self):
+        """
+        Based on a RedHat tree find the creation timestamp
+        """
+        base = self.get_rootdir()
+        if os.path.exists("%s/.discinfo" % base):
+            discinfo = open("%s/.discinfo" % base, "r")
+            datestamp = discinfo.read().split("\n")[0]
+            discinfo.close()
+        else:
+            return 0
+        return float(datestamp)
+
+    def set_variance(self, flavor, major, minor, arch):
+        """
+        find the profile kickstart and set the distro breed/os-version based on what
+        we can find out from the rpm filenames and then return the kickstart
+        path to use.
+        """
+
+        os_version = "suse"
+
+        kickbase = "/var/lib/cobbler/kickstarts"
+        return os_version, "autoyast_sample.xml"
+
+# ==========================================================================
+
+def get_import_manager(config,logger):
+    return ImportSuseManager(config,logger)
diff --git a/kickstarts/autoyast_sample.xml b/kickstarts/autoyast_sample.xml
new file mode 100644
index 0000000..728aaa3
--- /dev/null
+++ b/kickstarts/autoyast_sample.xml
@@ -0,0 +1,45 @@
+<!--
+
+ Copyright (c) 2011 Novell
+ Uwe Gansert u...@suse.de
+
+ This software is licensed to you under the GNU General Public License,
+ version 2 (GPLv2). There is NO WARRANTY for this software, express or
+ implied, including the implied warranties of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
+ along with this software; if not, see
+ http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+
+-->
+<?xml version="1.0"?>
+<!DOCTYPE profile>
+<profile xmlns="http://www.suse.com/1.0/yast2ns"; xmlns:config="http://www.suse.com/1.0/configns";>
+  <networking>
+    <keep_install_network config:type="boolean">true</keep_install_network>
+  </networking>
+  <software>
+    <patterns config:type="list">
+      <pattern>base</pattern>
+    </patterns>
+  </software>
+  <users config:type="list">
+    <user>
+      <encrypted config:type="boolean">false</encrypted>
+      <fullname>root</fullname>
+      <gid>0</gid>
+      <home>/root</home>
+      <password_settings>
+        <expire></expire>
+        <flag></flag>
+        <inact></inact>
+        <max></max>
+        <min></min>
+        <warn></warn>
+      </password_settings>
+      <shell>/bin/bash</shell>
+      <uid>0</uid>
+      <user_password>s3cr3t</user_password>
+      <username>root</username>
+    </user>
+  </users>
+</profile>
-- 
1.7.3.4

_______________________________________________
Spacewalk-devel mailing list
Spacewalk-devel@redhat.com
https://www.redhat.com/mailman/listinfo/spacewalk-devel

Reply via email to