@@ -14,6 +14,10 @@ import requests

 import json

 import time

 import os

+import cracklib

+import crypt

+import string

+import random

 from diskpartitioner import DiskPartitioner

 from packageselector import PackageSelector

 from custompackageselector import CustomPackageSelector

@@ -21,10 +25,11 @@ from installer import Installer

 from installercontainer import InstallerContainer

 from ostreeinstaller import OstreeInstaller

 from windowstringreader import WindowStringReader

+from ostreewindowstringreader import OSTreeWindowStringReader

 from jsonwrapper import JsonWrapper

 from selectdisk import SelectDisk

 from license import License

-import random

+from ostreeserverselector import OSTreeServerSelector

 class IsoInstaller(object):

@@ -75,7 +80,24 @@ class IsoInstaller(object):

             time.sleep(1)

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

         raise Exception("Can not mount the cd")

-    

+

+    def validate_hostname(self, hostname):

+        error_msg = "It should start with alpha char and ends with alpha-numeric char"

+        if (hostname == None or len(hostname) == 0):

+            return False, error_msg

+        return (ord(hostname[0]) in self.alpha_chars) and (hostname[-1] not in ['.', '-']), error_msg

+

+    def validate_password(self, text):

+        try:

+            p = cracklib.VeryFascistCheck(text)

+        except ValueError, message:

+            p = str(message)

+        return p == text, "Error: " + p

+

+    def generate_password_hash(self,  password):

+        shadow_password = crypt.crypt(password, "$6$" + "".join([random.choice(string.ascii_letters + string.digits) for _ in range(16)]))

+        return shadow_password

+

     def __init__(self, stdscreen, options_file):

         self.screen = stdscreen

@@ -120,16 +142,64 @@ class IsoInstaller(object):

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

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

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

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

-                'Hostname:', 

-                2, install_config,

-                random_hostname)

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

-                'Root password:', 

-                2, install_config)

-            confirm_password_reader = WindowStringReader(self.maxy, self.maxx, 10, 70, 'password', True,  'Confirm root password',

-                'Confirm Root password:', 

-                2, install_config)

+

+            self.alpha_chars = range(65, 91)

+            self.alpha_chars.extend(range(97,123))

+            hostname_accepted_chars = list(self.alpha_chars)

+            # Adding the numeric chars

+            hostname_accepted_chars.extend(range(48, 58))

+            # Adding the . and -

+            hostname_accepted_chars.extend([ord('.'), ord('-')])

+            

+            hostname_reader = WindowStringReader(

+                    self.maxy, self.maxx, 10, 70, 

+                    'hostname', 

+                    None, # confirmation error msg if it's a confirmation text

+                    None, # echo char

+                    hostname_accepted_chars, # set of accepted chars

+                    self.validate_hostname, # validation function of the input

+                    None, # post processing of the input field

+                    'Choose the hostname for your system', 'Hostname:', 2, install_config,

+                    random_hostname)

+            root_password_reader = WindowStringReader(

+                    self.maxy, self.maxx, 10, 70, 

+                    'password', 

+                    None, # confirmation error msg if it's a confirmation text

+                    '*', # echo char

+                    None, # set of accepted chars

+                    self.validate_password, # validation function of the input

+                    None,  # post processing of the input field

+                    'Set up root password', 'Root password:', 2, install_config)

+            confirm_password_reader = WindowStringReader(

+                    self.maxy, self.maxx, 10, 70, 

+                    'password', 

+                    "Passwords don't match, please try again.", # confirmation error msg if it's a confirmation text

+                    '*', # echo char

+                    None, # set of accepted chars

+                    None, # validation function of the input

+                    self.generate_password_hash, # post processing of the input field

+                    'Confirm root password', 'Confirm Root password:', 2, install_config)

+            ostree_server_selector = OSTreeServerSelector(self.maxy, self.maxx, install_config)

+            ostree_url_reader = OSTreeWindowStringReader(

+                    self.maxy, self.maxx, 10, 80, 

+                    'ostree_repo_url', 

+                    None, # confirmation error msg if it's a confirmation text

+                    None, # echo char

+                    None, # set of accepted chars

+                    None, # validation function of the input

+                    None, # post processing of the input field

+                    'Please provide the URL of OSTree repo', 'OSTree Repo URL:', 2, install_config,

+                    "https://dl.bintray.com/vmware/photon/rpm-ostree/dev/x86_64/minimal")

+            ostree_ref_reader = OSTreeWindowStringReader(

+                    self.maxy, self.maxx, 10, 70, 

+                    'ostree_repo_ref', 

+                    None, # confirmation error msg if it's a confirmation text

+                    None, # echo char

+                    None, # set of accepted chars

+                    None, # validation function of the input

+                    None, # post processing of the input field

+                    'Please provide the Ref in OSTree repo', 'OSTree Repo Ref:', 2, install_config,

+                    "dev/x86_64/minimal")

             items = items + [

                     (license_agreement.display, False),

@@ -138,6 +208,9 @@ class IsoInstaller(object):

                     (hostname_reader.get_user_string, True),

                     (root_password_reader.get_user_string, True),

                     (confirm_password_reader.get_user_string, False),

+                    (ostree_server_selector.display, True),

+                    (ostree_url_reader.get_user_string, True),

+                    (ostree_ref_reader.get_user_string, True),

                  ]

         else:

             install_config = ks_config

@@ -20,69 +20,17 @@ import urllib

 import modules.commons

 import xml.etree.ElementTree as ET

 from jsonwrapper import JsonWrapper

-from progressbar import ProgressBar

-from windowstringreader import WindowStringReader

-from window import Window

-from actionresult import ActionResult

 from installer import Installer

-from menu import Menu

 class OstreeInstaller(Installer):

     def __init__(self, install_config, maxy = 0, maxx = 0, iso_installer = False, rpm_path = "../stage/RPMS", log_path = "../stage/LOGS", ks_config = None):

         Installer.__init__(self, install_config, maxy, maxx, iso_installer, rpm_path, log_path, ks_config)

-        self.win_height = 13

-        self.win_width = 50

-        self.menu_starty = self.starty + 3    

-        self.ostree_host_menu_items = []

-        self.ostree_host_menu_items.append(("Default RPM-OSTree Server", self.default_installation, []))

-        self.ostree_host_menu_items.append(("Custom RPM-OSTree Server", self.custom_installation, []))

-        self.host_menu = Menu(self.menu_starty,  self.maxx, self.ostree_host_menu_items)

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Select OSTree Server', True, self.host_menu)

-        self.default_repo = True

-

-    def default_installation(self,  selected_item_params):

-        self.default_repo = True

-        return ActionResult(True, None)

-

-    def custom_installation(self,  selected_item_params):

-        self.default_repo = False

-        success = False

-        while not success:

-            got_the_url = False

-            while not got_the_url:

-                ostree_url_reader = WindowStringReader(

-                    self.maxy, self.maxx, 10, 70,

-                    "ostree_repo_url", False,

-                    "Please provide the URL of OSTree repo",

-                    "OSTree Repo URL:", 2,

-                    self.install_config,

-                    "https://dl.bintray.com/vmware/photon/rpm-ostree/dev/x86_64/minimal")

-

-                ret = ostree_url_reader.get_user_string(None)

-                self.ostree_repo_url = ret.result

-                got_the_url = ret.success

-

-            ostree_ref_reader = WindowStringReader(self.maxy,

-                self.maxx, 10, 70,

-                "ostree_ref", False,

-                "Please provide the Ref in OSTree repo",

-                "OSTree Repo Ref:", 2,

-                self.install_config,

-                "dev/x86_64/minimal")

-

-            ret = ostree_ref_reader.get_user_string(None)

-            self.ostree_ref = ret.result

-            success = ret.success

-

-        return ActionResult(True, None)

     def get_ostree_repo_url(self):

-        if self.ks_config != None:

-            self.ostree_repo_url = self.ks_config['ostree_repo_url']

-            self.ostree_ref = self.ks_config['ostree_repo_ref']

-            return

-        self.window.do_action()

+        self.default_repo = 'default_repo' in self.install_config and self.install_config['default_repo'];

+        self.ostree_repo_url = self.install_config['ostree_repo_url']

+        self.ostree_ref = self.install_config['ostree_repo_ref']

     def deploy_ostree(self, repo_url, repo_ref):

         self.run("ostree admin --sysroot={} init-fs {}".format(self.photon_root, self.photon_root), "Initializing OSTree filesystem")

new file mode 100644

@@ -0,0 +1,42 @@

+#!/usr/bin/python2

+#

+#    Copyright (C) 2015 vmware inc.

+#

+#    Author: Mahmoud Bassiouny <mbassiouny@vmware.com>

+

+import json

+import os

+import curses

+from sets import Set

+from jsonwrapper import JsonWrapper

+from menu import Menu

+from window import Window

+from actionresult import ActionResult

+

+class OSTreeServerSelector(object):

+    def __init__(self,  maxy, maxx, install_config):

+        self.install_config = install_config

+        win_width = 50

+        win_height = 13

+

+        win_starty = (maxy - win_height) / 2

+        win_startx = (maxx - win_width) / 2

+

+        menu_starty = win_starty + 3

+

+        ostree_host_menu_items = [

+                                        ("Default RPM-OSTree Server", self.set_default_repo_installation, True),

+                                        ("Custom RPM-OSTree Server", self.set_default_repo_installation, False)

+                                    ]

+

+        host_menu = Menu(menu_starty,  maxx, ostree_host_menu_items)

+        self.window = Window(win_height, win_width, maxy, maxx, 'Select OSTree Server', True, host_menu)

+

+    def set_default_repo_installation(self,  is_default_repo ):

+        self.install_config['default_repo'] = is_default_repo

+        return ActionResult(True, None)

+

+    def display(self, params):

+        if self.install_config['type'] == 'ostree_host':

+            return self.window.do_action()

+        return ActionResult(True, None)

new file mode 100644

@@ -0,0 +1,17 @@

+#!/usr/bin/python2

+#

+#    Copyright (C) 2015 vmware inc.

+#

+#    Author: Mahmoud Bassiouny <mbassiouny@vmware.com>

+

+from windowstringreader import WindowStringReader

+from actionresult import ActionResult

+

+class OSTreeWindowStringReader(WindowStringReader):

+    def __init__(self, maxy, maxx, height, width, field, confirmation_err_msg, echo_char, accepted_chars, validation_fn, conversion_fn, title, display_string, inputy, install_config, default_string = None):

+        WindowStringReader.__init__(self, maxy, maxx, height, width, field, confirmation_err_msg, echo_char, accepted_chars, validation_fn, conversion_fn, title, display_string, inputy, install_config, default_string)

+

+    def get_user_string(self, params):

+        if self.install_config['type'] == 'ostree_host' and not self.install_config['default_repo']:

+            return self.window.do_action()

+        return ActionResult(True, None)

@@ -5,24 +5,24 @@

 #    Author: Mahmoud Bassiouny <mbassiouny@vmware.com>

 import curses

-import crypt

-import string

-import random

-import cracklib

 import sys

 from actionresult import ActionResult

 from action import Action

 from confirmwindow import ConfirmWindow

 class ReadText(Action):

-    def __init__(self, maxy, maxx, textwin, y, install_config, field, confirm_pass, default_string = None):

+    def __init__(self, maxy, maxx, textwin, y, install_config, field, confirmation_error_msg, echo_char, accepted_chars, validation_fn, conversion_fn, default_string = None):

         self.textwin = textwin

         self.maxy = maxy

         self.maxx = maxx

         self.y = y

         self.install_config = install_config

         self.field = field

-        self.confirm_pass = confirm_pass;

+        self.confirmation_error_msg = confirmation_error_msg

+        self.echo_char = echo_char

+        self.accepted_chars = accepted_chars

+        self.validation_fn = validation_fn

+        self.conversion_fn = conversion_fn

         self.default_string = default_string

         self.textwin_width = self.textwin.getmaxyx()[1] - 1

         self.visible_text_width = self.textwin_width - 1

@@ -31,19 +31,8 @@ class ReadText(Action):

         self.maxlength = 255

         #initialize the accepted characters

-        if self.field == "password":

-            # Adding all the letters

-            self.accepted_chars = range(33, 127)

-        elif self.field == "hostname":

-

-            self.alpha_chars = range(65, 91)

-            self.alpha_chars.extend(range(97,123))

-            

-            self.accepted_chars = list(self.alpha_chars)

-            # Adding the numeric chars

-            self.accepted_chars.extend(range(48, 58))

-            # Adding the . and -

-            self.accepted_chars.extend([ord('.'), ord('-')])

+        if accepted_chars:

+            self.accepted_chars = accepted_chars

         else:

             self.accepted_chars = range(33, 127)

@@ -77,31 +66,20 @@ class ReadText(Action):

             ch = self.textwin.getch(self.y, curs_loc)

             if ch in [curses.KEY_ENTER, ord('\n')]:

-                if self.confirm_pass:

-                    if self.str != self.install_config['password']:

+                if self.confirmation_error_msg:

+                    if self.str != self.install_config[self.field]:

                         curses.curs_set(0)

                         conf_message_height = 8

                         conf_message_width = 48

                         conf_message_button_y = (self.maxy - conf_message_height) / 2 + 5

-                        confrim_window = ConfirmWindow(conf_message_height, conf_message_width, self.maxy, self.maxx, conf_message_button_y, "Passwords don't match, please try again.", True)

+                        confrim_window = ConfirmWindow(conf_message_height, conf_message_width, self.maxy, self.maxx, conf_message_button_y, self.confirmation_error_msg, True)

                         confrim_window.do_action()

                         return ActionResult(False, {'goBack': True})

-                    self.install_config['password'] = self.generate_password_hash(self.str)

-                elif self.field == "password":

-                    err = self.validate_password(self.str)

-                    if err != self.str:

-                        self.init_text()

-                        self.textwin.addstr(self.y + 2, 0, "Error: " + err, curses.color_pair(4))

-                        continue

-                    self.install_config['password'] = self.str;

-                elif self.field == "hostname":

-                    if not self.validate_hostname(self.str):

-                        self.textwin.addstr(self.y + 2, 0, "It should start with alpha char and ends with alpha-numeric char", curses.color_pair(4))

-                        continue

-                    self.install_config['hostname'] = self.str

+                    self.set_field()

                 else:

-                    self.install_config[self.field] = self.str

-                    return ActionResult(True, self.str)

+                    if not self.validate_input():

+                        continue

+                    self.set_field()

                 curses.curs_set(0)

                 return ActionResult(True, None)

             elif ch in [ord('\t')]:

@@ -122,24 +100,24 @@ class ReadText(Action):

                     text = self.str[-self.visible_text_width:]

                 else:

                     text = self.str

-                if self.field == "password":

-                    text = '*' * len(text)

+                if self.echo_char:

+                    text = self.echo_char * len(text)

                 # Add the dashes

                 text = text + '_' * (self.visible_text_width - len(self.str))

                 self.textwin.addstr(self.y, 0, text)

-    def validate_hostname(self, hostname):

-        if (hostname == None or len(hostname) == 0):

-            return False;

-        return (ord(hostname[0]) in self.alpha_chars) and (hostname[-1] not in ['.', '-'])

-

-    def validate_password(self, text):

-        try:

-            p = cracklib.VeryFascistCheck(text)

-        except ValueError, message:

-            p = str(message)

-        return p

-

-    def generate_password_hash(self,  password):

-        shadow_password = crypt.crypt(password, "$6$" + "".join([random.choice(string.ascii_letters + string.digits) for _ in range(16)]))

-        return shadow_password

+    def set_field(self):

+        if self.conversion_fn:

+            self.install_config[self.field] = self.conversion_fn(self.str)

+        else:

+            self.install_config[self.field] = self.str

+

+    def validate_input(self):

+        if self.validation_fn:

+            success, err = self.validation_fn(self.str)

+            if not success:

+                self.textwin.addstr(self.y + 2, 0, err, curses.color_pair(4))

+            return success

+        else:

+            return True

+

@@ -9,9 +9,10 @@ from window import Window

 from readtext import ReadText

 class WindowStringReader(object):

-    def __init__(self, maxy, maxx, height, width, field, confirm_password, title, display_string, inputy, install_config, default_string = None):

+    def __init__(self, maxy, maxx, height, width, field, confirmation_err_msg, echo_char, accepted_chars, validation_fn, conversion_fn, title, display_string, inputy, install_config, default_string = None):

         self.title = title

         self.display_string = display_string

+        self.install_config = install_config

         self.inputy = inputy

         self.width = width

@@ -23,7 +24,7 @@ class WindowStringReader(object):

         self.starty = (self.maxy - self.height) / 2

         self.window = Window(self.height, self.width, self.maxy, self.maxx, self.title, True)

-        self.read_text = ReadText(maxy, maxx, self.window.content_window(), self.inputy, install_config, field, confirm_password, default_string)

+        self.read_text = ReadText(maxy, maxx, self.window.content_window(), self.inputy, install_config, field, confirmation_err_msg, echo_char, accepted_chars, validation_fn, conversion_fn, default_string)

         self.window.set_action_panel(self.read_text)

         self.window.addstr(0, 0, self.display_string)