def main():
#
# Define parameters for commandline entry
#
module = AnsibleModule(argument_spec=dict(
outputfile=dict(required=True),
host=dict(required=True),
username=dict(required=True),
password=dict(required=True),
enablePassword=dict(required=False),
),
supports_check_mode=False)
username = module.params['username']
password = module.params['password']
enablePassword = module.params['enablePassword']
cliCommand = "display sys-info"
outputfile = module.params['outputfile']
hostIP = module.params['host']
output = ""
# Create instance of SSHClient object
remote_conn_pre = paramiko.SSHClient()
# Automatically add untrusted hosts (make sure okay for security policy in your environment)
remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# initiate SSH connection with the switch
remote_conn_pre.connect(hostIP, username=username, password=password)
time.sleep(2)
# Use invoke_shell to establish an 'interactive session'
remote_conn = remote_conn_pre.invoke_shell()
time.sleep(2)
# Enable and enter configure terminal then send command
output = output + cnos_utility.waitForDeviceResponse(
"\n", ">", 2, remote_conn)
output = output + cnos_utility.enterEnableModeForDevice(
enablePassword, 3, remote_conn)
#Make terminal length = 0
output = output + cnos_utility.waitForDeviceResponse(
"terminal length 0\n", "#", 2, remote_conn)
#Send the CLi command
output = output + cnos_utility.waitForDeviceResponse(
cliCommand + "\n", "#", 2, remote_conn)
#Save it into the file
file = open(outputfile, "a")
file.write(output)
file.close()
errorMsg = cnos_utility.checkOutputForError(output)
if (errorMsg == None):
module.exit_json(changed=True, msg="Device Sys Info is saved to file ")
else:
module.fail_json(msg=errorMsg)
def main():
#
# Define parameters for commandline entry
#
module = AnsibleModule(argument_spec=dict(
outputfile=dict(required=True),
host=dict(required=True),
username=dict(required=True),
password=dict(required=True, no_log=True),
enablePassword=dict(required=False, no_log=True),
deviceType=dict(required=True),
configType=dict(required=True),
protocol=dict(required=True),
serverip=dict(required=True),
rcpath=dict(required=True),
serverusername=dict(required=False),
serverpassword=dict(required=False),
),
supports_check_mode=False)
username = module.params['username']
password = module.params['password']
enablePassword = module.params['enablePassword']
outputfile = module.params['outputfile']
host = module.params['host']
deviceType = module.params['deviceType']
configType = module.params['configType']
protocol = module.params['protocol'].lower()
rcserverip = module.params['serverip']
rcpath = module.params['rcpath']
serveruser = module.params['serverusername']
serverpwd = module.params['serverpassword']
output = ""
timeout = 90
tftptimeout = 450
# Create instance of SSHClient object
remote_conn_pre = paramiko.SSHClient()
# Automatically add untrusted hosts (make sure okay for security policy in your environment)
remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# initiate SSH connection with the switch
remote_conn_pre.connect(host,
username=username,
password=password,
look_for_keys=False)
time.sleep(2)
# Use invoke_shell to establish an 'interactive session'
remote_conn = remote_conn_pre.invoke_shell()
time.sleep(2)
#
# Enable and enter configure terminal then send command
output = output + cnos_utility.waitForDeviceResponse(
"\n", ">", 2, remote_conn)
output = output + cnos_utility.enterEnableModeForDevice(
enablePassword, 3, remote_conn)
# Make terminal length = 0
output = output + cnos_utility.waitForDeviceResponse(
"terminal-length 0\n", "#", 2, remote_conn)
# Invoke method for config transfer from server
if (configType == 'running-config'):
if (protocol == "tftp" or protocol == "ftp"):
transfer_status = enos_utility.doRunningConfigBackUp(
protocol, tftptimeout, rcserverip, rcpath, serveruser,
serverpwd, remote_conn)
elif (protocol == "sftp" or protocol == "scp"):
transfer_status = enos_utility.doSecureRunningConfigBackUp(
protocol, timeout, rcserverip, rcpath, serveruser, serverpwd,
remote_conn)
else:
transfer_status = "Invalid Protocol option"
elif (configType == 'startup-config'):
if (protocol == "tftp" or protocol == "ftp"):
transfer_status = enos_utility.doStartupConfigBackUp(
protocol, tftptimeout, rcserverip, rcpath, serveruser,
serverpwd, remote_conn)
elif (protocol == "sftp" or protocol == "scp"):
transfer_status = enos_utility.doSecureStartupConfigBackUp(
protocol, timeout, rcserverip, rcpath, serveruser, serverpwd,
remote_conn)
else:
transfer_status = "Invalid Protocol option"
else:
transfer_status = "Invalid configType Option"
output = output + "\n Config Back Up status \n" + transfer_status
# Save it into the file
file = open(outputfile, "a")
file.write(output)
file.close()
# Logic to check when changes occur or not
errorMsg = cnos_utility.checkOutputForError(output)
if (errorMsg == None):
module.exit_json(changed=True, msg="Config file tranferred to server")
else:
module.fail_json(msg=errorMsg)
def main():
#
# Define parameters for commandline entry
#
module = AnsibleModule(argument_spec=dict(
commandfile=dict(required=True),
outputfile=dict(required=True),
host=dict(required=True),
deviceType=dict(required=True),
username=dict(required=True),
password=dict(required=True),
enablePassword=dict(required=False),
),
supports_check_mode=False)
username = module.params['username']
password = module.params['password']
enablePassword = module.params['enablePassword']
commandfile = module.params['commandfile']
outputfile = module.params['outputfile']
deviceType = module.params['deviceType']
hostIP = module.params['host']
output = ""
# Create instance of SSHClient object
remote_conn_pre = paramiko.SSHClient()
# Automatically add untrusted hosts (make sure okay for security policy in your environment)
remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# initiate SSH connection with the switch
remote_conn_pre.connect(hostIP, username=username, password=password)
time.sleep(2)
# Use invoke_shell to establish an 'interactive session'
remote_conn = remote_conn_pre.invoke_shell()
time.sleep(2)
# Enable and enter configure terminal then send command
output = output + cnos_utility.waitForDeviceResponse(
"\n", ">", 2, remote_conn)
output = output + cnos_utility.enterEnableModeForDevice(
enablePassword, 3, remote_conn)
#Make terminal length = 0
output = output + cnos_utility.waitForDeviceResponse(
"terminal length 0\n", "#", 2, remote_conn)
#Go to config mode
output = output + cnos_utility.waitForDeviceResponse(
"configure d\n", "(config)#", 2, remote_conn)
# Send commands one by one
with open(commandfile, "r") as f:
for line in f:
#Omit the comment lines in template file
if not line.startswith("#"):
command = line
if not line.endswith("\n"):
command = command + "\n"
response = cnos_utility.waitForDeviceResponse(
command, "#", 2, remote_conn)
errorMsg = cnos_utility.checkOutputForError(response)
output = output + response
if (errorMsg != None):
break # To cater to Mufti case
#Write to memory
output = output + cnos_utility.waitForDeviceResponse(
"save\n", "#", 3, remote_conn)
#Write output to file
file = open(outputfile, "a")
file.write(output)
file.close()
# Logic to check when changes occur or not
errorMsg = cnos_utility.checkOutputForError(output)
if (errorMsg == None):
module.exit_json(changed=True, msg="Template Applied")
else:
module.fail_json(msg=errorMsg)
def main():
#
# Define parameters for commandline entry
#
module = AnsibleModule(argument_spec=dict(
clicommand=dict(required=True),
clicommand2=dict(required=False),
outputfile=dict(required=True),
host=dict(required=True),
deviceType=dict(required=True),
username=dict(required=True),
password=dict(required=True, no_log=True),
enablePassword=dict(required=False, no_log=True),
),
supports_check_mode=False)
username = module.params['username']
password = module.params['password']
enablePassword = module.params['enablePassword']
cliCommand = module.params['clicommand']
cliCommand2 = module.params['clicommand2']
deviceType = module.params['deviceType']
outputfile = module.params['outputfile']
hostIP = module.params['host']
output = ""
# Create instance of SSHClient object
remote_conn_pre = paramiko.SSHClient()
# Automatically add untrusted hosts (make sure okay for security policy in your environment)
remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# initiate SSH connection with the switch
remote_conn_pre.connect(hostIP,
username=username,
password=password,
look_for_keys=False)
time.sleep(2)
# Use invoke_shell to establish an 'interactive session'
remote_conn = remote_conn_pre.invoke_shell()
time.sleep(2)
# Enable and enter configure terminal then send command
output = output + cnos_utility.waitForDeviceResponse(
"\n", ">", 2, remote_conn)
output = output + cnos_utility.enterEnableModeForDevice(
enablePassword, 3, remote_conn)
#Make terminal length = 0
output = output + cnos_utility.waitForDeviceResponse(
"terminal-length 0\n", "#", 2, remote_conn)
#Disable console prompts
output = output + cnos_utility.waitForDeviceResponse(
"terminal dont-ask\n", "#", 2, remote_conn)
#Go to config mode
output = output + cnos_utility.waitForDeviceResponse(
"configure t\n", "(config)#", 2, remote_conn)
#Send the CLi command
output = output + cnos_utility.waitForDeviceResponse(
cliCommand + "\n", "(config)#", 2, remote_conn)
#Send the second CLi command
output = output + cnos_utility.waitForDeviceResponse(
cliCommand2 + "\n", "(config)#", 2, remote_conn)
#Save it into the file
file = open(outputfile, "a")
file.write(output)
file.close()
# Logic to check when changes occur or not
errorMsg = cnos_utility.checkOutputForError(output)
if (errorMsg == None):
module.exit_json(changed=True,
msg="CLI command executed and results saved in file ")
else:
module.fail_json(msg=errorMsg)
def main():
#
# Define parameters for vlan creation entry
#
module = AnsibleModule(argument_spec=dict(
outputfile=dict(required=True),
host=dict(required=True),
username=dict(required=True),
password=dict(required=True),
enablePassword=dict(required=False),
deviceType=dict(required=True),
vlanArg1=dict(required=True),
vlanArg2=dict(required=False),
vlanArg3=dict(required=False),
vlanArg4=dict(required=False),
vlanArg5=dict(required=False),
),
supports_check_mode=False)
username = module.params['username']
password = module.params['password']
enablePassword = module.params['enablePassword']
vlanArg1 = module.params['vlanArg1']
vlanArg2 = module.params['vlanArg2']
vlanArg3 = module.params['vlanArg3']
vlanArg4 = module.params['vlanArg4']
vlanArg5 = module.params['vlanArg5']
outputfile = module.params['outputfile']
hostIP = module.params['host']
deviceType = module.params['deviceType']
output = ""
# Create instance of SSHClient object
remote_conn_pre = paramiko.SSHClient()
# Automatically add untrusted hosts (make sure okay for security policy in your environment)
remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# initiate SSH connection with the switch
remote_conn_pre.connect(hostIP, username=username, password=password)
time.sleep(2)
# Use invoke_shell to establish an 'interactive session'
remote_conn = remote_conn_pre.invoke_shell()
time.sleep(2)
# Enable and enter configure terminal then send command
output = output + cnos_utility.waitForDeviceResponse(
"\n", ">", 2, remote_conn)
output = output + cnos_utility.enterEnableModeForDevice(
enablePassword, 3, remote_conn)
#Make terminal length = 0
output = output + cnos_utility.waitForDeviceResponse(
"terminal length 0\n", "#", 2, remote_conn)
#Go to config mode
output = output + cnos_utility.waitForDeviceResponse(
"configure d\n", "(config)#", 2, remote_conn)
#Send the CLi command
#output = output + cnos_utility.createVlan(vlanid,vlanname,"(config)#", 2, remote_conn)
output = output + cnos_utility.vlanConfig(
remote_conn, deviceType, "(config)#", 2, vlanArg1, vlanArg2, vlanArg3,
vlanArg4, vlanArg5)
#Save it into the file
file = open(outputfile, "a")
file.write(output)
file.close()
# need to add logic to check when changes occur or not
errorMsg = cnos_utility.checkOutputForError(output)
if (errorMsg == None):
module.exit_json(changed=True,
msg="VLAN configuration is accomplished ")
else:
module.fail_json(msg=errorMsg)
def main():
#
# Define parameters for portChannel creation entry
#
module = AnsibleModule(
argument_spec=dict(
outputfile=dict(required=True),
host=dict(required=True),
username=dict(required=True),
password=dict(required=True),
enablePassword=dict(required=False),
deviceType=dict(required=True),
interfaceRange=dict(required=False),
interfaceOption=dict(required=False),
interfaceArg1=dict(required=True),
interfaceArg2=dict(required=False),
interfaceArg3=dict(required=False),
interfaceArg4=dict(required=False),
interfaceArg5=dict(required=False),
interfaceArg6=dict(required=False),
interfaceArg7=dict(required=False),),
supports_check_mode=False)
username = module.params['username']
password = module.params['password']
enablePassword = module.params['enablePassword']
interfaceRange = module.params['interfaceRange']
interfaceOption = module.params['interfaceOption']
interfaceArg1= module.params['interfaceArg1']
interfaceArg2 = module.params['interfaceArg2']
interfaceArg3= module.params['interfaceArg3']
interfaceArg4 = module.params['interfaceArg4']
interfaceArg5 = module.params['interfaceArg5']
interfaceArg6 = module.params['interfaceArg6']
interfaceArg7 = module.params['interfaceArg7']
outputfile = module.params['outputfile']
hostIP = module.params['host']
deviceType = module.params['deviceType']
output = ""
# Create instance of SSHClient object
remote_conn_pre = paramiko.SSHClient()
# Automatically add untrusted hosts (make sure okay for security policy in your environment)
remote_conn_pre.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# initiate SSH connection with the switch
remote_conn_pre.connect(hostIP, username=username, password=password)
time.sleep(2)
# Use invoke_shell to establish an 'interactive session'
remote_conn = remote_conn_pre.invoke_shell()
time.sleep(2)
# Enable and enter configure terminal then send command
output = output + cnos_utility.waitForDeviceResponse("\n",">", 2, remote_conn)
output = output + cnos_utility.enterEnableModeForDevice(enablePassword, 3, remote_conn)
#Make terminal length = 0
output = output + cnos_utility.waitForDeviceResponse("terminal length 0\n","#", 2, remote_conn)
#Go to config mode
output = output + cnos_utility.waitForDeviceResponse("configure d\n","(config)#", 2, remote_conn)
#Send the CLi command
if(interfaceOption == None or interfaceOption == ""):
output = output + cnos_utility.interfaceConfig(remote_conn, deviceType, "(config)#", 2, None, interfaceRange,
interfaceArg1, interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5,interfaceArg6, interfaceArg7)
elif(interfaceOption == "ethernet"):
output = output + cnos_utility.interfaceConfig(remote_conn, deviceType, "(config)#", 2, "ethernet", interfaceRange,
interfaceArg1, interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5,interfaceArg6, interfaceArg7)
elif(interfaceOption == "loopback"):
output = output + cnos_utility.interfaceConfig(remote_conn, deviceType, "(config)#", 2, "loopback", interfaceRange,
interfaceArg1, interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5,interfaceArg6, interfaceArg7)
elif(interfaceOption == "mgmt"):
output = output + cnos_utility.interfaceConfig(remote_conn, deviceType, "(config)#", 2, "mgmt", interfaceRange,
interfaceArg1, interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5,interfaceArg6, interfaceArg7)
elif(interfaceOption == "port-aggregation"):
output = output + cnos_utility.interfaceConfig(remote_conn, deviceType, "(config)#", 2, "port-aggregation", interfaceRange,
interfaceArg1, interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5,interfaceArg6, interfaceArg7)
elif(interfaceOption == "vlan"):
output = output + cnos_utility.interfaceConfig(remote_conn, deviceType, "(config)#", 2, "vlan", interfaceRange,
interfaceArg1, interfaceArg2, interfaceArg3, interfaceArg4, interfaceArg5,interfaceArg6, interfaceArg7)
else:
output = "Invalid interface option \n"
#Save it into the file
file = open(outputfile, "a")
file.write(output)
file.close()
# Logic to check when changes occur or not
errorMsg = cnos_utility.checkOutputForError(output)
if(errorMsg == None):
module.exit_json(changed=True, msg="Interface Configuration is done")
else:
module.fail_json(msg=errorMsg)
