def main():
"""
Main show EPGs routine
:return: None
"""
# Login to APIC
description = ('Simple application that logs on to the APIC'
' and add static-binding-leaves.')
creds = aci.Credentials('apic', description)
creds.add_argument('-t', '--tenant', help='Tenant name', default=DEFAULT_TENANT)
creds.add_argument('-a', '--app', help='Application profile name', default=DEFAULT_APP)
creds.add_argument('-e', '--epg', help='EPG name', default=DEFAULT_EPG)
creds.add_argument('-n', '--node', help='Node ID (e.g. 101)', default=DEFAULT_NODE_ID)
creds.add_argument('-y', '--type', help='Encapsulation type (vlan | vxlan | nvgre)', default=DEFAULT_ENCAP_TYPE)
creds.add_argument('-i', '--id', help='Specific identifier representing the virtual L2 network (e.g. 100)', default=DEFAULT_ENCAP_ID)
creds.add_argument('-m', '--mode', help='Encapsulation mode (regular | untagged | native)', default=DEFAULT_ENCAP_MODE)
creds.add_argument('-d', '--deploy', help='Deployment immediacy (immediate | lazy)', default=DEFAULT_IMMEDIACY)
creds.add_argument('-o', '--pod', help='Pod number (e.g. 1)', default=DEFAULT_POD)
args = creds.get()
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
tenant = aci.Tenant(args.tenant)
app = aci.AppProfile(args.app, tenant)
epg = aci.EPG(args.epg, app)
epg.add_static_leaf_binding(args.node, args.type, args.id, args.mode, args.deploy, args.pod)
# Push it all to the APIC
resp = session.push_to_apic(tenant.get_url(), tenant.get_json())
def main():
"""
Main execution routine
:return: None
"""
# Take login credentials from the command line if provided
# Otherwise, take them from your environment variables file ~/.profile
description = 'Simple application that logs on to the APIC and displays \
all of the filters.'
creds = ACI.Credentials('apic', description)
args = creds.get()
# Login to APIC
session = ACI.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
# Download all of the tenants
template = '{0:20} {1:20}'
print template.format("TENANT", "FILTER")
print template.format("------", "------")
tenants = ACI.Tenant.get(session)
for tenant in tenants:
filters = ACI.Filter.get(session, tenant)
for filter in filters:
print template.format(tenant.name, filter.name)
def main():
"""
Main subscribe tenants routine
:return: None
"""
# Take login credentials from the command line if provided
# Otherwise, take them from your environment variables file ~/.profile
description = ('Simple application using event subscription for the'
'Tenant class. When run, this application will log '
'into the APIC and subscribe to events on the Tenant '
'class. If a new tenant is created, the event will be'
'printed on the screen. Likewise, if an existing tenant'
'is deleted.')
creds = aci.Credentials('apic', description)
args = creds.get()
# Login to APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
aci.Tenant.subscribe(session)
while True:
if aci.Tenant.has_events(session):
tenant = aci.Tenant.get_event(session)
if tenant.is_deleted():
print('Tenant', tenant.name, 'has been deleted.')
else:
print('Tenant', tenant.name, 'has been created or modified.')
def main():
"""
Main show Process routine
:return: None
"""
description = 'Simple application that logs on to the APIC and displays process information for a switch'
creds = Credentials('apic', description)
creds.add_argument('-s',
'--switch',
type=str,
default=None,
help='Specify a particular switch id, e.g. "102"')
args = creds.get()
session = ACI.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print '%% Could not login to APIC'
sys.exit(0)
switches = ACI.Node.get(session, '1', args.switch)
for switch in switches:
if switch.role != 'controller':
processes = ACI.Process.get(session, switch)
tables = ACI.Process.get_table(
processes, 'Process list for Switch ' + switch.name + '::')
for table in tables:
print table.get_text(tablefmt='fancy_grid') + '\n'
def main():
"""
Main create tenant routine
:return: None
"""
# Get all the arguments
description = 'It logs in to the APIC and will create the vlan pool.'
creds = aci.Credentials('apic', description)
creds.add_argument('-v',
'--vlan',
help='The name of vlan pool',
default=DEFAULT_VLAN_NAME)
args = creds.get()
# Login to the APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
# Create the VLAN pool
vlan_pool = aci.NetworkPool(args.vlan, 'vlan', '222', '223', 'dynamic')
# Push the VLAN pool to the APIC
resp = session.push_to_apic(vlan_pool.get_url(), vlan_pool.get_json())
if not resp.ok:
print('%% Error: Could not push configuration to APIC')
print(resp.text)
def main():
"""
Main execution routine
:return: None
"""
# Login to APIC
session = aci.Session("http://apic-amslab.cisco.com", "admin", "C1sco123")
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
if resp.ok:
print("\nApic login successful")
intDown = []
intNames = []
interfaces = aci.Interface.get(session)
for interface in interfaces:
if interface.attributes['operSt'] == 'down':
intDown.append(interface.attributes['operSt'])
intNames.append(interface.attributes['if_name'])
l3outNames = []
l3outs = aci.L3ExtDomain.get(robvand)
print('\nThere are {} ports available'.format(intDown.count('down')))
template = "{0:25}"
print(template.format("\nAVAILABLE INTERFACES"))
print(template.format("---------"))
for intName in intNames:
print(template.format(intName))
def create_aci_session(aci_apic, aci_user, aci_pass):
"""
Creates an ACI session from the given APIC address, username, and password.
:param aci_apic: Address of the APIC.
:param aci_user: Username for the APIC.
:param aci_pass: Password for the APIC.
:return: The ACI session object or raises PortalException on error.
"""
try:
aci_session = ACI.Session(aci_apic, aci_user, aci_pass)
except CredentialsError as e:
app.logger.error(str(e))
raise PortalException('ACI credentials or APIC IP invalid.')
try:
resp = aci_session.login(timeout=30)
except (requests.exceptions.MissingSchema, requests.exceptions.InvalidURL, TypeError) as e:
app.logger.error(str(e))
raise PortalException('Invalid APIC IP, please provide a correct one.')
if resp.status_code != 200:
app.logger.error(resp.content)
raise PortalException('ACI credentials or APIC IP incorrect!')
return aci_session
def main():
"""
Main common routine for show interface description
:return: None
"""
# Set up the command line options
description = ('Simple application that logs in to the APIC'
'and displays the Interface Optics and Neighbors')
creds = ACI.Credentials('apic', description)
args = creds.get()
# Login to APIC
apic = ACI.Session(args.url, args.login, args.password)
resp = apic.login()
if not resp.ok:
print('%% Could not login to APIC')
return
# Show interface Optic & LLDP Neighbor
#print('starting node_ids')
switch_attributes = get_switch_attributes(apic, args)
#print('starting intf_ids')
intf_ids = get_intf_ids(apic, args, switch_attributes)
#print('starting Section for Optics and Neighbors')
interface_detail(apic, args, switch_attributes, intf_ids)
def main():
"""
Main show Process routine
:return: None
"""
description = 'Simple application that logs on to the APIC and check cluster information for a fabric'
creds = Credentials('apic', description)
args = creds.get()
session = ACI.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print '%% Could not login to APIC'
sys.exit(0)
cluster = ACI_PHYS.Cluster('Cluster')
cluster_info = cluster.get(session)
if (cluster.config_size != cluster.cluster_size):
print("*******************************************************")
print ("WARNING, configured cluster size "), cluster.config_size
print (": not equal to the actual size "), cluster.cluster_size
print "WARNING, desired stats collection might be lost"
print("*******************************************************")
print("APICs in the cluster"), cluster.name, (":")
for apic in cluster.apics:
print json.dumps(apic,indent=4, sort_keys = True)
else:
print("PASS")
def establish_ws_session(self, max_retries=None):
try:
with utils.get_rlock(lcon.ACI_WS_CONNECTION_LOCK, blocking=False):
retries = 0
self._reload_websocket_config()
max_retries = max_retries or 2 * len(self.ws_urls)
while retries < max_retries:
if self.session and self.session.session:
self.session.close()
LOG.info('Establishing WS connection with url: %s',
self.ws_urls[0])
self.session = acitoolkit.Session(
self.ws_urls[0],
self.apic_username,
self.apic_password,
verify_ssl=self.verify_ssl_certificate,
cert_name=self.cert_name,
key=self.private_key_file)
resp = self.session.login()
if not resp.ok:
LOG.warn('Websocket connection failed: %s' % resp.text)
self.ws_urls.rotate(-1)
LOG.info('Rotating websocket URL, '
'using: %s' % self.ws_urls[0])
retries += 1
continue
LOG.info('Websocket connection succeeded.')
self._spawn_monitors()
return self.session
utils.perform_harakiri(
LOG, "Cannot establish WS connection "
"after %s retries." % retries)
except utils.LockNotAcquired:
# Some other thread is trying to reconnect
return
def toolkit_login(admin_info):
session = ACI.Session(admin_info['ip_addr'], admin_info['user'],
admin_info['password'])
response = session.login()
if not response.ok:
error_message(
[1, 'There was an error with the connection to the APIC.', -1])
return False
decoded_response = json.loads(response.text)
if (response.status_code != 200):
if (response.status_code == 401):
connection_status = 'Username/Password incorrect'
return False
else:
error_message([
decoded_response['imdata'][0]['error']['attributes']['code'],
decoded_response['imdata'][0]['error']['attributes']['text'],
-1
])
return False
elif (response.status_code == 200):
refresh = decoded_response['imdata'][0]['aaaLogin']['attributes'][
'refreshTimeoutSeconds']
cookie = response.cookies['APIC-cookie']
return session
else:
return False
return False
def main():
time.sleep(70)
description = ('Simple application that logs on to the APIC'
' and displays all of the Endpoints.')
creds = aci.Credentials('apic', description)
args = creds.get()
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
data = []
endpoints = aci.IPEndpoint.get(session)
for ep in endpoints:
epg = ep.get_parent()
app_profile = epg.get_parent()
tenant = app_profile.get_parent()
if (tenant.name == 'Devops' and ((epg.name == 'web'))):
data.append((ep.mac, ep.ip, epg.name))
#print "Test here\n"
y = len(data)
print "[WEB]"
print data[y - 1][1]
def main():
"""
Main Show Endpoints Routine
:return: None
"""
# Take login credentials from the command line if provided
# Otherwise, take them from your environment variables file ~/.profile
description = ('Simple application that logs on to the APIC'
' and displays all of the Endpoints.')
creds = aci.Credentials('apic', description)
args = creds.get()
# Login to APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
return
# Download all of the interfaces
# and store the data as tuples in a list
data = []
endpoints = aci.Endpoint.get(session)
for ep in endpoints:
epg = ep.get_parent()
app_profile = epg.get_parent()
tenant = app_profile.get_parent()
data.append((ep.if_name, tenant.name))
# Display the data downloaded
print(tabulate(data, headers=["INTERFACE", "TENANT"]))
def main():
"""
Main Show Physical Domains Routine
:return: None
"""
# Take login credentials from the command line if provided
# Otherwise, take them from your environment variables file ~/.profile
description = ('Simple application that logs on to the APIC'
' and displays all of the Physical Domains.')
creds = aci.Credentials('apic', description)
args = creds.get()
# Login to APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
domains = aci.PhysDomain.get(session)
if len(domains) > 0:
print ('---------------')
print ('Physical Domain')
print ('---------------')
for domain in domains:
print domain.name
if len(domains) > 0:
print '\n'
domains = aci.VmmDomain.get(session)
def main():
# Get the APIC login credentials
description = 'testing tags'
creds = aci.Credentials('apic', description)
args = creds.get()
# Login to APIC and push the config
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
return
# get all physical domains
phydms = aci.PhysDomain.get(session)
template = "{0:30} {1:30} {2:25}"
if len(phydms) > 0:
print(template.format("Physical Domain", "Network", "encap_type"))
for p in phydms:
pool_name = ""
encap_type = ""
if p.has_network():
net = p.get_network()
pool_name = net.name
encap_type = net.encap_type
print(template.format(p.name, pool_name, encap_type))
def getErrorsEgressDrops():
# Login to APIC
session = ACI.Session("https://172.31.216.24",
"admin",
"scotch123",
subscription_enabled=False)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
# Download all of the interfaces and get their stats
# and display the stats
interfaces = ACI.Interface.get(session)
allStats = []
avgErrorPerInt = []
for interface in sorted(interfaces, key=attrgetter('if_name')):
if "egrDropPkts" in interface.stats.get().keys():
stats = interface.stats.get()['egrDropPkts']
if stats:
allStats.append([interface.name, stats["5min"]])
for i in allStats:
#avg packets dropped cause full buffer
name = i[0]
drops = i[1][12]['bufferAvg']
if drops:
avgErrorPerInt.append([name, drops])
return avgErrorPerInt
def establish_ws_session(self, max_retries=None):
retries = 0
self._reload_websocket_config()
max_retries = max_retries or 2 * len(self.ws_urls)
while retries < max_retries:
if self.session and self.session.session:
self.session.close()
LOG.info('Establishing WS connection with parameters: %s',
[self.ws_urls[0], self.apic_username, self.apic_password,
self.verify_ssl_certificate])
self.session = acitoolkit.Session(
self.ws_urls[0], self.apic_username, self.apic_password,
verify_ssl=self.verify_ssl_certificate,
cert_name=self.cert_name, key=self.private_key_file)
resp = self.session.login()
if not resp.ok:
LOG.debug('Websocket connection failed: %s' % resp.text)
self.ws_urls.rotate(-1)
LOG.info('Rotating websocket URL, using: %s' % self.ws_urls[0])
retries += 1
continue
LOG.info('Websocket connection succeeded.')
self._spawn_monitors()
return self.session
utils.perform_harakiri(LOG, "Cannot establish WS connection after %s "
"retries." % retries)
def main(login, password, url):
"""
Main execution routine
:return: None
"""
# Take login credentials from the command line if provided
# Otherwise, take them from your environment variables file ~/.profile
description = 'Simple application that logs on to the APIC and displays all of the Tenants.'
#creds = ACI.Credentials('apic', description)
#args = creds.get()
# Login to APIC
#session = ACI.Session(args.url, args.login, args.password)
session = ACI.Session(url, login, password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
# Download all of the tenants
print("TENANT")
print("------")
tenants = ACI.Tenant.get(session)
count = 0
for tenant in tenants:
count += 1
if count > 23:
os.system("read -p \"Press enter key\"")
count = 0
print(tenant.name)
def main():
description = (
'Simple application that logs on to the APIC and displays the'
' response of a given query')
creds = aci.Credentials('apic', description)
creds.add_argument('-c',
'--class_name',
help='The class which is to be queried',
required=True)
creds.add_argument(
'-q',
'--query_target',
default='self',
help=('This restricts the scope of the query,query_target takes self'
'| children | subtree. ex: -q self. The default is self.'))
args = creds.get()
if not args.class_name:
args.class_name = raw_input("Class Name: ")
# Login to APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
class_url = '/api/node/class/' + args.class_name + '.json?query-target=' + args.query_target
print("class_url is " + class_url)
ret = session.get(class_url)
response = ret.json()
imdata = response['imdata']
pprint(imdata)
def main():
"""
Main show EPGs routine
:return: None
"""
# Login to APIC
description = ('Simple application that logs on to the APIC'
' and displays all of the EPGs.')
creds = aci.Credentials('apic', description)
args = creds.get()
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
# Download all of the tenants, app profiles, and EPGs
# and store the names as tuples in a list
data = []
tenants = aci.Tenant.get(session)
for tenant in tenants:
apps = aci.AppProfile.get(session, tenant)
for app in apps:
epgs = aci.EPG.get(session, app, tenant)
for epg in epgs:
data.append((tenant.name, app.name, epg.name))
# Display the data downloaded
template = "{0:19} {1:20} {2:15}"
print(template.format("TENANT", "APP_PROFILE", "EPG"))
print(template.format("------", "-----------", "---"))
for rec in data:
print(template.format(*rec))
def main():
"""
Main create tenant routine
:return: None
"""
# Get all the arguments
description = 'It logs in to APIC and will create the physical domain.'
creds = aci.Credentials('apic', description)
creds.add_argument('-p', '--phy_domain',
help='The name of physical domain',
default=DEFAULT_PHY_DOMAIN_NAME)
args = creds.get()
# Login to the APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
# Create the physical Domain
phy_dmn = aci.PhysDomain(args.phy_domain)
# Push the physical domain to the APIC
resp = session.push_to_apic(phy_dmn.get_url(),
phy_dmn.get_json())
if not resp.ok:
print('%% Error: Could not push configuration to APIC')
print(resp.text)
def main():
"""
Main create tenant routine
:return: None
"""
# Get all the arguments
description = 'It logs in to the APIC and will create the tenant.'
creds = aci.Credentials('apic', description)
creds.add_argument('-t',
'--tenant',
help='The name of tenant',
default=DEFAULT_TENANT_NAME)
args = creds.get()
# Login to the APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
# Create the Tenant
tenant = aci.Tenant(args.tenant)
# Push the tenant to the APIC
resp = session.push_to_apic(tenant.get_url(), tenant.get_json())
if not resp.ok:
print('%% Error: Could not push configuration to APIC')
print(resp.text)
def main():
# Get the APIC login credentials
description = 'testing tags'
creds = aci.Credentials('apic', description)
creds.add_argument('--tag',
help='Add tag to all objects in this configuration')
creds.add_argument('--tenant', help='Tenant name to be created')
args = creds.get()
#Create the Tenant
if args.tenant:
tenant = aci.Tenant(args.tenant)
else:
tenant = aci.Tenant('tutorial-tag')
# Create the Application Profile
app = aci.AppProfile('myapp', tenant)
# Create the EPG
epg1 = aci.EPG('myepg1', app)
epg2 = aci.EPG('myepg2', app)
# Create a Context and BridgeDomain
context = aci.Context('myvrf', tenant)
bd = aci.BridgeDomain('mybd', tenant)
bd.add_context(context)
# Place the EPG in the BD
epg1.add_bd(bd)
epg2.add_bd(bd)
# Add Tag to the EPGs
epg1.add_tag("web server")
epg2.add_tag("database")
# test
app2 = aci.AppProfile('myapp2', tenant)
epg21 = aci.EPG('myepg21', app2)
epg22 = aci.EPG('myepg22', app2)
# Add Tag to all objects in this configuration
if args.tag:
tenant.add_tag(args.tag)
context.add_tag(args.tag)
bd.add_tag(args.tag)
epg1.add_tag(args.tag)
epg2.add_tag(args.tag)
# Login to APIC and push the config
session = aci.Session(args.url, args.login, args.password)
session.login()
resp = tenant.push_to_apic(session)
if resp.ok:
print('Success')
# Print what was sent
print('Pushed the following JSON to the APIC')
print('URL:', tenant.get_url())
print('JSON:', tenant.get_json())
def apic_login_acitk(hostname,username,password):
# Login to APIC
url = "https://" + hostname
session = ACI.Session(url, username, password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
return session
def apic_login():
url = credentials.ACI_login['ipaddr']
login = credentials.ACI_login['username']
password = credentials.ACI_login['password']
# Login to APIC
session = ACI.Session(url, login, password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
return (session)
def _ws_session_login(self,
url,
url_max_retries,
purpose,
aim_context=None,
apic_assign=None,
apic_assign_obj=None):
retries = 0
LOG.info('Establishing %s WS connection with url: %s', purpose, url)
valid_session = None
while retries < url_max_retries:
session = acitoolkit.Session(
url,
self.apic_username,
self.apic_password,
verify_ssl=self.verify_ssl_certificate,
cert_name=self.cert_name,
key=self.private_key_file)
resp = session.login()
if not resp.ok:
LOG.warn('%s Websocket connection failed: %s', purpose,
resp.text)
retries += 1
if session.session:
session.close()
continue
LOG.info('%s Websocket connection succeeded with url: %s', purpose,
url)
valid_session = session
break
if valid_session:
# We don't need to claim the ownership if we are just
# picking up a backup APIC.
if purpose != BACKUP_PURPOSE:
obj = self._update_apic_assign_db(aim_context, apic_assign,
apic_assign_obj)
if obj is None:
valid_session.close()
return False
if purpose == BACKUP_PURPOSE or obj:
if self.session and self.session.session:
self.session.close()
self.is_session_reconnected = True
self.session = valid_session
self._spawn_monitors()
if purpose == BACKUP_PURPOSE:
self.need_recovery = True
else:
self.apic_assign_obj = obj
self.need_recovery = False
return True
return False
def __init__(self, args):
# Login to the APIC
self.session = ACI.Session(args.url, args.login, args.password)
resp = self.session.login()
if not resp.ok:
print '%% Could not login to APIC'
# Create the Git repository
repo_parent_dir = os.getcwd()
self.repo_dir = os.path.join(repo_parent_dir, 'apic-config-db')
self.repo = git.Repo.init(self.repo_dir)
def main():
'''
Main Routine
'''
# Take login credentials from the command line if provided
description = ('Simple application to display details about faults in an ACI Fabric')
creds = aci.Credentials('apic', description)
creds.add_argument('--sort', choices=["asc", "desc"], default="desc", help='Specify the sort order within each severity based on time/date. Default is Descending order. i.e. Newest faults at the top of each category')
args = creds.get()
# Login to APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
return
# Available severity codes for ACI Fault Instances
fault_severity = ["critical", "major", "minor", "warning", "info", "cleared"]
fault_lookup = {} # Dictionary to be used to store the returned MO's, with the key being the severity
fault_severity_count = {} # Dictionary to track total faults per severity
# Loop through all fault severity types, perform a fault lookup in the system and return the list of MO's.
# Assign to the fault_lookup dictionary, with severity as the key
for fault_type in fault_severity:
resp = query_fault(session, fault_type, args.sort)
resp2 = resp['imdata']
faultInst = []
for entry in resp2:
faultInst.append((entry["faultInst"]["attributes"]["code"],
entry["faultInst"]["attributes"]["descr"],
entry["faultInst"]["attributes"]["cause"],
entry["faultInst"]["attributes"]["occur"],
entry["faultInst"]["attributes"]["lastTransition"]))
#print faultInst
fault_lookup[fault_type] = faultInst
# Find out the length of the inner list, based off the fault severity in the lookup
# eg: fault_lookup["critical"] = [x,y,z]
fault_severity_count[fault_type] = len(fault_lookup[fault_type])
# Loop through each severity, sort by faultCode and then print it out
for item in fault_severity:
print_fault(item, fault_lookup[item])
print "=" * 80
print ("Summary of total faults")
print "-" * 80
for fault_summary in fault_severity:
print (fault_summary + " = " + str(fault_severity_count[fault_summary]))
print "=" * 80
def tracker(args):
"""
Main Endpoint tracker
:param args: command line arguments
:return: None
"""
# Login to APIC
session = aci.Session(args.url, args.login, args.password)
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
sys.exit(0)
c, cnx = connect_mysql(args)
# Download all of the Endpoints and store in the database
endpoints = aci.Endpoint.get(session)
for ep in endpoints:
try:
epg = ep.get_parent()
except AttributeError:
continue
app_profile = epg.get_parent()
tenant = app_profile.get_parent()
if ep.if_dn:
for dn in ep.if_dn:
match = re.match('protpaths-(\d+)-(\d+)', dn.split('/')[2])
if match:
if match.group(1) and match.group(2):
int_name = "Nodes: " + match.group(
1) + "-" + match.group(2) + " " + ep.if_name
else:
int_name = ep.if_name
try:
data = (ep.mac, ep.ip, tenant.name, app_profile.name, epg.name,
ep.if_name, convert_timestamp_to_mysql(ep.timestamp))
except ValueError, e:
if args.daemon:
logging.info(e)
continue
ep_exists = c.execute("""SELECT * FROM endpoints
WHERE mac="%s"
AND
timestop is null;""" % ep.mac)
c.fetchall()
if not ep_exists:
c.execute("""INSERT INTO endpoints (mac, ip, tenant,
app, epg, interface, timestart)
VALUES ('%s', '%s', '%s', '%s',
'%s', '%s', '%s')""" % data)
cnx.commit()
def main():
description = 'Simple application that logs on to the APIC and displays stats for all of the Interfaces.'
creds = ACI.Credentials('apic', description)
# group = creds.add_mutually_exclusive_group()
group1 = creds.add_argument_group('Export', 'Export a cable plan')
group1.add_argument('-e', '--export_file', default=None, const='export text', dest='export_file', nargs='?',
help='Export cableplan from running fabric. If EXPORT_FILE is specified, the '
'cableplan will be written to EXPORT_FILE')
group2 = creds.add_argument_group('Compare', 'Compare cable plans')
group2.add_argument('-c1', '--cableplan1',
type=str, nargs=1,
default=None,
help="Name of cableplan xml file. If only CABLEPLAN1 is specified, "
"it will be compared to the running fabric. If it is specified with "
"CABLEPLAN2 (the -c2 option), then it will compare CABLEPLAN1 with CABLEPLAN2")
group2.add_argument('-c2', '--cableplan2',
type=str, nargs=1,
default=None,
help="Name of second cableplan xml file. The second cableplan file. This file will "
"be compared to CABLEPLAN1. This option must only be used "
"in conjunction with the -c1 option.")
args = creds.get()
session = ACI.Session(args.url, args.login, args.password)
if args.export_file and (args.cableplan1 or args.cableplan2):
creds.print_help()
print '\nError: export and compare operations are mutually exclusive'
exit()
if args.cableplan2 and not args.cableplan1:
creds.print_help()
print '\nError: -c2 option only valid with -c1 option'
exit()
if not args.export_file and not args.cableplan1:
creds.print_help()
print '\nError: Either export (-e) or compare (-c1) is required'
exit()
if args.export_file:
if args.export_file == 'export text':
export_to_file(session)
else:
export_to_file(session, args.export_file)
if args.cableplan1:
if args.cableplan2:
compare_cable_plans(session, args.cableplan1[0], args.cableplan2[0])
else:
compare_cable_plans(session, args.cableplan1[0])
