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):
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()
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 crash_restart(self):
'''Send configuration to shut
Args:
uut (`obj`): Device object.
abstract (`obj`): Abstract object.
steps (`step obj`): aetest step object
Returns:
None
Raises:
pyATS Results
'''
if not hasattr(self.device, 'debug_plugin'):
raise Exception('No debug plugin has been loaded on the device.')
ha = self.abstract.sdk.libs.abstracted_libs.ha.HA(
device=self.device, tftp=self.device.tftp)
# https://devxsupport.cisco.com/scp/tickets.php?id=39483
State('config', r'Linux')
State('exec', r'Linux')
ha.load_debug_plugin(self.device.debug_plugin)
# Set pattern
self.device.execute('kill -{cm} {p}\n'.\
format(p=self.previous_pid,
cm=self.obj.crash_method),
timeout=10)
self.device.execute('exit', timeout=10)
restore_state = State(name='config', pattern=r'^.(%N\(config\))#\s?')
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):
# 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):
enable = State('enable', patterns.enable_prompt)
boot = State('boot', patterns.loader_prompt)
self.add_state(enable)
self.add_state(boot)
self.add_default_statements(default_statement_list)
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)
enable_to_config = Path(enable, config, 'config term', None)
config_to_enable = Path(config, enable, 'end', None)
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(enable)
self.add_state(config)
self.add_state(shell)
self.add_state(loader)
self.add_state(guestshell)
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_default_statements(default_statement_list)
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):
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):
# 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 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)
debug = State('debug', patterns.debug_prompt)
sqlite = State('sqlite', patterns.sqlite_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)
debug_to_enable = Path(debug, enable, 'exit', None)
sqlite_to_debug = Path(sqlite, debug, '.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_state(debug)
self.add_state(sqlite)
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_path(debug_to_enable)
self.add_path(sqlite_to_debug)
self.add_default_statements(default_statement_list)
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 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 create(self):
# Create States and their state patterns
fxos_state = State('fxos_state', self.patterns.prompt.fxos_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)
local_mgmt_state = State('local_mgmt_state', self.patterns.prompt.local_mgmt_prompt)
# lina cli states
enable_state = State('enable_state', self.patterns.prompt.enable_prompt)
disable_state = State('disable_state', self.patterns.prompt.disable_prompt)
config_state = State('config_state', self.patterns.prompt.config_prompt)
# Add our states to the state machine
self.add_state(fxos_state)
self.add_state(fireos_state)
self.add_state(expert_state)
self.add_state(sudo_state)
self.add_state(rommon_state)
self.add_state(local_mgmt_state)
self.add_state(enable_state)
self.add_state(disable_state)
self.add_state(config_state)
# Create paths for switching between states
fxos_to_ftd = Path(fxos_state, fireos_state, "connect ftd", None)
fxos_to_local_mgmt = Path(fxos_state, local_mgmt_state, "connect local-mgmt", None)
ftd_to_expert = Path(fireos_state, expert_state, "expert", None)
ftd_expert_to_sudo = Path(expert_state, sudo_state, "sudo su -", self.dialogs.d_expert_to_sudo)
ftd_sudo_to_expert = Path(sudo_state, expert_state, "exit", None)
expert_to_ftd = Path(expert_state, fireos_state, "exit", None)
local_mgmt_to_fxos = Path(local_mgmt_state, fxos_state, "exit", None)
# there are two paths from fireos_state to fxos_state.
# 1. if on console, type "exit". if you type "connect fxos" you will be prompted to use "exit".
# 2. if on mgmt vty, type "connect fxos". if you type "exit", you will lose the vty.
# the following dialog tries "connect fxos" first, if prompted, uses "exit". it should work on both.
ftd_to_fxos = Path(fireos_state, fxos_state, "connect fxos", self.dialogs.d_ftd_to_fxos)
# Create lina cli paths
enable_to_disable_state = Path(enable_state, disable_state, "disable", None)
enable_to_config_path = Path(enable_state, config_state, 'conf t', None)
config_to_enable_path = Path(config_state, enable_state, 'end', None)
# Add paths to the State Machine
self.add_path(fxos_to_ftd)
self.add_path(ftd_to_fxos)
self.add_path(fxos_to_local_mgmt)
self.add_path(local_mgmt_to_fxos)
self.add_path(ftd_to_expert)
self.add_path(expert_to_ftd)
self.add_path(ftd_expert_to_sudo)
self.add_path(ftd_sudo_to_expert)
self.add_path(enable_to_disable_state)
self.add_path(enable_to_config_path)
self.add_path(config_to_enable_path)
# after inactivity timer, it will go back to prelogin:
self.add_default_statements([self.statements.login_incorrect, self.statements.login_password])
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 crash_restart(self):
'''Send configuration to shut
Args:
uut (`obj`): Device object.
abstract (`obj`): Abstract object.
steps (`step obj`): aetest step object
Returns:
None
Raises:
pyATS Results
'''
if not hasattr(self.device.custom, 'debug_plugin'):
raise Exception('No debug plugin has been loaded on the device.')
ha = self.abstract.sdk.libs.abstracted_libs.ha.HA(
device=self.device, filetransfer=self.device.filetransfer)
# https://devxsupport.cisco.com/scp/tickets.php?id=39483
State('config', r'Linux')
State('exec', r'Linux')
output = ha.load_debug_plugin(self.device.custom.debug_plugin)
if 'Incompatible' in output:
raise Exception("Incompatible debug plugin image\n")
try:
self.device.execute('kill -{cm} {p}\n'.\
format(p=self.previous_pid,
cm=self.obj.crash_method),
timeout=10)
except Exception as e:
log.info('Exception raised is expected when running trigger '\
'through management connection. Exception: {e}'.format(e=e))
# Set pattern
restore_state = State(name='config',
pattern=r'^.(%N\(config\))#\s?')
return
self.device.instantiate()
if 'vty' == self.device.connectionmgr.connections.cli.via:
time.sleep(60)
self.device.destroy()
self.device.connect(via='vty')
else:
self.device.execute('exit', timeout=10)
# Set pattern
restore_state = State(name='config', pattern=r'^.(%N\(config\))#\s?')
def define_asa_level_states(self):
available_slots = self.get_available_slots()
for slot in available_slots:
state_name = 'slot_' + slot + '_asa_state'
self.states_dict.update({
state_name: State(state_name, self.patterns.prompt.asa_prompt)
})
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):
"""creates the state machine"""
##########################################################
# State Definition
##########################################################
enable = State('enable', patterns.enable_prompt)
disable = State('disable', patterns.disable_prompt)
config = State('config', patterns.config_prompt)
rommon = State('rommon', patterns.rommon_prompt)
# standby_enable = State('standby_enable', patterns.standby_enable_prompt)
# standby_disable = State('standby_disable', patterns.standby_disable_prompt)
standby_locked = State('standby_locked', patterns.standby_locked)
##########################################################
# Path Definition
##########################################################
enable_to_disable = Path(enable, disable, 'disable', None)
enable_to_config = Path(enable, config, 'config term', None)
enable_to_rommon = Path(enable, rommon, 'reload', None)
disable_to_enable = Path(
disable, enable, 'enable',
Dialog([
statements.enable_password_stmt, statements.bad_password_stmt
]))
config_to_enable = Path(config, enable, 'end', None)
rommon_to_disable = Path(rommon, disable, 'boot',
Dialog(authentication_statement_list))
self.add_state(enable)
self.add_state(config)
self.add_state(disable)
self.add_state(rommon)
# self.add_state(standby_enable)
# self.add_state(standby_disable)
self.add_state(standby_locked)
self.add_path(rommon_to_disable)
self.add_path(disable_to_enable)
self.add_path(enable_to_config)
self.add_path(enable_to_rommon)
self.add_path(config_to_enable)
self.add_path(enable_to_disable)
self.add_default_statements(default_statement_list)
def create(self):
self.prompt = self.prompt if hasattr(self, 'prompt') else None
self.shell_prompt = self.shell_prompt if hasattr(
self, 'shell_prompt') else None
shell = State('shell', self.prompt or p.prompt)
learn_hostname = State('learn_hostname', p.learn_hostname)
learn_hostname_to_shell = Path(
learn_hostname, shell,
set_update_shell_prompt_pattern(self.shell_prompt), None)
self.add_state(shell)
# the learn_hostname state must be added as the last state entry, this will make it first
# in the pattern list when using learn_hostname = True.
self.add_state(learn_hostname)
self.add_path(learn_hostname_to_shell)
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 define_security_module_level_states(self):
available_slots = self.get_available_slots()
for slot in available_slots:
state_name = 'slot_' + slot + '_fpr_module_state'
self.states_dict.update({
state_name: State(state_name,
self.patterns.prompt.fpr_module_prompt)
})
def create(self):
# Create States and their state patterns
prelogin_state = State('prelogin_state',
self.patterns.prompt.prelogin_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)
eula_state = State('eula_state', self.patterns.prompt.eula_prompt)
firstboot_state = State('firstboot_state',
self.patterns.prompt.firstboot_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 states
self.add_state(prelogin_state)
self.add_state(fireos_state)
self.add_state(expert_state)
self.add_state(sudo_state)
self.add_state(eula_state)
self.add_state(firstboot_state)
self.add_state(liloboot_state)
self.add_state(liloos_state)
self.add_state(lilo_boot_menu_state)
# Create paths
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)
prelogin_to_fireos = Path(
prelogin_state, fireos_state, 'admin',
Dialog([self.statements.login_password_statement]))
fireos_to_prelogin = Path(fireos_state, prelogin_state, 'exit', None)
# Add paths
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(prelogin_to_fireos)
self.add_path(fireos_to_prelogin)
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):
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()
# Remove standby_locked state
self.remove_state('standby_locked')
# Add RPR state
rpr = State('rpr', patterns.rpr_state)
self.add_state(rpr)
def create(self):
"""creates the generic state machine"""
##########################################################
# State Definition
##########################################################
enable = State('enable', patterns.enable_prompt)
disable = State('disable', patterns.disable_prompt)
config = State('config', patterns.config_prompt)
rommon = State('rommon', patterns.rommon_prompt)
##########################################################
# Path Definition
##########################################################
enable_to_disable = Path(enable, disable, 'disable',
Dialog([statements.syslog_msg_stmt]))
enable_to_rommon = Path(enable, rommon, 'reload', None)
enable_to_config = Path(enable, config, config_transition,
Dialog([statements.syslog_msg_stmt]))
disable_to_enable = Path(
disable, enable, 'enable',
Dialog([
statements.enable_password_stmt, statements.bad_password_stmt,
statements.syslog_stripper_stmt
]))
config_to_enable = Path(config, enable, 'end',
Dialog([statements.syslog_msg_stmt]))
rommon_to_disable = Path(rommon, disable, 'boot',
Dialog(authentication_statement_list))
self.add_state(enable)
self.add_state(config)
self.add_state(disable)
self.add_state(rommon)
self.add_path(rommon_to_disable)
self.add_path(disable_to_enable)
self.add_path(enable_to_config)
self.add_path(enable_to_rommon)
self.add_path(config_to_enable)
self.add_path(enable_to_disable)
self.add_default_statements(default_statement_list)
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)
