@@ -13,7 +13,8 @@

                 "elfutils-libelf", "sqlite-autoconf", "nspr", "nss", "popt", "lua", "rpm",

                 "gptfdisk", "tar", "gzip", "openssl", "python2", "python2-libs", "python-requests",

                 "pcre", "glib", "parted", "libsigc++", "XML-Parser", "glibmm", "dparted",

-                "libgsystem", "ostree","device-mapper","device-mapper-libs","libsepol","libselinux"]

+                "libgsystem", "ostree","device-mapper","device-mapper-libs","libsepol","libselinux", 

+                "db", "libsolv", "hawkey", "python-hawkey"]

 }

@@ -16,7 +16,9 @@ import fnmatch

 import signal

 import sys

 import glob

+import urllib

 import modules.commons

+import xml.etree.ElementTree as ET

 from jsonwrapper import JsonWrapper

 from progressbar import ProgressBar

 from window import Window

@@ -52,7 +54,6 @@ class Installer(object):

         else:

             self.output = None

-        self.install_factor = 3

         if self.iso_installer:

             #initializing windows

             self.maxy = maxy

@@ -105,7 +106,7 @@ class Installer(object):

                 continue

             if self.iso_installer:

                 self.progress_bar.update_message('Installing {0}...'.format(rpm['package']))

-            return_value = self.install_package(rpm['package'])

+            return_value = self.install_package(rpm['filename'])

             if return_value != 0:

                 self.exit_gracefully(None, None)

             if self.iso_installer:

@@ -135,14 +136,80 @@ class Installer(object):

         return ActionResult(True, None)

+    def download_file(self, url, directory):

+        # TODO: Add errors handling

+        urlopener = urllib.URLopener()

+        urlopener.retrieve(url, os.path.join(directory, os.path.basename(url)))

+

+    def download_rpms(self):

+        repodata_dir = os.path.join(self.photon_root, 'RPMS/repodata')

+        process = subprocess.Popen(['mkdir', '-p', repodata_dir], stdout=self.output)

+        retval = process.wait()

+

+        import hawkey

+        self.install_factor = 1

+        # Load the repo data

+        sack = hawkey.Sack()

+        

+        repomd_filename = "repomd.xml"

+        repomd_url = os.path.join(self.rpm_path, "repodata/repomd.xml")

+

+        self.download_file(repomd_url, repodata_dir)

+

+        # parse to the xml to get the primary and files list

+        tree = ET.parse(os.path.join(repodata_dir, repomd_filename))

+        # TODO: Get the namespace dynamically from the xml file

+        ns = {'ns': 'http://linux.duke.edu/metadata/repo'}

+

+        primary_location = tree.find("./ns:data[@type='primary']/ns:location", ns).get("href");

+        filelists_location = tree.find("./ns:data[@type='filelists']/ns:location", ns).get("href");

+        primary_filename = os.path.basename(primary_location);

+        filelists_filename = os.path.basename(filelists_location);

+

+        self.download_file(os.path.join(self.rpm_path, primary_location), repodata_dir)

+        self.download_file(os.path.join(self.rpm_path, filelists_location), repodata_dir)

+        

+        repo = hawkey.Repo("installrepo")

+        repo.repomd_fn = os.path.join(repodata_dir, repomd_filename)

+        repo.primary_fn = os.path.join(repodata_dir, primary_filename)

+        repo.filelists_fn = os.path.join(repodata_dir, filelists_filename)

+        

+        sack.load_yum_repo(repo, load_filelists=True)

+

+        progressbar_num_items = 0

+        self.rpms_tobeinstalled = []

+        selected_packages = self.install_config['packages']

+        for package in selected_packages:

+            # Locate the package

+            q = hawkey.Query(sack).filter(name=package)

+            if (len(q) > 0):

+                progressbar_num_items +=  q[0].size + q[0].size * self.install_factor

+                self.rpms_tobeinstalled.append({'package': package, 'size': q[0].size, 'location': q[0].location, 'filename': os.path.basename(q[0].location)})

+            else:

+                print >> sys.stderr, "Package %s not found in the repo" % package

+                #self.exit_gracefully(None, None)

+

+        self.progress_bar.update_num_items(progressbar_num_items)

+

+        # Download the rpms

+        for rpm in self.rpms_tobeinstalled:

+            message = 'Downloading {0}...'.format(rpm['filename'])

+            self.progress_bar.update_message(message)

+            self.download_file(os.path.join(self.rpm_path, rpm['location']), os.path.join(self.photon_root, "RPMS"))

+            self.progress_bar.increment(rpm['size'])

+        

+        # update the rpms path

+        self.rpm_path = os.path.join(self.photon_root, "RPMS")

+

     def copy_rpms(self):

         # prepare the RPMs list

+        self.install_factor = 3

         rpms = []

         for root, dirs, files in os.walk(self.rpm_path):

             for name in files:

                 file = os.path.join(root, name)

                 size = os.path.getsize(file)

-                rpms.append({'name': name, 'path': file, 'size': size})

+                rpms.append({'filename': name, 'path': file, 'size': size})

         progressbar_num_items = 0

         self.rpms_tobeinstalled = []

@@ -150,20 +217,20 @@ class Installer(object):

         for package in selected_packages:

             pattern = package + '-[0-9]*.rpm'

             for rpm in rpms:

-                if fnmatch.fnmatch(rpm['name'], pattern):

+                if fnmatch.fnmatch(rpm['filename'], pattern):

                     rpm['package'] = package

                     self.rpms_tobeinstalled.append(rpm)

                     progressbar_num_items += rpm['size'] + rpm['size'] * self.install_factor

                     break

-        process = subprocess.Popen(['mkdir', '-p', self.photon_root + '/RPMS'], stdout=self.output)

-        retval = process.wait()

-

         if self.iso_installer:

             self.progress_bar.update_num_items(progressbar_num_items)

         # Copy the rpms

         for rpm in self.rpms_tobeinstalled:

+            if self.iso_installer:

+                message = 'Copying {0}...'.format(rpm['filename'])

+                self.progress_bar.update_message(message)

             shutil.copy(rpm['path'], self.photon_root + '/RPMS/')

             if self.iso_installer:

                 self.progress_bar.increment(rpm['size'])

@@ -177,7 +244,14 @@ class Installer(object):

         process = subprocess.Popen(['cp', '-r', "../installer", self.photon_root], stdout=self.output)

         retval = process.wait()

-        self.copy_rpms()

+        # Create the rpms directory

+        process = subprocess.Popen(['mkdir', '-p', self.photon_root + '/RPMS'], stdout=self.output)

+        retval = process.wait()

+

+        if self.rpm_path.startswith("http://"):

+            self.download_rpms()

+        else:

+            self.copy_rpms()

     def initialize_system(self):

         #Setup the disk

@@ -25,8 +25,8 @@ from license import License

 class IsoInstaller(object):

-    def get_config(self, path, cd_path):

-        if path.startswith("http"):

+    def get_config(self, path):

+        if path.startswith("http://"):

             # Do 3 trials to get the kick start

             # TODO: make sure the installer run after network is up

             for x in range(0,3):

@@ -48,10 +48,15 @@ class IsoInstaller(object):

             raise Exception(err_msg)

         else:

             if path.startswith("cdrom:/"):

-                path = os.path.join(cd_path, path.replace("cdrom:/", "", 1))

+                self.mount_RPMS_cd()

+                path = os.path.join(self.cd_path, path.replace("cdrom:/", "", 1))

             return (JsonWrapper(path)).read();

     def mount_RPMS_cd(self):

+        # check if the cd is already mounted

+        if self.cd_path:

+            return

+

         # Mount the cd to get the RPMS

         process = subprocess.Popen(['mkdir', '-p', '/mnt/cdrom'])

         retval = process.wait()

@@ -61,7 +66,8 @@ class IsoInstaller(object):

             process = subprocess.Popen(['mount', '/dev/cdrom', '/mnt/cdrom'])

             retval = process.wait()

             if retval == 0:

-                return "/mnt/cdrom"

+                self.cd_path = "/mnt/cdrom"

+                return

             print "Failed to mount the cd, retry in a second"

             time.sleep(1)

         print "Failed to mount the cd, exiting the installer, check the logs for more details"

@@ -83,32 +89,40 @@ class IsoInstaller(object):

         curses.curs_set(0)

-        self.install_config = {'iso_system': False}

+        self.cd_path = None;

-        # Mount the cd for the RPM, tools, and may be the ks

-        cd_path = self.mount_RPMS_cd()

+        self.install_config = {'iso_system': False}

-        # check the kickstart params

-        ks_config = None

         kernel_params = subprocess.check_output(['cat', '/proc/cmdline'])

+

+        # check the kickstart param

+        ks_config = None

         m = re.match(r".*ks=(\S+)\s*.*\s*", kernel_params)

         if m != None:

-            ks_config = self.get_config(m.group(1), cd_path)

-

-        license_agreement = License(self.maxy, self.maxx)

-        select_disk = SelectDisk(self.maxy, self.maxx, self.install_config)

-        package_selector = PackageSelector(self.maxy, self.maxx, self.install_config, options_file)

-        hostname_reader = WindowStringReader(self.maxy, self.maxx, 10, 70, False,  'Choose the hostname for your system',

-            'Hostname:', 

-            2, self.install_config)

-        root_password_reader = WindowStringReader(self.maxy, self.maxx, 10, 70, True,  'Set up root password',

-            'Root password:', 

-            2, self.install_config)

-        installer = Installer(self.install_config, self.maxy, self.maxx, True, rpm_path=os.path.join(cd_path, "RPMS"), log_path="/var/log", ks_config=ks_config)

+            ks_config = self.get_config(m.group(1))

+

+        # check for the repo param

+        m = re.match(r".*repo=(\S+)\s*.*\s*", kernel_params)

+        if m != None:

+            rpm_path = m.group(1)

+        else:

+            # the rpms should be in the cd

+            self.mount_RPMS_cd()

+            rpm_path=os.path.join(self.cd_path, "RPMS")

         # This represents the installer screen, the bool indicated if I can go back to this window or not

         items = []

         if not ks_config:

+            license_agreement = License(self.maxy, self.maxx)

+            select_disk = SelectDisk(self.maxy, self.maxx, self.install_config)

+            package_selector = PackageSelector(self.maxy, self.maxx, self.install_config, options_file)

+            hostname_reader = WindowStringReader(self.maxy, self.maxx, 10, 70, False,  'Choose the hostname for your system',

+                'Hostname:', 

+                2, self.install_config)

+            root_password_reader = WindowStringReader(self.maxy, self.maxx, 10, 70, True,  'Set up root password',

+                'Root password:', 

+                2, self.install_config)

+            

             items = items + [

                     (license_agreement.display, False),

                     (select_disk.display, True),

@@ -116,6 +130,7 @@ class IsoInstaller(object):

                     (hostname_reader.get_user_string, True),

                     (root_password_reader.get_user_string, True),

                  ]

+        installer = Installer(self.install_config, self.maxy, self.maxx, True, rpm_path=rpm_path, log_path="/var/log", ks_config=ks_config)

         items = items + [(installer.install, False)]

         index = 0

@@ -27,7 +27,7 @@ fi

 [ ${EUID} -eq 0 ] 	|| fail "${PRGNAME}: Need to be root user: FAILURE"

 RPMPKG=""

-RPMPKG=$(find ${RPMROOT} -name "$1-[0-9]*.rpm" -print)

+RPMPKG=$(find ${RPMROOT} -name "$1" -print)

 # TODO: sometimes we catch several items into RPMPKG.

 # In case we have several releases in rpm cache. Need to handle that.

 [ -z $RPMPKG ] && fail "installation error: rpm package not found\n"

@@ -8,9 +8,9 @@ enabled = True

 def execute(name, ks_config, config, root):

     if ks_config:

-        package_list_micro = JsonWrapper("packages_micro.json").read()

-        package_list_minimal = JsonWrapper("packages_minimal.json").read()

-        package_list_full = JsonWrapper("packages_full.json").read()

+        package_list_micro = JsonWrapper("data/packages_micro.json").read()

+        package_list_minimal = JsonWrapper("data/packages_minimal.json").read()

+        package_list_full = JsonWrapper("data/packages_full.json").read()

         if ks_config['type'] == 'micro':

             packages = package_list_micro["packages"]