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)
