def update_menu(self, action_result): if (action_result.result and 'goNext' in action_result.result and action_result.result['goNext']): return ActionResult(True, None) if self.position == 0: self.contentwin.addstr(self.height - 3, 5, '<Go Back>') self.contentwin.refresh() self.hide_window() self.action_panel.hide() return ActionResult(False, None) else: if (action_result.result != None and 'diskIndex' in action_result.result): params = action_result.result['diskIndex'] if self.menu_helper: self.menu_helper(params) result = self.items[self.position - 1][1]() if result.success: self.hide_window() self.action_panel.hide() return result else: if 'goBack' in result.result and result.result['goBack']: self.contentwin.refresh() self.hide_window() self.action_panel.hide() return ActionResult(False, None)
def exit_function(self, selected_item_params): selection = self.NET_CONFIG_OPTION_STRINGS.index( selected_item_params[0]) if selection == self.NET_CONFIG_OPTION_DHCP: self.install_config['network']['type'] = 'dhcp' elif selection == self.NET_CONFIG_OPTION_DHCP_HOSTNAME: network_config = {} random_id = '%12x' % random.randrange(16**12) random_hostname = 'photon-' + random_id.strip() accepted_chars = list(range(ord('A'), ord('Z') + 1)) accepted_chars = list(range(ord('a'), ord('z') + 1)) accepted_chars.extend(range(ord('0'), ord('9') + 1)) accepted_chars.extend([ord('.'), ord('-')]) result = WindowStringReader( self.maxy, self.maxx, 13, 80, 'hostname', None, None, accepted_chars, NetworkConfigure.validate_hostname, None, 'Choose the DHCP hostname for your system', 'DHCP Hostname:', 2, network_config, random_hostname, True).get_user_string(None) if not result.success: return ActionResult(False, {'custom': False}) self.install_config['network'] = network_config self.install_config['network']['type'] = 'dhcp' elif selection == self.NET_CONFIG_OPTION_MANUAL: network_config = {} items = ['IP Address', 'Netmask', 'Gateway', 'Nameserver'] keys = ['ip_addr', 'netmask', 'gateway', 'nameserver'] self.create_window = ReadMulText(self.maxy, self.maxx, 0, network_config, '_conf_', items, None, None, None, self.validate_static_conf, None, True) result = self.create_window.do_action() if not result.success: return ActionResult(False, {'goBack': True}) for i in range(len(items)): network_config[keys[i]] = network_config.pop( '_conf_' + str(i), None) self.install_config['network'] = network_config self.install_config['network']['type'] = 'static' elif selection == self.NET_CONFIG_OPTION_VLAN: network_config = {} result = WindowStringReader( self.maxy, self.maxx, 18, 75, 'vlan_id', None, None, list(range(48, 58)), NetworkConfigure.validate_vlan_id, None, '[!] Configure the network', self.VLAN_READ_STRING, 6, network_config, '', True).get_user_string(True) if not result.success: return ActionResult(False, {'goBack': True}) self.install_config['network'] = network_config self.install_config['network']['type'] = 'vlan' return ActionResult(True, {'custom': False})
def guided_partitions(self, device_index): menu_height = 9 menu_width = 40 menu_starty = (self.maxy - menu_height) / 2 + 5 confrim_window = ConfirmWindow( menu_height, menu_width, self.maxy, self.maxx, menu_starty, 'This will erase the disk.\nAre you sure?') confirmed = confrim_window.do_action().result['yes'] if not confirmed: return ActionResult(confirmed, None) self.progress_bar.initialize('Partitioning...') self.progress_bar.show() self.progress_bar.show_loading('Partitioning') # Do the partitioning self.window.clearerror() partitions_data = modules.commons.partition_disk( self.devices[device_index].path) if partitions_data == None: self.window.adderror('Partitioning failed, you may try again') else: self.install_config['disk'] = partitions_data self.progress_bar.hide() return ActionResult(partitions_data != None, None)
def guided_partitions(self, params): if not 'diskindex' in self.install_config: return ActionResult(False, None) device_index = self.install_config['diskindex'] menu_height = 9 menu_width = 40 menu_starty = (self.maxy - menu_height) // 2 + 5 self.install_config['delete_partition'] = True confrim_window = ConfirmWindow(menu_height, menu_width, self.maxy, self.maxx, menu_starty, 'This will erase the disk.\nAre you sure?') confirmed = confrim_window.do_action().result['yes'] if confirmed == False: self.install_config['skipPrevs'] = True return ActionResult(False, {'goBack':True}) self.install_config['skipPrevs'] = False self.progress_bar.initialize('Partitioning...') self.progress_bar.show() self.progress_bar.show_loading('Partitioning') # Do the partitioning if 'partitionsnumber' in self.install_config: if int(self.install_config['partitionsnumber']) == 0: partitions_data = modules.commons.partition_disk( self.devices[device_index].path, modules.commons.default_partitions) else: partitions = [] for i in range(int(self.install_config['partitionsnumber'])): if len(self.install_config[str(i)+'partition_info'+str(0)]) == 0: sizedata = 0 else: sizedata = int(self.install_config[str(i) + 'partition_info' + str(0)]) mtdata = self.install_config[str(i) + 'partition_info' + str(2)] typedata = self.install_config[str(i) + 'partition_info'+str(1)] partitions = partitions + [{"mountpoint": mtdata, "size": sizedata, "filesystem": typedata},] partitions_data = modules.commons.partition_disk( self.devices[device_index].path, partitions) else: partitions_data = modules.commons.partition_disk( self.devices[device_index].path, modules.commons.default_partitions) if partitions_data == None: self.partition_window.adderror('Partitioning failed, you may try again') else: self.install_config['disk'] = partitions_data arch = subprocess.check_output(['uname', '-m'], universal_newlines=True) if "x86" in arch: self.install_config['boot'] = 'dualboot' else: self.install_config['boot'] = 'efi' self.progress_bar.hide() return ActionResult(partitions_data != None, None)
def do_action(self): self.init_text() curses.curs_set(1) if self.default_string != None: self.textwin.addstr(self.y, 0, self.default_string) self.str = self.default_string while True: if len(self.str) > self.visible_text_width: curs_loc = self.visible_text_width else: curs_loc = len(self.str) ch = self.textwin.getch(self.y, curs_loc) update_text = False if ch in [curses.KEY_ENTER, ord('\n')]: 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, self.confirmation_error_msg, True) confrim_window.do_action() return ActionResult(False, {'goBack': True}) self.set_field() else: if not self.validate_input(): continue self.set_field() curses.curs_set(0) return ActionResult(True, None) elif ch in [ord('\t')]: curses.curs_set(0) return ActionResult(False, None) elif ch == 127: # Handle the backspace case self.str = self.str[:len(self.str) - 1] update_text = True elif len(self.str) < self.maxlength and ch in self.accepted_chars: self.str += chr(ch) update_text = True if update_text: if len(self.str) > self.visible_text_width: text = self.str[-self.visible_text_width:] else: text = self.str 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 guided_partitions(self, device_index): menu_height = 9 menu_width = 40 menu_starty = (self.maxy - menu_height) / 2 + 5 confrim_window = ConfirmWindow( menu_height, menu_width, self.maxy, self.maxx, menu_starty, 'This will erase the disk.\nAre you sure?') confirmed = confrim_window.do_action().result['yes'] if not confirmed: return ActionResult(confirmed, None) #self.install_config['disk'] = self.devices[device_index].path #return ActionResult(True, None) # Do the partitioning self.window.clearerror() json_ret = subprocess.check_output([ 'gpartedbin', 'defaultpartitions', self.devices[device_index].path ], stderr=open(os.devnull, 'w')) json_dct = json.loads(json_ret) if json_dct['success']: self.install_config['disk'] = json_dct['data'] else: self.window.adderror('Partitioning failed, you may try again') return ActionResult(json_dct['success'], None)
def display(self): if 'ostree' in self.install_config: return ActionResult(None, {"inactive_screen": True}) self.create_available_linux_menu() if len(self.menu_items) < 2: return ActionResult(None, {"inactive_screen": True}) self.window.addstr(0, 0, 'Which type of Linux kernel would you like to install?') return self.window.do_action()
def display(self, params): if 'skipPrevs' in self.install_config and self.install_config[ 'skipPrevs'] == True: self.delete() return ActionResult(False, {'goBack': True}) if 'autopartition' in self.install_config and self.install_config[ 'autopartition'] == True: return ActionResult(True, None) if 'delete_partition' in self.install_config and self.install_config[ 'delete_partition'] == True: self.delete() self.install_config['delete_partition'] = False self.device_index = self.install_config['diskindex'] self.disk_buttom_items = [] self.disk_buttom_items.append(('<Next>', self.next)) self.disk_buttom_items.append(('<Create New>', self.create_function)) self.disk_buttom_items.append(('<Delete All>', self.delete_function)) self.disk_buttom_items.append(('<Go Back>', self.go_back)) self.text_items = [] self.text_items.append(('Disk', 20)) self.text_items.append(('Size', 5)) self.text_items.append(('Type', 5)) self.text_items.append(('Mountpoint', 20)) self.table_space = 5 title = 'Current partitions:\n' self.window.addstr(0, (self.win_width - len(title)) / 2, title) info = "Unpartitioned space: " + str( self.disk_size[self.device_index][1]) + " MB, Total size: " + str( int(self.devices[self.device_index].size) / 1048576) + " MB" self.text_pane = TextPane(self.text_starty, self.maxx, self.text_width, "EULA.txt", self.text_height, self.disk_buttom_items, partition=True, popupWindow=True, install_config=self.install_config, text_items=self.text_items, table_space=self.table_space, default_start=1, info=info, size_left=str( self.disk_size[self.device_index][1])) self.window.set_action_panel(self.text_pane) return self.window.do_action()
def exit_function(self, selected_item_params): if selected_item_params[0] == 'ostree_host': self.install_config['ostree'] = {} else: self.install_config.pop('ostree', None) self.install_config['packages'] = selected_item_params[1] return ActionResult(True, {'custom': False})
def next(self): if self.install_config['partitionsnumber'] == 0: window_height = 9 window_width = 40 window_starty = (self.maxy - window_height) / 2 + 5 confirm_window = ConfirmWindow( window_height, window_width, self.maxy, self.maxx, window_starty, 'Partition information cannot be empty', info=True) confirm_window.do_action() return self.display(False) #must have / if not self.has_slash: window_height = 9 window_width = 40 window_starty = (self.maxy - window_height) / 2 + 5 confirm_window = ConfirmWindow(window_height, window_width, self.maxy, self.maxx, window_starty, 'Missing /', info=True) confirm_window.do_action() return self.display(False) self.window.hide_window() self.text_pane.hide() return ActionResult(True, {'goNext': True})
def display(self): if self.setup_network and not self.do_setup_network(): return ActionResult(False, {'goBack': True}) file_source = {} accepted_chars = list(range(ord('a'), ord('z') + 1)) accepted_chars.extend(range(ord('A'), ord('Z') + 1)) accepted_chars.extend(range(ord('0'), ord('9') + 1)) accepted_chars.extend( [ord('-'), ord('_'), ord('.'), ord('~'), ord(':'), ord('/')]) result = WindowStringReader(self.maxy, self.maxx, 18, 78, 'url', None, None, accepted_chars, None, None, self.title, self.intro, 10, file_source, 'https://', True).get_user_string(None) if not result.success: return result status_window = Window(10, 70, self.maxy, self.maxx, 'Installing Photon', False) status_window.addstr(1, 0, 'Downloading file...') status_window.show_window() fd, temp_file = tempfile.mkstemp() result, msg = CommandUtils.wget( file_source['url'], temp_file, ask_fn=self.ask_proceed_unsafe_download) os.close(fd) if not result: status_window.adderror('Error: ' + msg + ' Press any key to go back...') status_window.content_window().getch() status_window.clearerror() status_window.hide_window() return ActionResult(False, {'goBack': True}) if 'additional_files' not in self.install_config: self.install_config['additional_files'] = [] copy = {temp_file: self.dest} self.install_config['additional_files'].append(copy) return ActionResult(True, None)
def exit_function(self, selected_indexes): selected_items = [] for index in selected_indexes: selected_items.append(self.menu_items[index][0]) self.install_config['packages'] = self.package_list_json[ "minimal_packages"] + selected_items return ActionResult(True, None)
def unsafe_install(self, params): if self.iso_installer: self.window.show_window() self.progress_bar.initialize('Initializing installation...') self.progress_bar.show() self.execute_modules(modules.commons.PRE_INSTALL) self.initialize_system() #install packages for rpm in self.rpms_tobeinstalled: # We already installed the filesystem in the preparation if rpm['package'] == 'filesystem': continue if self.iso_installer: self.progress_bar.update_message('Installing {0}...'.format( rpm['package'])) return_value = self.install_package(rpm['package']) if return_value != 0: self.exit_gracefully(None, None) if self.iso_installer: self.progress_bar.increment(rpm['size'] * self.install_factor) if self.iso_installer: self.progress_bar.show_loading('Finalizing installation') self.finalize_system() if not self.install_config['iso_system']: # Execute post installation modules self.execute_modules(modules.commons.POST_INSTALL) # install grub process = subprocess.Popen([ self.setup_grub_command, '-w', self.photon_root, self.install_config['disk']['disk'], self.install_config['disk']['root'] ], stdout=self.output) retval = process.wait() process = subprocess.Popen( [self.unmount_disk_command, '-w', self.photon_root], stdout=self.output) retval = process.wait() if self.iso_installer: self.progress_bar.hide() self.window.addstr( 0, 0, 'Congratulations, Photon has been installed in {0} secs.\n\nPress any key to continue to boot...' .format(self.progress_bar.time_elapsed)) if self.ks_config == None: self.window.content_window().getch() return ActionResult(True, None)
def get_user_string(self): result = ActionResult(True, None) if 'ostree' in self.install_config and not self.install_config[ 'ostree']['default_repo']: result = self.wsr.window.do_action() if result.success: self.install_config['ostree'][self.field] = self.config[ self.field] return result
def do_action(self): curses.curs_set(1) while True: ch = self.textwin.getch(self.y, self.x) if ch in [curses.KEY_ENTER, ord('\n')]: if self.ispassword: err = self.validate_password(self.str) if err != self.str: spaces = ' ' * (self.textwin.getmaxyx()[1] - 1) self.textwin.addstr(self.y + 2, 0, spaces) self.textwin.addstr(self.y + 2, 0, "Error: " + err, curses.color_pair(4)) continue self.install_config[ 'password'] = self.generate_password_hash(self.str) else: 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 curses.curs_set(0) return ActionResult(True, None) elif ch in [ord('\t')]: curses.curs_set(0) return ActionResult(False, None) elif ch == 127: # Handle the backspace case self.x -= 1 if self.x < 0: self.x = 0 self.textwin.addch(self.y, self.x, ord('_')) self.str = self.str[:len(self.str) - 1] elif self.x < self.maxlength and ch in self.accepted_chars: if (self.ispassword): self.textwin.echochar(ord('*')) else: self.textwin.echochar(ch) self.str += chr(ch) self.x += 1
def exit_function(self, selected_indexes): json_wrapper_package_list = JsonWrapper("packages_minimal.json") package_list_json = json_wrapper_package_list.read() selected_items = [] for index in selected_indexes: selected_items.append(self.menu_items[index][0]) self.install_config[ 'packages'] = package_list_json["packages"] + selected_items return ActionResult(True, None)
def display(self): if 'ostree' in self.install_config: return ActionResult(None, {"inactive_screen": True}) self.window.addstr( 0, 0, 'The installer has detected that you are installing') self.window.addstr(1, 0, 'Photon OS on a VMware hypervisor.') self.window.addstr( 2, 0, 'Which type of Linux kernel would you like to install?') return self.window.do_action()
def next(self): if self.cp_config['partitionsnumber'] == 0: window_height = 9 window_width = 40 window_starty = (self.maxy - window_height) // 2 + 5 confirm_window = ConfirmWindow( window_height, window_width, self.maxy, self.maxx, window_starty, 'Partition information cannot be empty', info=True) confirm_window.do_action() return self.display() #must have / if not self.has_slash: window_height = 9 window_width = 40 window_starty = (self.maxy - window_height) // 2 + 5 confirm_window = ConfirmWindow(window_height, window_width, self.maxy, self.maxx, window_starty, 'Missing /', info=True) confirm_window.do_action() return self.display() self.window.hide_window() self.partition_pane.hide() partitions = [] for i in range(int(self.cp_config['partitionsnumber'])): if len(self.cp_config[str(i) + 'partition_info' + str(0)]) == 0: sizedata = 0 else: sizedata = int(self.cp_config[str(i) + 'partition_info' + str(0)]) mtdata = self.cp_config[str(i) + 'partition_info' + str(2)] typedata = self.cp_config[str(i) + 'partition_info' + str(1)] partitions = partitions + [ { "mountpoint": mtdata, "size": sizedata, "filesystem": typedata }, ] self.install_config['partitions'] = partitions return ActionResult(True, {'goNext': True})
def validate_partition(self, pstr): if not pstr: return ActionResult(False, None) sizedata = pstr[0] mtdata = pstr[2] typedata = pstr[1] devicedata = self.devices[self.device_index].path #no empty fields unless swap if (typedata == 'swap' and (len(mtdata) != 0 or len(typedata) == 0 or len(devicedata) == 0)): return False, "invalid swap data " if (typedata != 'swap' and (len(sizedata) == 0 or len(mtdata) == 0 or len(typedata) == 0 or len(devicedata) == 0)): if not self.has_empty and mtdata and typedata and devicedata: self.has_empty = True else: return False, "Input cannot be empty" if typedata != 'swap' and typedata != 'ext3' and typedata != 'ext4': return False, "Invalid type" if len(mtdata) != 0 and mtdata[0] != '/': return False, "Invalid path" if mtdata in self.path_checker: return False, "Path already existed" #validate disk: must be one of the existing disks i = self.device_index #valid size: must not exceed memory limit curr_size = self.disk_size[i][1] if len(sizedata) != 0: try: int(sizedata) except ValueError: return False, "invalid device size" if int(curr_size) - int(sizedata) < 0: return False, "invalid device size" #if valid, update the size and return true new_size = (self.disk_size[i][0], int(curr_size)- int(sizedata)) self.disk_size[i] = new_size if mtdata == "/": self.has_slash = True self.path_checker.append(mtdata) return True, None
def _unsafe_install(self): """ Install photon system """ self._setup_install_repo() self._initialize_system() self._install_packages() self._enable_network_in_chroot() self._finalize_system() self._disable_network_in_chroot() self._cleanup_and_exit() return ActionResult(True, None)
def do_action(self): while True: self.refresh() key = self.window.getch() if key in [curses.KEY_ENTER, ord('\n')]: if self.selector_menu: # send the selected indexes result = self.items[self.position][1](self.selected_items) else: result = self.items[self.position][1](self.items[self.position][2]) if result.success: self.hide() return result if key in [ord(' ')] and self.selector_menu: if self.position in self.selected_items: self.selected_items.remove(self.position) else: self.selected_items.add(self.position) elif key in [ord('\t')] and self.can_navigate_outside: if not self.tab_enable: continue self.refresh(False) if self.save_sel: return ActionResult(False, {'diskIndex': self.position}) else: return ActionResult(False, None) elif key == curses.KEY_UP or key == curses.KEY_LEFT: if not self.tab_enable and key == curses.KEY_LEFT: if self.save_sel: return ActionResult(False, {'diskIndex': self.position, 'direction':-1}) elif self.selector_menu: result = self.items[self.position][1](self.selected_items) else: result = self.items[self.position][1](self.items[self.position][2]) return ActionResult(False, {'direction': -1}) self.navigate(-1) elif key == curses.KEY_DOWN or key == curses.KEY_RIGHT: if not self.tab_enable and key == curses.KEY_RIGHT: if self.save_sel: return ActionResult(False, {'diskIndex': self.position, 'direction':1}) else: return ActionResult(False, {'direction': 1}) self.navigate(1) elif key == curses.KEY_NPAGE: self.navigate(self.height) elif key == curses.KEY_PPAGE: self.navigate(-self.height) elif key == curses.KEY_HOME: self.navigate(-self.position)
def _unsafe_install(self): """ Install photon system """ self._format_disk() self._setup_install_repo() self._initialize_system() self._install_packages() self._enable_network_in_chroot() self._finalize_system() self._cleanup_install_repo() self._execute_modules(modules.commons.POST_INSTALL) self._post_install() self._disable_network_in_chroot() self._cleanup_and_exit() return ActionResult(True, None)
def display(self): self.initialize_devices() if 'autopartition' in self.install_config and self.install_config[ 'autopartition'] == True: return ActionResult(True, None) self.device_index = self.disk_to_index[self.install_config['disk']] self.disk_buttom_items = [] self.disk_buttom_items.append(('<Next>', self.next)) self.disk_buttom_items.append(('<Create New>', self.create_function)) self.disk_buttom_items.append(('<Delete All>', self.delete_function)) self.disk_buttom_items.append(('<Go Back>', self.go_back)) self.text_items = [] self.text_items.append(('Disk', 20)) self.text_items.append(('Size', 5)) self.text_items.append(('Type', 5)) self.text_items.append(('Mountpoint', 20)) self.table_space = 5 title = 'Current partitions:\n' self.window.addstr(0, (self.win_width - len(title)) // 2, title) info = ("Unpartitioned space: " + str(self.disk_size[self.device_index][1]) + " MB, Total size: " + str(int(self.devices[self.device_index].size) / 1048576) + " MB") self.partition_pane = PartitionPane( self.text_starty, self.maxx, self.text_width, self.text_height, self.disk_buttom_items, config=self.cp_config, text_items=self.text_items, table_space=self.table_space, info=info, size_left=str(self.disk_size[self.device_index][1])) self.window.set_action_panel(self.partition_pane) return self.window.do_action()
def do_action(self): self.show_window() action_result = self.action_panel.do_action() if action_result.success: self.hide_window() return action_result else: if (action_result.result != None and 'goBack' in action_result.result and action_result.result['goBack']): self.hide_window() self.action_panel.hide() return action_result else: #highlight the GoBack and keep going self.contentwin.addstr(self.height - 3, 5, '<Go Back>', curses.color_pair(3)) self.contentwin.refresh() while action_result.success == False: key = self.contentwin.getch() if key in [curses.KEY_ENTER, ord('\n')]: #remove highlight from Go Back self.contentwin.addstr(self.height - 3, 5, '<Go Back>') self.contentwin.refresh() self.hide_window() self.action_panel.hide() return ActionResult(False, None) elif key in [ord('\t')]: #remove highlight from Go Back self.contentwin.addstr(self.height - 3, 5, '<Go Back>') self.contentwin.refresh() # go do the action inside the panel action_result = self.action_panel.do_action() if action_result.success: self.hide_window() return action_result else: #highlight the GoBack and keep going self.contentwin.addstr(self.height - 3, 5, '<Go Back>', curses.color_pair(3)) self.contentwin.refresh()
def unsafe_install(self, params): self.prepare_files_rpms_list() if self.iso_installer: self.window.show_window() self.progress_bar.initialize(self.total_size, 'Initializing installation...') self.progress_bar.show() self.pre_initialize_filesystem() #install packages for rpm in self.rpms_tobeinstalled: # We already installed the filesystem in the preparation if rpm['package'] == 'filesystem': continue if self.iso_installer: self.progress_bar.update_message('Installing {0}...'.format( rpm['package'])) return_value = self.install_package(rpm['package']) if return_value != 0: self.exit_gracefully(None, None) #time.sleep(0.05) if self.iso_installer: self.progress_bar.increment(rpm['size'] * self.install_factor) if self.iso_installer: self.progress_bar.show_loading('Finalizing installation') #finalize system self.finalize_system() #time.sleep(5) if not self.install_config['iso_system'] and not self.local_install: # install grub process = subprocess.Popen([ self.setup_grub_command, '-w', self.photon_root, self.install_config['disk']['disk'], self.install_config['disk']['root'] ], stdout=self.output, stderr=self.output) retval = process.wait() #update root password self.update_root_password() #update hostname self.update_hostname() #update openssh config self.update_openssh_config() process = subprocess.Popen( [self.unmount_disk_command, '-w', self.photon_root], stdout=self.output, stderr=self.output) retval = process.wait() if self.iso_installer: self.progress_bar.hide() self.window.addstr( 0, 0, 'Congratulations, Photon has been installed in {0} secs.\n\nPress any key to continue to boot...' .format(self.progress_bar.time_elapsed)) self.window.content_window().getch() return ActionResult(True, None)
def unsafe_install(self, params): self.org_photon_root = self.photon_root sysroot_ostree = os.path.join(self.photon_root, "ostree") sysroot_boot = os.path.join(self.photon_root, "boot") loader0 = os.path.join(sysroot_boot, "loader.0") loader1 = os.path.join(sysroot_boot, "loader.1") boot0 = os.path.join(sysroot_ostree, "boot.0") boot1 = os.path.join(sysroot_ostree, "boot.1") boot01 = os.path.join(sysroot_ostree, "boot.0.1") boot11 = os.path.join(sysroot_ostree, "boot.1.1") self.get_ostree_repo_url() self.window.show_window() self.progress_bar.initialize("Initializing installation...") self.progress_bar.show() self.progress_bar.show_loading("Unpacking local OSTree repo") if self.default_repo: self.run("mkdir repo") self.run( "tar --warning=none -xf /mnt/cdrom/ostree-repo.tar.gz -C repo") self.local_repo_path = "/installer/repo/" self.ostree_repo_url = self.repo_config['OSTREEREPOURL'] self.ostree_ref = self.repo_config['OSTREEREFS'] self.execute_modules(modules.commons.PRE_INSTALL) disk = self.install_config['disk']['disk'] self.run("sgdisk -d 2 -n 2::+300M -n 3: -p {}".format(disk), "Updating partition table for OSTree") self.run("mkfs -t ext4 {}2".format(disk)) self.run("mkfs -t ext4 {}3".format(disk)) self.run("mount {}3 {}".format(disk, self.photon_root)) self.run("mkdir -p {} ".format(sysroot_boot)) self.run("mount {}2 {}".format(disk, sysroot_boot)) self.deploy_ostree(self.ostree_repo_url, self.ostree_ref) commit_number = self.get_commit_number(self.ostree_ref) self.do_systemd_tmpfiles_commands(commit_number) self.mount_devices_in_deployment(commit_number) deployment = os.path.join( self.photon_root, "ostree/deploy/photon/deploy/" + commit_number + ".0/") deployment_boot = os.path.join(deployment, "boot") deployment_sysroot = os.path.join(deployment, "sysroot") self.run("mv {} {}".format(loader1, loader0)) self.run("mv {} {}".format(boot1, boot0)) self.run("mv {} {}".format(boot11, boot01)) self.run("mount --bind {} {}".format(sysroot_boot, deployment_boot)) self.run("mount --bind {} {}".format(self.photon_root, deployment_sysroot)) self.run( "chroot {} bash -c \"grub2-install /dev/sda\"".format(deployment)) self.run( "chroot {} bash -c \"grub2-mkconfig -o /boot/grub2/grub.cfg\"". format(deployment)) self.run("mv {} {}".format(loader0, loader1)) self.run("mv {} {}".format(boot0, boot1)) self.run("mv {} {}".format(boot01, boot11)) self.run( "chroot {} bash -c \"ostree admin instutil set-kargs root=/dev/sda3 \"" .format(deployment)) sysroot_grub2_grub_cfg = os.path.join(self.photon_root, "boot/grub2/grub.cfg") self.run("ln -sf ../loader/grub.cfg {}".format(sysroot_grub2_grub_cfg)) self.run("mv {} {}".format(loader1, loader0)) self.run("mv {} {}".format(boot1, boot0)) self.run("mv {} {}".format(boot11, boot01)) deployment_fstab = os.path.join(deployment, "etc/fstab") self.run( "echo \"/dev/sda2 /boot ext4 defaults 1 2 \" >> {} ". format(deployment_fstab), "Adding /boot mount point in fstab") self.run("mount --bind {} {}".format(deployment, self.photon_root)) self.progress_bar.update_loading_message( "Starting post install modules") self.execute_modules(modules.commons.POST_INSTALL) self.progress_bar.update_loading_message("Unmounting disks") self.run("{} {} {}".format(self.unmount_disk_command, '-w', self.photon_root)) self.progress_bar.update_loading_message("Ready to restart") self.progress_bar.hide() self.window.addstr( 0, 0, 'Congratulations, Photon has been installed in {0} secs.\n\nPress any key to continue to boot...' .format(self.progress_bar.time_elapsed)) if self.ks_config == None: self.window.content_window().getch() return ActionResult(True, None)
def go_back(self): self.delete() self.window.hide_window() self.partition_pane.hide() return ActionResult(False, {'goBack': True})
def custom_packages(self): return ActionResult(True, {'custom': True})
def exit_function(self, selected_item_params): self.install_config['type'] = selected_item_params[0] self.install_config['packages'] = selected_item_params[1] self.install_config['additional-files'] = selected_item_params[2] return ActionResult(True, {'custom': False})
def next_function(self): return ActionResult(True, None)