def create(self): """creates the junos state machine""" ########################################################## # State Definition ########################################################## shell = State('shell', patterns.shell_prompt) enable = State('enable', patterns.enable_prompt) config = State('config', patterns.config_prompt) ########################################################## # Path Definition ########################################################## config_dialog = Dialog([ [ patterns.commit_changes_prompt, 'sendline(yes)', None, True, False ], ]) enable_to_shell = Path(enable, shell, 'exit', None) shell_to_enable = Path(shell, enable, 'cli', None) enable_to_config = Path(enable, config, 'configure', None) config_to_enable = Path(config, enable, 'exit', config_dialog) # Add State and Path to State Machine self.add_state(shell) self.add_state(enable) self.add_state(config) self.add_path(enable_to_shell) self.add_path(shell_to_enable) self.add_path(enable_to_config) self.add_path(config_to_enable)
def create(self): shell = State('shell', patterns.shell_prompt) enable = State('enable', patterns.enable_prompt) config = State('config', patterns.config_prompt) self.add_state(shell) self.add_state(enable) self.add_state(config) shell_dialog = Dialog( [[patterns.shell_prompt, 'sendline(exec)', None, True, False]]) config_dialog = Dialog([[ patterns.commit_changes_prompt, 'sendline(yes)', None, True, False ], [ patterns.commit_replace_prompt, 'sendline(yes)', None, True, False ], [ patterns.configuration_failed_message, self.handle_failed_config, None, True, False ]]) shell_to_enable = Path(shell, enable, 'exec', None) enable_to_config = Path(enable, config, 'configure terminal', None) config_to_enable = Path(config, enable, 'end', config_dialog) self.add_path(shell_to_enable) self.add_path(enable_to_config) self.add_path(config_to_enable) self.add_default_statements(self.default_commands)
def create(self): # Create States and their state patterns prelogin_state = State('prelogin_state', self.patterns.prompt.prelogin_prompt) admin_state = State('admin_state', self.patterns.prompt.admin_prompt) sudo_state = State('sudo_state', self.patterns.prompt.sudo_prompt) # Add our states to the state machine self.add_state(admin_state) self.add_state(sudo_state) self.add_state(prelogin_state) # Create paths for switching between states admin_to_sudo = Path(admin_state, sudo_state, 'sudo su -', self.dialogs.d_admin_to_sudo) sudo_to_admin = Path(sudo_state, admin_state, "exit", None) prelogin_to_admin = Path( prelogin_state, admin_state, 'admin', Dialog([self.statements.login_password_statement])) admin_to_prelogin = Path(admin_state, prelogin_state, 'exit', None) # Add paths to the State Machine self.add_path(admin_to_sudo) self.add_path(sudo_to_admin) self.add_path(prelogin_to_admin) self.add_path(admin_to_prelogin) # after inactivity timer, it will go back to prelogin: self.add_default_statements(self.statements.login_password)
def define_asa_level_paths(self): fpr_module_states = [key for key in self.states_dict if key.endswith('fpr_module_state')] asa_states = [key for key in self.states_dict if key.endswith('asa_state')] for fpr_module_state in fpr_module_states: for asa_state in asa_states: if asa_state.startswith( fpr_module_state.replace('fpr_module_state', '')): fpr_module_to_asa = Path( self.states_dict[fpr_module_state], self.states_dict[asa_state], "connect asa", None) asa_to_fpr_module = Path( self.states_dict[asa_state], self.states_dict[fpr_module_state], '\001d', None) self.paths_dict.update({ fpr_module_state + '_to_' + asa_state: fpr_module_to_asa }) self.paths_dict.update({ asa_state + '_to_' + fpr_module_state: asa_to_fpr_module })
def create(self): # Create States disable_state = State(AsaSmStates.DISABLE_STATE.value, self.patterns.prompt.disable_prompt) enable_state = State(AsaSmStates.ENABLE_STATE.value, self.patterns.prompt.enable_prompt) config_state = State(AsaSmStates.CONFIG_STATE.value, self.patterns.prompt.config_prompt) # Add states self.add_state(disable_state) self.add_state(enable_state) self.add_state(config_state) # Create paths enable_dialog = Dialog( [self.statements.disable_to_enable_statement, self.statements.set_enable_pwd_statement, self.statements.repeat_enable_pwd_statement, ] ) disable_to_enable_path = Path(disable_state, enable_state, 'enable', enable_dialog) enable_to_disable_path = Path(enable_state, disable_state, 'disable', None) enable_to_config_path = Path(enable_state, config_state, 'config t', None) config_to_enable_path = Path(config_state, enable_state, 'end', None) # Add paths self.add_path(disable_to_enable_path) self.add_path(enable_to_disable_path) self.add_path(enable_to_config_path) self.add_path(config_to_enable_path)
def create(self): cisco_exec = State('cisco_exec', patterns.cisco_prompt) cisco_config = State('cisco_config', patterns.cisco_config_prompt) vshell = State('cisco_vshell', patterns.shell_prompt) self.add_state(cisco_exec) self.add_state(cisco_config) self.add_state(vshell) cisco_exec_to_config = Path(cisco_exec, cisco_config, 'config term', None) # Ignore config changes on state change # config commits are done as part of the configure method cisco_config_dialog = Dialog([ # Uncommitted changes found, commit them? [yes/no/CANCEL] no [ patterns.cisco_commit_changes_prompt, 'sendline(no)', None, True, False ], ]) cisco_config_to_exec = Path(cisco_config, cisco_exec, 'end', cisco_config_dialog) cisco_exec_to_vshell = Path(cisco_exec, vshell, 'vshell', None) vshell_to_cisco_exec = Path(vshell, cisco_exec, 'exit', None) self.add_path(cisco_exec_to_config) self.add_path(cisco_config_to_exec) self.add_path(cisco_exec_to_vshell) self.add_path(vshell_to_cisco_exec) self.add_default_statements(default_statement_list)
def create(self): super().create() self.remove_path('enable', 'rommon') self.remove_path('rommon', 'disable') self.remove_state('rommon') # incase there is no previous shell state regiestered try: self.remove_path('shell', 'enable') self.remove_path('enable', 'shell') self.remove_state('shell') except Exception: pass rommon = State('rommon', patterns.rommon_prompt) enable_to_rommon = Path(self.get_state('enable'), rommon, 'reload', Dialog(reload_statement_list)) rommon_to_disable = Path(rommon, self.get_state('disable'), boot_from_rommon, Dialog(connection_statement_list)) self.add_state(rommon) self.add_path(enable_to_rommon) self.add_path(rommon_to_disable) shell = State('shell', patterns.shell_prompt) enable_to_shell = Path(self.get_state('enable'), shell, 'request platform software system shell') shell_to_enable = Path(shell, self.get_state('enable'), 'exit', None) self.add_state(shell) self.add_path(enable_to_shell) self.add_path(shell_to_enable)
def create(self): p = patterns.ASAPatterns() enable = State('enable', p.enable_prompt) disable = State('disable', p.disable_prompt) config = State('config', p.config_prompt) enable_to_disable = Path(enable, disable, 'disable', None) enable_to_config = Path(enable, config, 'config term', None) disable_to_enable = Path(disable, enable, 'enable', Dialog([statements.enable_password])) config_to_enable = Path(config, enable, 'end', None) self.add_state(enable) self.add_state(disable) self.add_state(config) self.add_path(enable_to_disable) self.add_path(enable_to_config) self.add_path(config_to_enable) self.add_path(disable_to_enable) self.add_default_statements(default_statement_list)
def create(self): super().create() container_shell = State('container_shell', patterns.container_shell_prompt) rommon = self.get_state('rommon') disable = self.get_state('disable') enable = self.get_state('enable') self.add_state(container_shell) rommon.pattern = patterns.rommon_prompt self.remove_path('rommon', 'disable') self.remove_path('enable', 'rommon') rommon_to_disable = Path( rommon, disable, boot_from_rommon, Dialog(rommon_boot_statement_list + [boot_timeout_stmt])) enable_to_rommon = Path(enable, rommon, 'reload', Dialog(reload_to_rommon_statement_list)) container_shell_to_enable = Path(container_shell, enable, 'exit', None) self.add_path(rommon_to_disable) self.add_path(enable_to_rommon) self.add_path(container_shell_to_enable)
def create(self): super().create() self.remove_path('disable', 'enable') self.remove_path('rommon', 'disable') self.remove_path('enable', 'disable') self.remove_state('disable') # Adding SHELL state to NXOS platform. shell = State('shell', patterns.shell_prompt) enable = self.get_state('enable') # Loader state loader = State('loader', patterns.loader_prompt) # Guestshell state guestshell = State('guestshell', patterns.guestshell_prompt) enable_to_shell = Path(enable, shell, 'run bash', None) shell_to_enable = Path(shell, enable, 'exit', None) enable_to_guestshell = Path(enable, guestshell, 'guestshell', None) guestshell_to_enable = Path(guestshell, enable, 'exit', None) # Add State and Path to State Machine self.add_state(shell) self.add_state(loader) self.add_state(guestshell) self.add_path(enable_to_shell) self.add_path(shell_to_enable) self.add_path(enable_to_guestshell) self.add_path(guestshell_to_enable)
def create(self): shell = State('shell', p.prompt) config = State('config', p.config_prompt) shell_to_config = Path(shell, config, 'config term', None) config_to_shell = Path(config, shell, 'end', None) self.add_state(shell) self.add_state(config) self.add_path(shell_to_config) self.add_path(config_to_shell)
def _define_chassis_login_paths(self): self.paths_dict.update({ 'prelogin_to_mio': Path(self.states_dict['prelogin_state'], self.states_dict['mio_state'], 'admin', self.dialogs.d_prelogin_to_mio) }) self.paths_dict.update({ 'mio_to_prelogin': Path(self.states_dict['mio_state'], self.states_dict['prelogin_state'], 'top; exit', None) })
def create(self): exec_mode = State('enable', patterns.exec_prompt) config_mode = State('config', patterns.config_prompt) exec_to_config = Path(exec_mode, config_mode, 'conf', None) config_to_exec = Path(config_mode, exec_mode, 'end', None) self.add_state(exec_mode) self.add_state(config_mode) self.add_path(exec_to_config) self.add_path(config_to_exec)
def create(self): mdcli = State('mdcli', patterns.mdcli_prompt) classiccli = State('classiccli', patterns.classiccli_prompt) mdcli_to_classiccli = Path(mdcli, classiccli, '//') classiccli_to_mdcli = Path(classiccli, mdcli, '//') self.add_state(mdcli) self.add_state(classiccli) self.add_path(mdcli_to_classiccli) self.add_path(classiccli_to_mdcli)
def create(self): enable = State('enable', patterns.enable_prompt) config = State('config', patterns.config_prompt) run = State('run', patterns.run_prompt) admin = State('admin', patterns.admin_prompt) admin_conf = State('admin_conf', patterns.admin_conf_prompt) admin_run = State('admin_run', patterns.admin_run_prompt) self.add_state(enable) self.add_state(config) self.add_state(run) self.add_state(admin) self.add_state(admin_conf) self.add_state(admin_run) config_dialog = Dialog([[ patterns.commit_changes_prompt, 'sendline(yes)', None, True, False ], [ patterns.commit_replace_prompt, 'sendline(yes)', None, True, False ], [ patterns.configuration_failed_message, self.handle_failed_config, None, True, False ]]) enable_to_config = Path(enable, config, 'configure terminal', None) enable_to_run = Path(enable, run, 'run', None) enable_to_admin = Path(enable, admin, 'admin', None) admin_to_admin_conf = Path(admin, admin_conf, 'config', None) admin_to_admin_run = Path(admin, admin_run, 'run', None) admin_conf_to_admin = Path(admin_conf, admin, 'exit', config_dialog) admin_run_to_admin = Path(admin_run, admin, 'exit', None) admin_to_enable = Path(admin, enable, 'exit', None) run_to_enable = Path(run, enable, 'exit', None) config_to_enable = Path(config, enable, 'end', config_dialog) self.add_path(config_to_enable) self.add_path(enable_to_config) self.add_path(enable_to_admin) self.add_path(enable_to_run) self.add_path(admin_to_enable) self.add_path(run_to_enable) self.add_path(admin_to_admin_conf) self.add_path(admin_to_admin_run) self.add_path(admin_conf_to_admin) self.add_path(admin_run_to_admin) self.add_default_statements(default_commands)
def create(self): enable = State('enable', patterns.enable_prompt) config = State('config', patterns.config_prompt) shell = State('shell', patterns.shell_prompt) loader = State('loader', patterns.loader_prompt) guestshell = State('guestshell', patterns.guestshell_prompt) module = State('module', patterns.module_prompt) module_elam = State('module_elam', patterns.module_elam_prompt) module_elam_insel = State('module_elam_insel', patterns.module_elam_insel_prompt) enable_to_config = Path(enable, config, send_config_cmd, None) config_to_enable = Path(config, enable, 'end', Dialog([ Statement(pattern=patterns.commit_changes_prompt, action='sendline(no)', loop_continue=True) ])) enable_to_shell = Path(enable, shell, 'run bash', None) shell_to_enable = Path(shell, enable, 'exit', None) enable_to_guestshell = Path(enable, guestshell, 'guestshell', None) guestshell_to_enable = Path(guestshell, enable, 'exit', None) enable_to_module = Path(enable, module, attach_module, None) module_to_enable = Path(module, enable, 'exit', None) module_elam_to_module = Path(module_elam, module, 'exit', None) module_elam_insel_to_module = Path(module_elam_insel, module_elam, 'exit', None) # Add State and Path to State Machine self.add_state(enable) self.add_state(config) self.add_state(shell) self.add_state(loader) self.add_state(guestshell) self.add_state(module) self.add_state(module_elam) self.add_state(module_elam_insel) self.add_path(enable_to_config) self.add_path(config_to_enable) self.add_path(enable_to_shell) self.add_path(shell_to_enable) self.add_path(enable_to_guestshell) self.add_path(guestshell_to_enable) self.add_path(enable_to_module) self.add_path(module_to_enable) self.add_path(module_elam_to_module) self.add_path(module_elam_insel_to_module) self.add_default_statements(default_statement_list)
def create(self): # Create States and their state patterns prelogin_state = State('prelogin_state', self.patterns.prompt.prelogin_prompt) mio_state = State('mio_state', self.patterns.prompt.mio_prompt) admin_state = State('admin_state', self.patterns.prompt.admin_prompt) sudo_state = State('sudo_state', self.patterns.prompt.sudo_prompt) fireos_state = State('fireos_state', self.patterns.prompt.fireos_prompt) liloboot_state = State('liloboot_state', self.patterns.prompt.lilo_boot_prompt) liloos_state = State('lilos_state', self.patterns.prompt.lilo_os_prompt) lilo_boot_menu_state = State('lilobootmenu_state', self.patterns.prompt.lilo_boot_menu_prompt) # Add our states to the state machine self.add_state(prelogin_state) self.add_state(mio_state) self.add_state(admin_state) self.add_state(sudo_state) self.add_state(fireos_state) self.add_state(liloboot_state) self.add_state(liloos_state) self.add_state(lilo_boot_menu_state) # Create paths for switching between states mio_to_admin = Path(mio_state, admin_state, "connect host", self.dialogs.d_mio_to_admin) admin_to_sudo = Path(admin_state, sudo_state, "sudo su -", self.dialogs.d_admin_to_sudo) sudo_to_admin = Path(sudo_state, admin_state, "exit", None) admin_to_mio = Path(admin_state, mio_state, "\030", None) prelogin_to_admin = Path(prelogin_state, admin_state, 'admin', Dialog([self.statements.login_password_statement])) admin_to_prelogin = Path(admin_state, prelogin_state, 'exit', None) # transitions from and to 'fireos_state' state fireos_to_admin_path = Path(fireos_state, admin_state, 'expert', None) admin_to_fireos_path = Path(admin_state, fireos_state, 'exit', None) fireos_to_prelogin = Path(fireos_state, prelogin_state, 'exit', None) # Add paths to the State Machine self.add_path(mio_to_admin) self.add_path(admin_to_sudo) self.add_path(sudo_to_admin) self.add_path(admin_to_mio) self.add_path(prelogin_to_admin) self.add_path(admin_to_prelogin) self.add_path(fireos_to_admin_path) self.add_path(admin_to_fireos_path) self.add_path(fireos_to_prelogin) # after inactivity timer, it will go back to prelogin: self.add_default_statements([self.statements.login_password, self.statements.login_incorrect])
def create(self): # States disable = State('disable', patterns.disable_prompt) enable = State('enable', patterns.enable_prompt) config = State('config', patterns.config_prompt) standby_locked = State('standby_locked', patterns.standby_locked) rommon = State('rommon', patterns.rommon_prompt) shell = State('shell', patterns.shell_prompt) # Paths disable_to_enable = Path( disable, enable, 'enable', Dialog([ statements.enable_password_stmt, statements.bad_password_stmt ])) enable_to_disable = Path(enable, disable, 'disable', None) enable_to_config = Path(enable, config, 'config term', None) config_to_enable = Path(config, enable, 'end', None) enable_to_rommon = Path(enable, rommon, 'reload', Dialog(reload_statement_list)) rommon_to_disable = \ Path(rommon, disable, '\r', Dialog( connection_statement_list + boot_from_rommon_statement_list)) self.add_state(disable) self.add_state(enable) self.add_state(config) self.add_state(rommon) # Ensure that a locked standby is properly detected. # This is done by ensuring this is the last state added # so its state pattern is considered first. self.add_state(standby_locked) self.add_path(disable_to_enable) self.add_path(enable_to_disable) self.add_path(enable_to_config) self.add_path(config_to_enable) self.add_path(enable_to_rommon) self.add_path(rommon_to_disable) # Adding SHELL state to IOSXE platform. shell_dialog = Dialog( [[patterns.access_shell, 'sendline(y)', None, True, False]]) enable_to_shell = Path(enable, shell, 'request platform software system shell', shell_dialog) shell_to_enable = Path(shell, enable, 'exit', None) # Add State and Path to State Machine self.add_state(shell) self.add_path(enable_to_shell) self.add_path(shell_to_enable) self.add_default_statements(default_statement_list)
def create(self): super().create() self.remove_path('enable', 'rommon') self.remove_path('rommon', 'disable') self.remove_state('rommon') rommon = State('rommon', patterns.rommon_prompt) enable_to_rommon = Path(self.get_state('enable'), rommon, 'reload', Dialog(reload_statement_list)) rommon_to_disable = Path(rommon, self.get_state('disable'), boot_from_rommon, Dialog(connection_statement_list)) self.add_state(rommon) self.add_path(enable_to_rommon) self.add_path(rommon_to_disable)
def create(self): super().create() self.remove_path('enable', 'shell') self.remove_path('shell', 'enable') self.remove_state('shell') shell = State('shell', patterns.shell_prompt) enable = self.get_state('enable') enable_to_shell = Path(enable, shell, 'bash', None) shell_to_enable = Path(shell, enable, 'exit', None) # Add State and Path to State Machine self.add_state(shell) self.add_path(enable_to_shell) self.add_path(shell_to_enable)
def create(self): cisco_exec = State('cisco_exec', patterns.cisco_prompt) juniper_exec = State('juniper_exec', patterns.juniper_prompt) cisco_config = State('cisco_config', patterns.cisco_config_prompt) juniper_config = State('juniper_config', patterns.juniper_config_prompt) self.add_state(cisco_exec) self.add_state(juniper_exec) self.add_state(cisco_config) self.add_state(juniper_config) cisco_to_juniper_exec = Path(cisco_exec, juniper_exec, 'switch cli', None) juniper_to_cisco_exec = Path(juniper_exec, cisco_exec, 'switch cli', None) cisco_exec_to_juniper_config = Path(cisco_config, juniper_config, 'switch cli', None) juniper_exec_to_cisco_config = Path(juniper_config, cisco_config, 'switch cli', None) cisco_exec_to_config = Path(cisco_exec, cisco_config, 'config', None) juniper_exec_to_config = Path(juniper_exec, juniper_config, 'configure', None) # Ignore config changes on state change # config commits are done as part of the configure method cisco_config_dialog = Dialog([ # Uncommitted changes found, commit them? [yes/no/CANCEL] no [ patterns.cisco_commit_changes_prompt, 'sendline(no)', None, True, False ], ]) juniper_config_dialog = Dialog([ # Discard changes and continue? [yes,no] yes [ patterns.juniper_commit_changes_prompt, 'sendline(yes)', None, True, False ], ]) cisco_config_to_exec = Path(cisco_config, cisco_exec, 'end', cisco_config_dialog) juniper_config_to_exec = Path(juniper_config, juniper_exec, 'exit', juniper_config_dialog) self.add_path(cisco_to_juniper_exec) self.add_path(juniper_to_cisco_exec) self.add_path(cisco_exec_to_juniper_config) self.add_path(juniper_exec_to_cisco_config) self.add_path(cisco_exec_to_config) self.add_path(juniper_exec_to_config) self.add_path(cisco_config_to_exec) self.add_path(juniper_config_to_exec) self.add_default_statements(default_statement_list)
def define_contexts(self, contexts=None): """ Add the new states machine for contexts. Append the prompts, states and paths for the contexts :param contexts: a list with contexts name diffrent than ['system', 'admin'] eq. ['ctx1','ctx2'] if not given, defaulted to ['system', 'admin'] :return: None """ # add system_state if 'system_state' not in [s.name for s in self.sm.states]: system_ctx_prompt = 'system_prompt' ctx_prompt_value = '[\r\n][\x07]?system>' self.sm.patterns.prompt.update( {system_ctx_prompt: ctx_prompt_value}) system_ctx_state = State('system_state', ctx_prompt_value) self.sm.add_state(system_ctx_state) else: system_ctx_state = \ [s for s in self.sm.states if s.name == 'system_state'][0] if not contexts: contexts = ['admin'] else: contexts.append('admin') for ctx in contexts: context_prompt = '{}_ctx_prompt'.format(ctx) ctx_prompt_value = '[\r\n][\x07]?{}>'.format(ctx) self.sm.patterns.prompt.update({context_prompt: ctx_prompt_value}) ctx_state = '{}_ctx_state'.format(ctx) context_ctx_state = State(ctx_state, ctx_prompt_value) self.sm.add_state(context_ctx_state) # Create paths system_to_ctx = Path(system_ctx_state, context_ctx_state, 'changeto context {}'.format(ctx), None) ctx_to_system = Path(context_ctx_state, system_ctx_state, 'exit', None) # Add paths self.sm.add_path(system_to_ctx) self.sm.add_path(ctx_to_system)
def create(self): super().create() disable_to_enable_state = Path(self.get_state('disable_state'), self.get_state('enable_state'), 'en', self.dialogs.ftd_dialogs.disable_to_enable) fireos_to_disable_state = Path(self.get_state('fireos_state'), self.get_state('disable_state'), 'system support diagnostic-cli', None) disable_to_fireos_path = Path(self.get_state('disable_state'), self.get_state('fireos_state'), '\001'+'d'+'exit', None) self.add_path(fireos_to_disable_state) self.add_path(disable_to_fireos_path) self.add_path(disable_to_enable_state)
def create(self): enable = State('enable', patterns.enable_prompt) config = State('config', patterns.config_prompt) shell = State('shell', patterns.shell_prompt) setup = State('setup', list(setup_patterns.__dict__.values())) self.add_state(enable) self.add_state(config) self.add_state(setup) self.add_state(shell) enable_to_config = Path(enable, config, 'configure', None) config_to_enable = Path(config, enable, 'end', None) self.add_path(enable_to_config) self.add_path(config_to_enable) self.add_default_statements(default_statement_list)
def create(self): super().create() disable_to_enable_state = Path(self.get_state('disable_state'), self.get_state('enable_state'), 'en', self.dialogs.disable_to_enable) enable_to_fxos_path = Path(self.get_state('enable_state'), self.get_state('fxos_state'), 'connect fxos admin', None) fxos_to_enable_path = Path(self.get_state('fxos_state'), self.get_state('enable_state'), 'exit', None) self.add_path(enable_to_fxos_path) self.add_path(fxos_to_enable_path) self.add_path(disable_to_enable_state)
def create(self): # Create States csp_enable_state = State(CspSmStates.CSP_ENABLE_STATE.value, self.patterns.prompt.enable_prompt) csp_config_state = State(CspSmStates.CSP_CONFIG_STATE.value, self.patterns.prompt.config_prompt) # Add states self.add_state(csp_enable_state) self.add_state(csp_config_state) enable_to_config_path = Path(csp_enable_state, csp_config_state, 'config t', None) config_to_enable_path = Path(csp_config_state, csp_enable_state, 'end', None) # Add paths self.add_path(enable_to_config_path) self.add_path(config_to_enable_path)
def create(self): disable = State('disable', patterns.disable_prompt) enable = State('enable', patterns.enable_prompt) self.add_state(enable) self.add_state(disable) enable_to_disable = Path(enable, disable, 'disable', None) disable_to_enable = Path( disable, enable, 'enable', Dialog([ statements.enable_password_stmt, statements.bad_password_stmt ])) self.add_path(disable_to_enable) self.add_path(enable_to_disable) self.add_default_statements(default_statement_list)
def create(self): super().create() # fireos to fxos transition has changed on child Wm class new_path_ftd_to_fxos = Path(self.states[2], self.states[1], "exit") # Add path to the State Machine self.remove_path(self.states[2], self.states[1]) self.add_path(new_path_ftd_to_fxos)
def create(self): # Create States prelogin_state = State('prelogin_state', self.patterns.prompt.prelogin_prompt) pkglogin_state = State('pkglogin_state', self.patterns.prompt.pkglogin_prompt) fireos_state = State('fireos_state', self.patterns.prompt.fireos_prompt) expert_state = State('expert_state', self.patterns.prompt.expert_prompt) sudo_state = State('sudo_state', self.patterns.prompt.sudo_prompt) rommon_state = State('rommon_state', self.patterns.prompt.rommon_prompt) boot_state = State('boot_state', self.patterns.prompt.firepower_boot) config_state = State('config_state', self.patterns.prompt.config_prompt) system_state = State('system_state', self.patterns.prompt.system_prompt) # Add states self.add_state(prelogin_state) self.add_state(pkglogin_state) self.add_state(fireos_state) self.add_state(expert_state) self.add_state(sudo_state) self.add_state(rommon_state) self.add_state(boot_state) self.add_state(config_state) self.add_state(system_state) # Create paths prelogin_to_fireos_path = Path(prelogin_state, fireos_state, 'admin', Dialog([self.statements.login_password_statement])) pkglogin_to_boot_path = Path(pkglogin_state, boot_state, 'admin', Dialog([self.statements.pkg_password_statement])) fireos_to_prelogin_path = Path(fireos_state, prelogin_state, 'exit', None) fireos_to_expert_path = Path(fireos_state, expert_state, 'expert', None) expert_to_fireos_path = Path(expert_state, fireos_state, 'exit', None) expert_to_sudo_path = Path(expert_state, sudo_state, 'sudo su -', Dialog([self.statements.sudo_password_statement])) sudo_to_expert_path = Path(sudo_state, expert_state, 'exit', None) system_to_expert_path = Path(system_state, expert_state, 'expert', None) expert_to_system_path = Path(expert_state, system_state, 'exit', None) # Add paths self.add_path(prelogin_to_fireos_path) self.add_path(pkglogin_to_boot_path) self.add_path(fireos_to_prelogin_path) self.add_path(fireos_to_expert_path) self.add_path(expert_to_fireos_path) self.add_path(expert_to_sudo_path) self.add_path(sudo_to_expert_path) self.add_path(system_to_expert_path) self.add_path(expert_to_system_path)
def create(self): """creates the junos state machine""" JunosSingleRpStateMachine.create(self) ########################################################## # Get parent State ########################################################## shell = self.get_state('shell') enable = self.get_state('enable') ########################################################## # Overwrite parent Path ########################################################## self.remove_path(shell, enable) self.remove_path(enable, shell) enable_to_shell = Path(enable, shell, 'start shell', None) shell_to_enable = Path(shell, enable, 'exit', None) self.add_path(enable_to_shell) self.add_path(shell_to_enable)