def SheetTunnels(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['Tunnels'] = []
# Connect to NSX
SessionNSX = ConnectNSX(auth_list)
transport_node_url = '/api/v1/transport-nodes'
transport_node_json = GetAPI(SessionNSX[0], transport_node_url, auth_list)
XLS_Lines = []
TN_HEADER_ROW = ('Transport Node', 'Tunnel Name', 'Tunnel Status',
'Egress Interface', 'Local Tunnel IP', 'Remote Tunnel IP',
'Remote Node ID', 'Remote Node Name', 'Encap')
# Check if Transport Node present
if isinstance(
transport_node_json,
dict) and 'results' in transport_node_json and transport_node_json[
'result_count'] > 0:
for node in transport_node_json['results']:
tunnel_url = '/api/v1/transport-nodes/' + node['id'] + '/tunnels'
tunnel_json = GetAPI(SessionNSX[0], tunnel_url, auth_list)
if tunnel_json["result_count"] > 0:
Dict_NodesTunnels = {}
Dict_NodesTunnels['node_name'] = node['display_name']
Dict_NodesTunnels['tunnels'] = []
Dict_Tunnels = {}
for tunnel in tunnel_json["tunnels"]:
Dict_Tunnels['name'] = tunnel['name']
Dict_Tunnels['status'] = tunnel['status']
Dict_Tunnels['Egress_int'] = tunnel['egress_interface']
Dict_Tunnels['local_ip'] = tunnel['local_ip']
Dict_Tunnels['remote_ip'] = tunnel['remote_ip']
Dict_Tunnels['remote_node_id'] = tunnel['remote_node_id']
Dict_Tunnels['remote_node_display_name'] = tunnel[
'remote_node_display_name']
Dict_Tunnels['encap'] = tunnel['encap']
Dict_NodesTunnels['tunnels'].append(Dict_Tunnels)
# Create line
XLS_Lines.append([
node['display_name'], tunnel['name'], tunnel['status'],
tunnel['egress_interface'], tunnel['local_ip'],
tunnel['remote_ip'], tunnel['remote_node_id'],
tunnel['remote_node_display_name'], tunnel['encap']
])
NSX_Config['Tunnels'].append(Dict_NodesTunnels)
else:
XLS_Lines.append(
["no Transport Nodes", "", "", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
ConditionnalFormat(TN_WS, 'C2:C' + str(len(XLS_Lines) + 1), 'UP')
def SheetSegments(auth_list,WORKBOOK,TN_WS,NSX_Config = {}):
NSX_Config['Segments'] = []
Dict_LS = {}
# NSX Connection
SessionNSX = ConnectNSX(auth_list)
stub_config = StubConfigurationFactory.new_std_configuration(SessionNSX[1])
ls_svc = LogicalSwitches(stub_config)
ls_list = ls_svc.list()
nb = len(ls_list.results)
tz_svc = TransportZones(stub_config)
tz_list = tz_svc.list()
XLS_Lines = []
TN_HEADER_ROW = ('Segments', 'VNI', 'VLAN', 'Transport Zone Name', 'Transport Zone Type', 'Replication Mode', 'Admin State')
if ls_list.result_count > 0:
while True:
for segment in ls_list.results:
TZ_NAME = ""
TZ_Type = ""
for tz in tz_list.results:
if segment.transport_zone_id == tz.id:
TZ_NAME = tz.display_name
TZ_Type = tz.transport_type
Dict_LS['segment_name'] = segment.display_name
Dict_LS['vni'] = segment.vni
Dict_LS['vlan'] = segment.vlan
Dict_LS['tz_name'] = TZ_NAME
Dict_LS['tz_type'] = TZ_Type
Dict_LS['replication_mode'] = segment.replication_mode
Dict_LS['status'] = segment.admin_state
NSX_Config['Segments'].append(Dict_LS)
XLS_Lines.append([segment.display_name, segment.vni, segment.vlan, TZ_NAME, TZ_Type, segment.replication_mode,segment.admin_state])
if ls_list.cursor is None:
break
else:
print(" --> more than " + str(nb) + " results for " + style.RED + "Segments" + style.NORMAL + " - please wait")
ls_list = LogicalSwitches(stub_config).list(cursor =ls_list.cursor )
nb = len(ls_list.results) + nb
else:
XLS_Lines.append(["no Segments", "", "", "", "", "",""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV,TN_HEADER_ROW,XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK,TN_WS.title,TN_HEADER_ROW,XLS_Lines,"0072BA")
ConditionnalFormat(TN_WS, 'G2:G' + str(len(XLS_Lines) + 1), 'UP')
def SheetSegments(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['Segments'] = []
Dict_LS = {}
# Connect to NSX
SessionNSX = ConnectNSX(auth_list)
segments_url = '/api/v1/logical-switches'
segments_json = GetAPI(SessionNSX[0], segments_url, auth_list)
tz_url = '/policy/api/v1/infra/sites/default/enforcement-points/default/transport-zones'
tz_json = GetAPI(SessionNSX[0], tz_url, auth_list)
XLS_Lines = []
TN_HEADER_ROW = ('Segments', 'VNI', 'VLAN', 'Transport Zone Name',
'Transport Zone Type', 'Replication Mode', 'Admin State')
# Check if Segements present
if isinstance(
segments_json, dict
) and 'results' in segments_json and segments_json['result_count'] > 0:
for segment in segments_json['results']:
TZ_NAME = ""
TZ_Type = ""
Dict_LS['vni'] = ''
Dict_LS['vlan'] = ''
for tz in tz_json['results']:
if segment['transport_zone_id'] == tz['id']:
TZ_NAME = tz['display_name']
TZ_Type = tz['tz_type']
break
Dict_LS['segment_name'] = segment['display_name']
if 'vni' in segment: Dict_LS['vni'] = segment['vni']
if 'vlan' in segment: Dict_LS['vlan'] = segment['vlan']
Dict_LS['tz_name'] = TZ_NAME
Dict_LS['tz_type'] = TZ_Type
if 'replication_mode' in segment:
Dict_LS['replication_mode'] = segment['replication_mode']
Dict_LS['status'] = segment['admin_state']
NSX_Config['Segments'].append(Dict_LS)
XLS_Lines.append([
Dict_LS['segment_name'], Dict_LS['vni'], Dict_LS['vlan'],
TZ_NAME, TZ_Type, Dict_LS['replication_mode'],
segment['admin_state']
])
else:
XLS_Lines.append(["no Segments", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
ConditionnalFormat(TN_WS, 'G2:G' + str(len(XLS_Lines) + 1), 'UP')
def SheetSummary(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
# Connection to NSX
SessionNSX = ConnectNSX(auth_list)
system_url = '/api/v1/ui-controller/system-aggregate-status'
inventory_url = '/api/v1/ui-controller/inventory-aggregate-status'
security_url = '/api/v1/ui-controller/security-aggregate-status'
network_url = '/api/v1/ui-controller/networking-aggregate-status'
fabric_url = '/api/v1/ui-controller/fabric-aggregate-status'
inventory_json = GetAPI(SessionNSX[0], inventory_url, auth_list)
security_json = GetAPI(SessionNSX[0], security_url, auth_list)
network_json = GetAPI(SessionNSX[0], network_url, auth_list)
fabric_json = GetAPI(SessionNSX[0], fabric_url, auth_list)
system_json = GetAPI(SessionNSX[0], system_url, auth_list)
XLS_Lines = []
TN_HEADER_ROW = (' ', 'Number', 'Alarms', 'Status')
XLS_Lines = GetEntity(system_json, XLS_Lines)
XLS_Lines = GetEntity(fabric_json, XLS_Lines)
XLS_Lines = GetEntity(inventory_json, XLS_Lines)
XLS_Lines = GetEntity(network_json, XLS_Lines)
XLS_Lines = GetEntity(security_json, XLS_Lines)
a1 = TN_WS['A1']
a1.font = Font(name='Arial', size=16, bold=True)
a1.value = "Summary"
TN_WS[3]
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK,
TN_WS.title,
TN_HEADER_ROW,
XLS_Lines,
"0072BA",
"TableStyleLight9",
True,
start_cell='A4')
ConditionnalFormat(TN_WS, 'D5:D' + str(len(XLS_Lines) + 4), 'UP',
False, 'GREEN')
ConditionnalFormat(TN_WS, 'D5:D' + str(len(XLS_Lines) + 4), 'NONE',
False, 'ORANGE')
ConditionnalFormat(TN_WS, 'D5:D' + str(len(XLS_Lines) + 4), 'UP')
def SheetTZ(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['TZ'] = []
Dict_TZ = {}
# Connect NSX
SessionNSX = ConnectNSX(auth_list)
stub_config = StubConfigurationFactory.new_std_configuration(SessionNSX[1])
XLS_Lines = []
TN_HEADER_ROW = ('Name', 'Description', 'ID', 'Ressource Type',
'Host Switch ID', 'Hos Switch Mode', 'Host Switch Name',
'Host Switch is Default', 'is Nested NSX',
'Transport Type', 'Uplink Teaming Policy Name')
tz_list = TransportZones(stub_config).list()
for TZ in tz_list.results:
tz = TZ.convert_to(TransportZone)
if tz.uplink_teaming_policy_names is not None:
TZ_Teaming = "\n".join(tz.uplink_teaming_policy_names)
else:
TZ_Teaming = ""
Dict_TZ['name'] = tz.display_name
Dict_TZ['description'] = tz.description
Dict_TZ['id'] = tz.id
Dict_TZ['resource_type'] = tz.resource_type
Dict_TZ['host_swithc_id'] = tz.host_switch_id
Dict_TZ['host_switch_mode'] = tz.host_switch_mode
Dict_TZ['host_switch_name'] = tz.host_switch_name
Dict_TZ['is_default'] = tz.is_default
Dict_TZ['nested'] = tz.nested_nsx
Dict_TZ['type'] = tz.transport_type
Dict_TZ['teaming'] = tz.uplink_teaming_policy_names
NSX_Config['TZ'].append(Dict_TZ)
# Create line
XLS_Lines.append([
tz.display_name, tz.description, tz.id, tz.resource_type,
tz.host_switch_id, tz.host_switch_mode, tz.host_switch_name,
tz.is_default, tz.nested_nsx, tz.transport_type, TZ_Teaming
])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
def SheetSecPol(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['Policies'] = []
Dict_Policies = {}
# connection to NSX
SessionNSX = ConnectNSX(auth_list)
policies_json = GetAPI(
SessionNSX[0],
'/policy/api/v1/infra/domains/default/security-policies', auth_list)
# Header of Excel and initialization of lines
XLS_Lines = []
TN_HEADER_ROW = ('Security Policy ID', 'Security Policy Name',
'NSX Policy Path', 'Sequence Number', 'Category',
'is Stateful')
if isinstance(
policies_json, dict
) and 'results' in policies_json and policies_json['result_count'] > 0:
for policy in policies_json["results"]:
Dict_Policies['id'] = policy['id']
Dict_Policies['name'] = policy['display_name']
Dict_Policies['path'] = policy['path']
Dict_Policies['sequence_number'] = policy['sequence_number']
Dict_Policies['category'] = policy['category']
Dict_Policies['stateful'] = policy['stateful']
NSX_Config['Policies'].append(Dict_Policies)
XLS_Lines.append([
policy['id'], policy['display_name'], policy['path'],
policy['sequence_number'], policy['category'],
policy['stateful']
])
else:
XLS_Lines.append(['No results', "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
def SheetT1Segments(auth_list,WORKBOOK,TN_WS,NSX_Config = {}):
NSX_Config['T1Segments'] = []
Dict_Segments = {}
# Connect to NSX
SessionNSX = ConnectNSX(auth_list)
t1_url = '/policy/api/v1/infra/tier-1s'
t1_json = GetAPI(SessionNSX[0],t1_url, auth_list)
XLS_Lines = []
TN_HEADER_ROW = ('Tier1 Segment Name', 'Tier1 Segment ID', 'Segment Gateway', 'Segment Network', 'Tier1 Router Name', 'Tier1 Router ID')
if isinstance(t1_json, dict) and 'results' in t1_json and t1_json['result_count'] > 0:
for i in t1_json["results"]:
t1_segment_url = '/policy/api/v1/search?query=resource_type:Segment&&dsl=segment where connectivity path=' + str(i['path']) + ''
t1_segment_json = GetAPI(SessionNSX[0],t1_segment_url, auth_list)
for n in t1_segment_json["results"]:
Dict_Segments['id'] = n['id']
Dict_Segments['name'] = n['display_name']
Dict_Segments['gw'] = n['subnets'][0]['gateway_address']
Dict_Segments['subnet'] = n['subnets'][0]['network']
Dict_Segments['router'] = i['display_name']
Dict_Segments['path'] = str(n['connectivity_path']).split("/")[3]
NSX_Config['T1Segments'].append(Dict_Segments)
XLS_Lines.append([n['display_name'], n['id'], n['subnets'][0]['gateway_address'], n['subnets'][0]['network'], i['display_name'], str(n['connectivity_path']).split("/")[3]])
else:
XLS_Lines.append(["no result", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV,TN_HEADER_ROW,XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK,TN_WS.title,TN_HEADER_ROW,XLS_Lines,"0072BA")
def SheetSecDFW(auth_list,WORKBOOK,TN_WS, NSX_Config = {}):
NSX_Config['DFW'] = []
# connection to NSX
SessionNSX = ConnectNSX(auth_list)
policies_json = GetAPI(SessionNSX[0],'/policy/api/v1/infra/domains/default/security-policies', auth_list)
# Get all groups - to get display name
domain_id = 'default'
# Connection for get Groups criteria - REST/API
groups_json = GetAPI(SessionNSX[0],'/policy/api/v1/infra/domains/' + domain_id + '/groups', auth_list)
# Get All Services
services_json = GetAPI(SessionNSX[0],'/policy/api/v1/infra/services', auth_list)
# Get all Contewxt Profile
context_json = GetAPI(SessionNSX[0],'/policy/api/v1/infra/context-profiles', auth_list)
# Header of Excel and initialization of lines
XLS_Lines = []
TN_HEADER_ROW = ('Security Policy', 'Security Policy Applied to', 'Category','Rule Name', 'Rule ID','Source', 'Destination', 'Services', 'Profiles', 'Rule Applied to', 'Action', 'Direction', 'Disabled', 'IP Protocol', 'Logged')
if isinstance(policies_json, dict) and 'results' in policies_json:
for policy in policies_json["results"]:
# Check Applied to for policies
scopelist= GetListNameFromPath(policy['scope'], groups_json)
#### Get RULES ####
domain_id = 'default'
rules_url = '/policy/api/v1/infra/domains/' + domain_id + '/security-policies/' + policy['id'] + '/rules/'
rules_json = GetAPI(SessionNSX[0],rules_url, auth_list)
PrintRulesbyCategory(rules_json, groups_json, services_json, context_json, policy['display_name'],policy['id'],policy['category'], scopelist, XLS_Lines, NSX_Config)
else:
XLS_Lines.append(['No results', "", "", "", "", "", "", "", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV,TN_HEADER_ROW,XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK,TN_WS.title,TN_HEADER_ROW,XLS_Lines,"0072BA")
def SheetSecDFW(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['DFW'] = []
# connection to NSX
SessionNSX = ConnectNSX(auth_list)
policies_json = GetAPI(
SessionNSX[0],
'/policy/api/v1/infra/domains/default/security-policies', auth_list)
stub_config = StubConfigurationFactory.new_std_configuration(SessionNSX[1])
rules_svc = Rules(stub_config)
# Header of Excel and initialization of lines
XLS_Lines = []
TN_HEADER_ROW = ('Security Policy', 'Security Policy Applied to',
'Category', 'Rule Name', 'Rule ID', 'Source',
'Destination', 'Services', 'Profiles', 'Rule Applied to',
'Action', 'Direction', 'Disabled', 'IP Protocol',
'Logged')
if isinstance(policies_json, dict) and 'results' in policies_json:
for policy in policies_json["results"]:
# Check Applied to for policies
scopelist = GetListNameFromPath(policy['scope'])
#### Get RULES ####
PrintRulesbyCategory(rules_svc, policy['display_name'],
policy['id'], policy['category'], scopelist,
XLS_Lines, NSX_Config)
else:
XLS_Lines.append(
['No results', "", "", "", "", "", "", "", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
def SheetTZ(auth_list,WORKBOOK,TN_WS, NSX_Config ={} ):
NSX_Config['TZ'] = []
# Connect NSX
SessionNSX = ConnectNSX(auth_list)
transport_zone_url = '/api/v1/transport-zones'
transport_zone_json = GetAPI(SessionNSX[0],transport_zone_url, auth_list)
XLS_Lines = []
TN_HEADER_ROW = ('Name', 'ID', 'Ressource Type', 'Host Switch ID', 'Host Switch Mode', 'Host Switch Name', 'Host Switch is Default', 'is Nested NSX', 'Transport Type')
if isinstance(transport_zone_json, dict) and 'results' in transport_zone_json and transport_zone_json['result_count'] > 0:
for TZ in transport_zone_json['results']:
Dict_TZ = {}
Dict_TZ['name'] = TZ['display_name']
Dict_TZ['id'] = TZ['id']
Dict_TZ['resource_type'] = TZ['resource_type']
Dict_TZ['host_swithc_id'] = TZ['host_switch_id']
Dict_TZ['host_switch_mode'] = TZ['host_switch_mode']
Dict_TZ['host_switch_name'] = TZ['host_switch_name']
Dict_TZ['is_default'] = TZ['is_default']
Dict_TZ['nested'] = TZ['nested_nsx']
Dict_TZ['type'] = TZ['transport_type']
NSX_Config['TZ'].append(Dict_TZ)
# Create line
XLS_Lines.append([TZ['display_name'], TZ['id'], TZ['resource_type'], TZ['host_switch_id'], TZ['host_switch_mode'], TZ['host_switch_name'], TZ['is_default'], TZ['nested_nsx'], TZ['transport_type']])
else:
XLS_Lines.append(['no Transport Zones', '', '', '', '', '', '', '', ''])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV,TN_HEADER_ROW,XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK,TN_WS.title,TN_HEADER_ROW,XLS_Lines,"0072BA")
def DocsSetOne(auth_list):
if GetOutputFormat() == 'CSV':
print(
style.RED +
" ==> Invalid: CSV output incompatible with single file documentation set "
+ style.NORMAL)
return
global NSX_Config
NSX_Config = {}
start_time = time.time()
WORKBOOK = CreateXLSFile(auth_list, 'Audit_NSX')
if WORKBOOK != None:
if GetOutputFormat() == 'JSON' or GetOutputFormat() == 'YAML':
TN_WS = WORKBOOK[1].active
print('\nGenerating Summary sheet')
SheetSummary(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('\nGenerating NSX-T Manager Information sheet')
SheetNSXManagerInfo(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Fabric Discovered Nodes sheet')
SheetFabDiscoveredNodes(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Transport Zones sheet')
SheetTZ(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Services sheet')
SheetNSXServices(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T TEP Tunnels sheet')
SheetTunnels(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Segments sheet')
SheetSegments(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router Summary sheet')
SheetRouterSum(auth_list, WORKBOOK[0], TN_WS)
print('Generating NSX-T Router Ports sheet')
SheetRouterPorts(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router T1 Segments sheet')
SheetT1Segments(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router T0 BGP Sessions sheet')
SheetBGPSession(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router T0 Routing Tables sheet')
SheetT0RoutingTable(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router T1 Forwarding Tables sheet')
SheetT1ForwardingTable(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Groups sheet')
SheetSecGrp(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Security Policies sheet')
SheetSecPol(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Security DFW sheet')
SheetSecDFW(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Alarms sheet')
SheetAlarms(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print("\nDocumentation set took %s seconds to complete\n" %
(time.time() - start_time))
WORKBOOK[1].close()
else:
TN_WS = WORKBOOK[0].active
TN_WS.title = "Summary"
print('\nGenerating Summary sheet')
SheetSummary(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('\nGenerating NSX-T Manager Information sheet')
TN_WS = WORKBOOK[0].create_sheet("NSX_Manager_Info")
SheetNSXManagerInfo(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Fabric Discovered Nodes sheet')
TN_WS = WORKBOOK[0].create_sheet("Transport_Nodes")
SheetFabDiscoveredNodes(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Transport Zones sheet')
TN_WS = WORKBOOK[0].create_sheet("Transport_Zones")
SheetTZ(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Services sheet')
TN_WS = WORKBOOK[0].create_sheet("Services")
SheetNSXServices(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T TEP Tunnels sheet')
TN_WS = WORKBOOK[0].create_sheet("Transport_Node_Tunnels")
SheetTunnels(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Segments sheet')
TN_WS = WORKBOOK[0].create_sheet("Segments")
SheetSegments(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router Summary sheet')
TN_WS = WORKBOOK[0].create_sheet("Logical_Router_Summary")
SheetRouterSum(auth_list, WORKBOOK[0], TN_WS)
print('Generating NSX-T Router Ports sheet')
TN_WS = WORKBOOK[0].create_sheet("Logical_Router_Ports")
SheetRouterPorts(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router T1 Segments sheet')
TN_WS = WORKBOOK[0].create_sheet("Tier1_Segments")
SheetT1Segments(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router T0 BGP Sessions sheet')
TN_WS = WORKBOOK[0].create_sheet("Tier0_BGP_Sessions")
SheetBGPSession(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router T0 Routing Tables sheet')
TN_WS = WORKBOOK[0].create_sheet("Tier0_Routing_Tables")
SheetT0RoutingTable(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Router T1 Forwarding Tables sheet')
TN_WS = WORKBOOK[0].create_sheet("Tier1_Forwarding_Tables")
SheetT1ForwardingTable(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Groups sheet')
TN_WS = WORKBOOK[0].create_sheet("Security_Groups")
SheetSecGrp(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Security Policies sheet')
TN_WS = WORKBOOK[0].create_sheet("Security_Policies")
SheetSecPol(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Security DFW sheet')
TN_WS = WORKBOOK[0].create_sheet("Rules_Distributed_Firewall")
SheetSecDFW(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print('Generating NSX-T Alarms sheet')
TN_WS = WORKBOOK[0].create_sheet("Alarms")
SheetAlarms(auth_list, WORKBOOK[0], TN_WS, NSX_Config)
print("\nDocumentation set took %s seconds to complete\n" %
(time.time() - start_time))
WORKBOOK[0].save(WORKBOOK[1])
def SheetFabDiscoveredNodes(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
Dict_DiscoveredNodes = {} # Dict Discovered nodes initialization
NSX_Config['DiscoveredNodes'] = []
# Connect to NSX
SessionNSX = ConnectNSX(auth_list)
discovered_nodes_url = '/api/v1/fabric/discovered-nodes'
discovered_nodes_json = GetAPI(SessionNSX[0], discovered_nodes_url,
auth_list)
# Construct Line
TN_HEADER_ROW = ('Display name', 'OS Type', 'OS Version', 'Node Type',
'Hostname', 'Full Name', 'Management IP', 'Domain name',
'DNS', 'UUID', 'Powerstate', 'In Maintenance Mode',
'Build', 'Vendor', 'Model', 'Serial Number',
'Connection State', 'Licensed Product Name',
'Licensed Product Version', 'Mgmt Server IP',
'Lockdown Mode', 'DAS Host State')
XLS_Lines = []
# Check if Discovered Nodes present
if isinstance(
discovered_nodes_json, dict
) and 'results' in discovered_nodes_json and discovered_nodes_json[
'result_count'] > 0:
for node in discovered_nodes_json['results']:
Dict_Properties = {}
# Loop in properties
for propertie in node['origin_properties']:
if propertie['key'] == 'hostName':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'fullName':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'managementIp':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'domainName':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'dnsConfigAddress':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'uuid':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'powerState':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'inMaintenanceMode':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'build':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'vendor':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'model':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'serialNumber':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'connectionState':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'licenseProductName':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'licenseProductVersion':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'managementServerIp':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'lockdownMode':
Dict_Properties[propertie['key']] = propertie['value']
if propertie['key'] == 'dasHostState':
Dict_Properties[propertie['key']] = propertie['value']
# Fill Discovered Nodes Dict
Dict_DiscoveredNodes['node_name'] = node['display_name']
Dict_DiscoveredNodes['event_type'] = node['os_type']
Dict_DiscoveredNodes['node_name'] = node['os_version']
Dict_DiscoveredNodes['node_resource_type'] = node['node_type']
Dict_DiscoveredNodes['hostName'] = Dict_Properties['hostName']
Dict_DiscoveredNodes['fullName'] = Dict_Properties['fullName']
Dict_DiscoveredNodes['managementIp'] = Dict_Properties[
'managementIp']
try:
Dict_DiscoveredNodes['domainName'] = Dict_Properties[
'domainName']
except:
Dict_Properties['domainName'] = 'No Domain Name'
Dict_DiscoveredNodes['dnsConfigAddress'] = Dict_Properties[
'dnsConfigAddress']
Dict_DiscoveredNodes['uuid'] = Dict_Properties['uuid']
Dict_DiscoveredNodes['powerState'] = Dict_Properties['powerState']
Dict_DiscoveredNodes['inMaintenanceMode'] = Dict_Properties[
'inMaintenanceMode']
Dict_DiscoveredNodes['build'] = Dict_Properties['build']
Dict_DiscoveredNodes['vendor'] = Dict_Properties['vendor']
Dict_DiscoveredNodes['model'] = Dict_Properties['model']
Dict_DiscoveredNodes['serialNumber'] = Dict_Properties[
'serialNumber']
Dict_DiscoveredNodes['connectionState'] = Dict_Properties[
'connectionState']
Dict_DiscoveredNodes['licenseProductName'] = Dict_Properties[
'licenseProductName']
Dict_DiscoveredNodes['licenseProductVersion'] = Dict_Properties[
'licenseProductVersion']
Dict_DiscoveredNodes['managementServerIp'] = Dict_Properties[
'managementServerIp']
Dict_DiscoveredNodes['lockdownMode'] = Dict_Properties[
'lockdownMode']
Dict_DiscoveredNodes['dasHostState'] = Dict_Properties[
'dasHostState']
NSX_Config['DiscoveredNodes'].append(Dict_DiscoveredNodes)
# write one line for a node
XLS_Lines.append([
node['display_name'], node['os_type'], node['os_version'],
node['node_type'], Dict_Properties['hostName'],
Dict_Properties['fullName'], Dict_Properties['managementIp'],
Dict_Properties['domainName'],
Dict_Properties['dnsConfigAddress'], Dict_Properties['uuid'],
Dict_Properties['powerState'],
Dict_Properties['inMaintenanceMode'], Dict_Properties['build'],
Dict_Properties['vendor'], Dict_Properties['model'],
Dict_Properties['serialNumber'],
Dict_Properties['connectionState'],
Dict_Properties['licenseProductName'],
Dict_Properties['licenseProductVersion'],
Dict_Properties['managementServerIp'],
Dict_Properties['lockdownMode'],
Dict_Properties['dasHostState']
])
else:
XLS_Lines.append([
'No result', '', '', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', ''
])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
ConditionnalFormat(TN_WS, 'K2:K' + str(len(XLS_Lines) + 1),
'poweredOn')
ConditionnalFormat(TN_WS, 'L2:L' + str(len(XLS_Lines) + 1), 'false')
ConditionnalFormat(TN_WS, 'Q2:Q' + str(len(XLS_Lines) + 1),
'connected')
def SheetBGPSession(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['T0Sessions'] = []
Dict_Sessions = {}
SessionNSX = ConnectNSX(auth_list)
########### GET Tier-0 Gateways ###########
t0_url = '/policy/api/v1/infra/tier-0s'
t0_json = GetAPI(SessionNSX[0], t0_url, auth_list)
XLS_Lines = []
TN_HEADER_ROW = ('T0', 'BGP status', 'ECMP', 'Inter-SR',
'Source IP address', 'Local AS', 'Neighbor IP address',
'Remote AS', 'Total IN Prefixes', 'Total OUT prefixes',
'Session Status')
if isinstance(
t0_json,
dict) and 'results' in t0_json and t0_json['result_count'] > 0:
for t0 in t0_json["results"]:
#localservice_url = "/policy/api/v1/infra/tier-0s/"+ t0['display_name'] +"/locale-services"
localservice = "default"
bgpstatus_url = "/policy/api/v1/infra/tier-0s/" + t0[
'display_name'] + "/locale-services/" + localservice + "/bgp/neighbors/status"
bgpconfig_url = "/policy/api/v1/infra/tier-0s/" + t0[
'display_name'] + "/locale-services/" + localservice + "/bgp"
#t0_localservice = GetAPI(SessionNSX[0],localservice_url, auth_list)
bgpstatus_json = GetAPI(SessionNSX[0], bgpstatus_url, auth_list)
bgpconfig_json = GetAPI(SessionNSX[0], bgpconfig_url, auth_list)
Dict_Sessions['T0_name'] = t0['display_name']
# BGP Sessions treatment
if isinstance(bgpstatus_json,
dict) and 'results' in bgpstatus_json:
Dict_Sessions['bgp_sessions'] = []
Dict_bgp_session = {}
if 'local_as_num' in bgpconfig_json:
Dict_bgp_session['local_as'] = str(
bgpconfig_json['local_as_num'])
else:
Dict_bgp_session['local_as'] = ""
if 'inter_sr_ibgp' in bgpconfig_json:
Dict_bgp_session['inter_sr_ibgp'] = str(
bgpconfig_json['inter_sr_ibgp']).upper()
else:
Dict_bgp_session['inter_sr_ibgp'] = ''
Dict_bgp_session['bgp_status'] = str(
bgpconfig_json['enabled']).upper()
Dict_bgp_session['ecmp'] = str(bgpconfig_json['ecmp']).upper()
for session in bgpstatus_json['results']:
Dict_bgp_session['source_ip'] = session['source_address']
Dict_bgp_session['remote_ip'] = session['neighbor_address']
Dict_bgp_session['remote_as'] = str(
session['remote_as_number'])
Dict_bgp_session['total_in'] = str(
session['total_in_prefix_count'])
Dict_bgp_session['total_out'] = str(
session['total_out_prefix_count'])
Dict_bgp_session['connection_state'] = session[
'connection_state']
Dict_Sessions['bgp_sessions'].append(Dict_bgp_session)
XLS_Lines.append([
Dict_Sessions['T0_name'],
Dict_bgp_session['bgp_status'],
Dict_bgp_session['ecmp'],
Dict_bgp_session['inter_sr_ibgp'],
Dict_bgp_session['source_ip'],
Dict_bgp_session['local_as'],
Dict_bgp_session['remote_ip'],
Dict_bgp_session['remote_as'],
Dict_bgp_session['total_in'],
Dict_bgp_session['total_out'],
Dict_bgp_session['connection_state']
])
elif not bgpstatus_json:
XLS_Lines.append([
t0['display_name'], "No BGP sessions", "", "", "", "", "",
"", "", "", ""
])
else:
XLS_Lines.append([
t0['display_name'], " No BGP sessions", "", "", "", "", "",
"", "", "", ""
])
NSX_Config['T0Sessions'].append(Dict_Sessions)
print(" --> Get BGP sessions for " + style.ORANGE +
t0['display_name'] + style.NORMAL)
else:
XLS_Lines.append(
["No T0 router found", "", "", "", "", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
ConditionnalFormat(TN_WS, 'K2:K' + str(len(XLS_Lines) + 1),
'ESTABLISHED')
ConditionnalFormat(TN_WS, 'B2:B' + str(len(XLS_Lines) + 1), 'TRUE')
def SheetRouterSum(auth_list,WORKBOOK,TN_WS, NSX_Config = {}):
if 'LR' not in NSX_Config:
NSX_Config['LR'] = []
Dict_LR = {}
SessionNSX = ConnectNSX(auth_list)
########### GET Logical Routers ###########
lr_list_url = '/api/v1/logical-routers'
lr_list_json = GetAPI(SessionNSX[0],lr_list_url, auth_list)
########### GET Edge Clusters ###########
edge_list_url = '/api/v1/edge-clusters'
edge_list_json = GetAPI(SessionNSX[0],edge_list_url, auth_list)
########### CREATE LIST OF TUPLES - EDGE-ID / EDGE NAME ###########
edge_list = []
if edge_list_json['result_count'] > 0:
for i in edge_list_json["results"]:
edge_list.append(tuple((i['id'],i['display_name'])))
XLS_Lines = []
TN_HEADER_ROW = ('Logical Router Name', 'Logical Router ID', 'Edge Cluster Name', 'Edge Custer ID', 'Logical Router Type', 'High Availability Mode', 'Enable Standby Relocation', 'Failover Mode')
if lr_list_json['result_count'] > 0:
for LR in lr_list_json['results']:
HA = ""
RELOC = ""
FAILOVER = ""
LRType = ""
EdgeClusterName = ""
LRID = ""
if 'edge_cluster_id' in LR:
LRID = LR['edge_cluster_id']
# Get Edge Cluster Name
for ec in edge_list:
if LR['edge_cluster_id'] == ec[0]:
EdgeClusterName = ec[1]
if 'router_type' in LR:
LRType = LR['router_type']
if 'high_availability_mode' in LR:
HA = LR['high_availability_mode']
if 'allocation_profile' in LR:
RELOC = LR['allocation_profile']['enable_standby_relocation']
if 'failover_mode' in LR:
FAILOVER = LR['failover_mode']
Dict_LR['name'] = LR['display_name']
Dict_LR['id'] = LR['id']
Dict_LR['edge_cluster_name'] = EdgeClusterName
Dict_LR['edge_cluster_id'] = LRID
Dict_LR['router_type'] = LRType
Dict_LR['failover_mode'] = FAILOVER
Dict_LR['ha_mode'] = HA
Dict_LR['relocation'] = RELOC
NSX_Config['LR'].append(Dict_LR)
XLS_Lines.append([LR['display_name'], LR['id'],EdgeClusterName, LRID, LRType, HA, RELOC, FAILOVER])
else:
XLS_Lines.append(['No results', "", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV,TN_HEADER_ROW,XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK,TN_WS.title,TN_HEADER_ROW,XLS_Lines,"0072BA")
def SheetT1ForwardingTable(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['T1ForwardingTable'] = []
Dict_T1 = {}
# Connect NSX
SessionNSX = ConnectNSX(auth_list)
########### GET Edge Clusters ###########
#edge_list_url = '/api/v1/search/query?query=resource_type:Edgenode'
#edge_list_json = GetAPI(SessionNSX[0],edge_list_url, auth_list)
########### GET Tier-1 Gateways ###########
t1_url = '/policy/api/v1/infra/tier-1s'
t1_json = GetAPI(SessionNSX[0], t1_url, auth_list)
########### CREATE LIST OF TUPLES - EDGE-ID / EDGE NAME ###########
#edge_list = []
#if edge_list_json["result_count"] > 0:
# for edge in edge_list_json["results"]:
# edge_list.append(tuple((edge['id'],edge['display_name'])))
t1_id_list = []
XLS_Lines = []
TN_HEADER_ROW = ('T1 Router', 'Edge Node Path', 'Edge ID', 'HA Status',
'Route Type', 'Network', 'Admin Distance', 'Next Hop',
'LR Component ID', 'LR Component Type')
if t1_json["result_count"] > 0:
for T1 in t1_json["results"]:
t1_id_list.append(T1['display_name'])
for T1 in t1_id_list:
forwardingURL = t1_url + '/' + str(T1) + '/forwarding-table'
# Get T1 State
t1_state_json = GetAPI(SessionNSX[0],
t1_url + '/' + str(T1) + '/state',
auth_list)
nb_routes = 0
EdgeID = None
HAStatus = None
if isinstance(t1_state_json,
dict) and 'tier1_status' in t1_state_json:
if 'per_node_status' in t1_state_json['tier1_status']:
for node in t1_state_json['tier1_status'][
'per_node_status']:
if node['high_availability_status'] != 'STANDBY':
EdgeID = node['transport_node_id']
HAStatus = node['high_availability_status']
forwardingURL = t1_url + '/' + str(
T1) + '/forwarding-table?edge_id=' + EdgeID
# Get T1 forwardoing table
t1_routingtable_json = GetAPI(SessionNSX[0], forwardingURL,
auth_list)
if isinstance(
t1_routingtable_json, dict
) and 'results' in t1_routingtable_json and t1_routingtable_json[
'result_count'] > 0:
for n in t1_routingtable_json["results"]:
# Get routes
nb_routes = len(n['route_entries'])
for entry in n['route_entries']:
Dict_T1['edge_name'] = n['edge_node']
Dict_T1['edge_id'] = EdgeID
Dict_T1['ha'] = HAStatus
Dict_T1['T0_name'] = T1
Dict_T1['route_type'] = entry['route_type']
Dict_T1['network'] = entry['network']
Dict_T1['ad'] = entry['admin_distance']
Dict_T1['next_hop'] = entry['next_hop']
Dict_T1['lr_id'] = entry['lr_component_id']
Dict_T1['lr_type'] = entry['lr_component_type']
NSX_Config['T1ForwardingTable'].append(Dict_T1)
XLS_Lines.append([
T1, n['edge_node'], EdgeID, HAStatus,
entry['route_type'], entry['network'],
entry['admin_distance'], entry['next_hop'],
entry['lr_component_id'],
entry['lr_component_type']
])
elif not t1_routingtable_json:
XLS_Lines.append([
T1, "No Forwarding table found", "", "", "", "", "", "",
"", ""
])
else:
XLS_Lines.append([
T1, "T1 not deployed on Edge Cluster. DR Only", "", "", "",
"", "", "", "", ""
])
print(" --> Get forwarding tables of " + style.ORANGE + T1 +
style.NORMAL + " Router: " + style.ORANGE + str(nb_routes) +
style.NORMAL + " route(s)")
else:
XLS_Lines.append(
["No Forwarding table found", "", "", "", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
def SheetFabDiscoveredNodes(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
SessionNSX = ConnectNSX(auth_list)
stub_config = StubConfigurationFactory.new_std_configuration(SessionNSX[1])
disc_node_list = DiscoveredNodes(stub_config).list()
Dict_DiscoveredNodes = {} # Dict Discovered nodes initialization
NSX_Config['DiscoveredNodes'] = []
# Construct Line
XLS_Lines = []
if disc_node_list.result_count > 0:
TN_HEADER_ROW = ('Display name', 'OS Type', 'OS Version', 'Node Type',
'Hostname', 'Full Name', 'Management IP',
'Domain name', 'DNS', 'UUID', 'Powerstate',
'In Maintenance Mode', 'Build', 'Vendor', 'Model',
'Serial Number', 'Connection State',
'Licensed Product Name', 'Licensed Product Version',
'Mgmt Server IP', 'Lockdown Mode', 'DAS Host State')
for node in disc_node_list.results:
Dict_Properties = {}
# Loop in properties
for propertie in node.origin_properties:
if propertie.key == 'hostName':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'fullName':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'managementIp':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'domainName':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'dnsConfigAddress':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'uuid':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'powerState':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'inMaintenanceMode':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'build':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'vendor':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'model':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'serialNumber':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'connectionState':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'licenseProductName':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'licenseProductVersion':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'managementServerIp':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'lockdownMode':
Dict_Properties[propertie.key] = propertie.value
if propertie.key == 'dasHostState':
Dict_Properties[propertie.key] = propertie.value
# Fill Discovered Nodes Dict
Dict_DiscoveredNodes['node_name'] = node.display_name
Dict_DiscoveredNodes['event_type'] = node.os_type
Dict_DiscoveredNodes['node_name'] = node.os_version
Dict_DiscoveredNodes['node_resource_type'] = node.node_type
Dict_DiscoveredNodes['hostName'] = Dict_Properties['hostName']
Dict_DiscoveredNodes['fullName'] = Dict_Properties['fullName']
Dict_DiscoveredNodes['managementIp'] = Dict_Properties[
'managementIp']
try:
Dict_DiscoveredNodes['domainName'] = Dict_Properties[
'domainName']
except:
Dict_Properties['domainName'] = 'No Domain Name'
Dict_DiscoveredNodes['dnsConfigAddress'] = Dict_Properties[
'dnsConfigAddress']
Dict_DiscoveredNodes['uuid'] = Dict_Properties['uuid']
Dict_DiscoveredNodes['powerState'] = Dict_Properties['powerState']
Dict_DiscoveredNodes['inMaintenanceMode'] = Dict_Properties[
'inMaintenanceMode']
Dict_DiscoveredNodes['build'] = Dict_Properties['build']
Dict_DiscoveredNodes['vendor'] = Dict_Properties['vendor']
Dict_DiscoveredNodes['model'] = Dict_Properties['model']
Dict_DiscoveredNodes['serialNumber'] = Dict_Properties[
'serialNumber']
Dict_DiscoveredNodes['connectionState'] = Dict_Properties[
'connectionState']
Dict_DiscoveredNodes['licenseProductName'] = Dict_Properties[
'licenseProductName']
Dict_DiscoveredNodes['licenseProductVersion'] = Dict_Properties[
'licenseProductVersion']
Dict_DiscoveredNodes['managementServerIp'] = Dict_Properties[
'managementServerIp']
Dict_DiscoveredNodes['lockdownMode'] = Dict_Properties[
'lockdownMode']
Dict_DiscoveredNodes['dasHostState'] = Dict_Properties[
'dasHostState']
NSX_Config['DiscoveredNodes'].append(Dict_DiscoveredNodes)
# write one line for a node
XLS_Lines.append([
node.display_name, node.os_type, node.os_version,
node.node_type, Dict_Properties['hostName'],
Dict_Properties['fullName'], Dict_Properties['managementIp'],
Dict_Properties['domainName'],
Dict_Properties['dnsConfigAddress'], Dict_Properties['uuid'],
Dict_Properties['powerState'],
Dict_Properties['inMaintenanceMode'], Dict_Properties['build'],
Dict_Properties['vendor'], Dict_Properties['model'],
Dict_Properties['serialNumber'],
Dict_Properties['connectionState'],
Dict_Properties['licenseProductName'],
Dict_Properties['licenseProductVersion'],
Dict_Properties['managementServerIp'],
Dict_Properties['lockdownMode'],
Dict_Properties['dasHostState']
])
else:
XLS_Lines = ('No result', '', '', '', '', '', '', '', '', '', '', '',
'', '', '', '', '', '', '', '', '', '')
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
ConditionnalFormat(TN_WS, 'K2:K' + str(len(XLS_Lines) + 1),
'poweredOn')
ConditionnalFormat(TN_WS, 'L2:L' + str(len(XLS_Lines) + 1), 'false')
ConditionnalFormat(TN_WS, 'Q2:Q' + str(len(XLS_Lines) + 1),
'connected')
def SheetNSXServices(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['Services'] = []
Dict_Services = {}
# Connection to NSX
SessionNSX = ConnectNSX(auth_list)
services_url = '/policy/api/v1/infra/services'
services_json = GetAPI(SessionNSX[0], services_url, auth_list)
XLS_Lines = []
TN_HEADER_ROW = ('Services Name', 'Services Entries', 'Service Type',
'Port # / Additionnal Properties', 'Tags', 'Scope')
if services_json['result_count'] > 0:
for SR in services_json['results']:
TAGS = ""
SCOPE = ""
if 'tags' in SR:
tag_list = []
scope_list = []
for tag in SR['tags']:
tag_list.append(tag['tag'])
scope_list.append(tag['scope'])
TAGS = ", ".join(tag_list)
SCOPE = ", ".join(scope_list)
List_SR = []
List_Proto = []
List_Ports = []
for svc in SR['service_entries']:
List_SR.append(svc['display_name'])
if 'l4_protocol' in svc:
List_Proto.append(svc['l4_protocol'])
Ports = ", ".join(svc['destination_ports'])
List_Ports.append(Ports)
elif 'protocol' in svc:
List_Proto.append(svc['protocol'])
if "icmp_type" in svc:
List_Ports.append(str(svc['icmp_type']))
elif "alg" in svc:
List_Proto.append(svc['alg'])
Ports = ", ".join(svc['destination_ports'])
List_Ports.append(Ports)
elif "protocol_number" in svc:
List_Proto.append(svc['protocol_number'])
elif "ether_type" in svc:
List_Proto.append(svc['ether_type'])
else:
List_Proto.append('IGMP')
Proto = "\n".join(List_Proto)
svc_ports = "\n".join(List_Ports)
Dict_Services['name'] = SR['display_name']
Dict_Services['tags'] = TAGS
Dict_Services['scope'] = SCOPE
Dict_Services['ports'] = List_Ports
Dict_Services['protocols'] = List_Proto
Dict_Services['services_entries'] = List_SR
NSX_Config['Services'].append(Dict_Services)
# Create Line
XLS_Lines.append([
SR['display_name'], "\n".join(List_SR), Proto, svc_ports, TAGS,
SCOPE
])
else:
XLS_Lines.append(['No results', "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
def SheetT0RoutingTable(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['T0RoutingTable'] = []
Dict_T0 = {}
SessionNSX = ConnectNSX(auth_list)
########### GET Tier-0 Gateways ###########
t0_url = '/policy/api/v1/infra/tier-0s'
t0_json = GetAPI(SessionNSX[0], t0_url, auth_list)
t0_id_list = []
for i in t0_json["results"]:
t0_id_list.append(i['display_name'])
XLS_Lines = []
TN_HEADER_ROW = ('T0', 'Edge Node Path', 'Route Type', 'Network',
'Admin Distance', 'Next Hop', 'LR Component ID',
'LR Component Type')
for T0 in t0_id_list:
nb_routes = 0
t0_routingtable_json = GetAPI(
SessionNSX[0], t0_url + '/' + str(T0) + '/routing-table',
auth_list)
if isinstance(
t0_routingtable_json, dict
) and 'results' in t0_routingtable_json and t0_routingtable_json[
'result_count'] > 0:
for n in t0_routingtable_json["results"]:
nb_routes = len(n["route_entries"])
# get routes
for entry in n['route_entries']:
Dict_T0['edge'] = n['edge_node']
Dict_T0['T0_name'] = T0
Dict_T0['route_type'] = entry['route_type']
Dict_T0['network'] = entry['network']
Dict_T0['ad'] = entry['admin_distance']
Dict_T0['next_hop'] = entry['next_hop']
Dict_T0['lr_id'] = entry['lr_component_id']
Dict_T0['lr_type'] = entry['lr_component_type']
NSX_Config['T0RoutingTable'].append(Dict_T0)
XLS_Lines.append([
T0, n['edge_node'], entry['route_type'],
entry['network'], entry['admin_distance'],
entry['next_hop'], entry['lr_component_id'],
entry['lr_component_type']
])
elif not t0_routingtable_json:
XLS_Lines.append(
[T0, "No Routing table found", "", "", "", "", "", ""])
else:
XLS_Lines.append([
T0, " T1 not deployed on Edge Cluster. DR Only", "", "", "",
"", "", ""
])
print(" --> Get forwarding tables of " + style.ORANGE + T0 +
style.NORMAL + " Router: " + style.ORANGE + str(nb_routes) +
style.NORMAL + " route(s)")
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
def SheetSecGrp(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
NSX_Config['Groups'] = []
Dict_Groups = {}
domain_id = 'default'
# Connection for get Groups criteria - REST/API
Groups_list_url = '/policy/api/v1/infra/domains/' + domain_id + '/groups'
SessionNSX = ConnectNSX(auth_list)
Groups_list_json = GetAPI(SessionNSX[0], Groups_list_url, auth_list)
XLS_Lines = []
TN_HEADER_ROW = ('Group Name', 'Tags', 'Scope', 'Criteria Type',
'Criteria', 'IP addresses', 'Virtual Machines',
'Segments', 'Segments Ports')
if isinstance(Groups_list_json,
dict) and 'results' in Groups_list_json and Groups_list_json[
'result_count'] > 0:
count = 1
for group in Groups_list_json['results']:
print(
str(count) + " - Treating NS group: " + style.ORANGE +
group['display_name'] + style.NORMAL)
count += 1
# Get Tag and scope
List_Tag = []
List_Scope = []
# Check if tag is in a group
if "tags" in group:
for tag in group['tags']:
List_Tag.append(tag['tag'])
List_Scope.append(tag['scope'])
Tags = ','.join(List_Tag)
Scope = ','.join(List_Scope)
else:
Tags = ""
Scope = ""
#Criteria Treatment
if group['expression'] == []:
print('skipping group without expression')
continue
for nbcriteria in group['expression']:
criteria = GetCriteria(SessionNSX[0], auth_list, nbcriteria)
# Create IP Address List for each group
IPs_url = '/policy/api/v1/infra/domains/' + domain_id + '/groups/' + group[
'id'] + '/members/ip-addresses'
IPs_json = GetAPI(SessionNSX[0], IPs_url, auth_list)
IP = ""
if isinstance(
IPs_json, dict
) and 'results' in IPs_json and 'result_count' in IPs_json and IPs_json[
'result_count'] > 0:
IP = ', '.join(IPs_json['results'])
# Create Virtual Machine List for each group
VMs_url = '/policy/api/v1/infra/domains/' + domain_id + '/groups/' + group[
'id'] + '/members/virtual-machines'
VMs_json = GetAPI(SessionNSX[0], VMs_url, auth_list)
VM = ""
VMList = []
if isinstance(
VMs_json, dict
) and 'results' in VMs_json and 'result_count' in VMs_json and VMs_json[
'result_count'] > 0:
for vm in VMs_json['results']:
VMList.append(vm['display_name'])
VM = ', '.join(VMList)
# Create Segment List for each group
Segs_url = '/policy/api/v1/infra/domains/' + domain_id + '/groups/' + group[
'id'] + '/members/segments'
Segs_json = GetAPI(SessionNSX[0], Segs_url, auth_list)
Segment = ""
SegList = []
if isinstance(
Segs_json, dict
) and 'results' in Segs_json and 'result_count' in Segs_json and Segs_json[
'result_count'] > 0:
for seg in Segs_json['results']:
SegList.append(seg['display_name'])
Segment = ', '.join(SegList)
# Create Segment Port/vNIC List for each group
Seg_Ports_url = '/policy/api/v1/infra/domains/' + domain_id + '/groups/' + group[
'id'] + '/members/segment-ports'
Seg_Ports_json = GetAPI(SessionNSX[0], Seg_Ports_url, auth_list)
SegPort = ""
SegPortList = []
if isinstance(
Seg_Ports_json, dict
) and 'results' in Seg_Ports_json and 'result_count' in Seg_Ports_json and Seg_Ports_json[
'result_count'] > 0:
for segport in Seg_Ports_json['results']:
SegPortList.append(segport['display_name'])
SegPort = ', '.join(SegPortList)
Dict_Groups['name'] = group['display_name']
Dict_Groups['tags'] = List_Tag
Dict_Groups['scope'] = List_Scope
Dict_Groups['type_crtieria'] = criteria[1]
Dict_Groups['criteria'] = criteria[0]
Dict_Groups['ip'] = IP
Dict_Groups['vm'] = VMList
Dict_Groups['segment'] = SegList
Dict_Groups['segment_port'] = SegPortList
NSX_Config['Groups'].append(Dict_Groups)
XLS_Lines.append([
group['display_name'], Tags, Scope, '\n'.join(criteria[1]),
criteria[0], IP, VM, Segment, SegPort
])
else:
XLS_Lines.append(['No results', "", "", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
def SheetAlarms(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
Dict_Alarm = {} # Dict alarm initialization
NSX_Config['Alarms'] = []
# Connect NSX
SessionNSX = ConnectNSX(auth_list)
TN_json = GetAPI(SessionNSX[0], '/api/v1/transport-nodes', auth_list)
Edge_json = GetAPI(SessionNSX[0], '/api/v1/cluster/nodes', auth_list)
stub_config = StubConfigurationFactory.new_std_configuration(SessionNSX[1])
node_dict = {}
# Construct Dicts of Edge Node and Transport Node for Name from ID
if TN_json['result_count'] > 0:
for TN in TN_json['results']:
node_dict.update({TN["id"]: TN["display_name"]})
if Edge_json['result_count'] > 0:
for EDGE in Edge_json['results']:
node_dict.update({EDGE["id"]: EDGE["display_name"]})
# Alarms extract
alarms_svc = Alarms(stub_config)
alarms_list = alarms_svc.list()
NodeName = ""
XLS_Lines = []
TN_HEADER_ROW = ('Feature', 'Event Type', 'Reporting Node',
'Node Ressource Type', 'Entity Name', 'Severity',
'Last Reported Time', 'Status', 'Description',
'Recommended Action')
if alarms_list.result_count > 0:
for alarm in alarms_list.results:
# Get Name of Node from ID
for key, value in node_dict.items():
if key == alarm.entity_id: NodeName = value
# Transform date and time of alarms
dtt = datetime.datetime.fromtimestamp(
float(alarm.last_reported_time /
1000)).strftime('%Y-%m-%d %H:%M:%S')
# Create line
XLS_Lines.append([
alarm.feature_name, alarm.event_type, NodeName,
alarm.node_resource_type, alarm.entity_id, alarm.severity, dtt,
alarm.status, alarm.description, alarm.recommended_action
])
# Fill alarm Dict
Dict_Alarm['feature_name'] = alarm.feature_name
Dict_Alarm['event_type'] = alarm.event_type
Dict_Alarm['node_name'] = NodeName
Dict_Alarm['node_resource_type'] = alarm.node_resource_type
Dict_Alarm['entity_id'] = alarm.entity_id
Dict_Alarm['severity'] = alarm.severity
Dict_Alarm['time'] = dtt
Dict_Alarm['status'] = alarm.status
Dict_Alarm['description'] = alarm.description
Dict_Alarm['recommended_action'] = alarm.recommended_action
NSX_Config['Alarms'].append(Dict_Alarm)
else:
XLS_Lines.append(['No results', "", "", "", "", "", "", "", "", ""])
# Create sheet
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
ConditionnalFormat(TN_WS, 'F', 'CRITICAL', True, 'RED')
ConditionnalFormat(TN_WS, 'F', 'HIGH', True, 'ORANGE')
ConditionnalFormat(TN_WS, 'H', 'RESOLVED', True, 'GREEN')
def SheetNSXManagerInfo(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
Dict_NSXManager = {} # Dict NSXManager initialization
NSX_Config['NSXManager'] = Dict_NSXManager
SessionNSX = ConnectNSX(auth_list)
########### SECTION FOR REPORTING ON NSX-T MANAGER CLUSTER ###########
nsxclstr_url = '/api/v1/cluster/status'
nsxclstr_json = GetAPI(SessionNSX[0], nsxclstr_url, auth_list)
# Check online and offline nodes
if 'online_nodes' in nsxclstr_json['mgmt_cluster_status']:
online_nodes = str(
len(nsxclstr_json['mgmt_cluster_status']['online_nodes']))
else:
online_nodes = "0"
if 'offline_nodes' in nsxclstr_json['mgmt_cluster_status']:
offline_nodes = str(
len(nsxclstr_json['mgmt_cluster_status']['offline_nodes']))
else:
offline_nodes = "0"
# check Version NSX-T
nsx_version = GetVersion(auth_list)
NSX_Config['NSXManager']['Cluster_id'] = nsxclstr_json['cluster_id']
NSX_Config['NSXManager']['Cluster_status'] = nsxclstr_json[
'mgmt_cluster_status']['status']
NSX_Config['NSXManager']['Cluster_ctrl_status'] = nsxclstr_json[
'control_cluster_status']['status']
NSX_Config['NSXManager']['Cluster_overall_status'] = nsxclstr_json[
'detailed_cluster_status']['overall_status']
NSX_Config['NSXManager']['Cluster_online_nodes'] = online_nodes
NSX_Config['NSXManager']['Cluster_offline_nodes'] = offline_nodes
# Summary Table
XLS_Lines = [['NSX-T Cluster ID', nsxclstr_json['cluster_id']],
['NSX-T version', nsx_version],
[
'NSX-T Cluster Status',
nsxclstr_json['mgmt_cluster_status']['status']
],
[
'NSX-T Control Cluster Status',
nsxclstr_json['control_cluster_status']['status']
],
[
'Overall NSX-T Cluster Status',
nsxclstr_json['detailed_cluster_status']['overall_status']
], ['Number of online nodes', online_nodes],
['Number of offline nodes', offline_nodes]]
idx_second_sheet = len(XLS_Lines) + 2
# Write in Excel
for line in XLS_Lines:
TN_WS.append(line)
# Format 1st Sheet
for i in range(1, len(XLS_Lines) + 1):
TN_WS.cell(row=i,
column=1).fill = PatternFill('solid',
start_color='004F81BD',
end_color='004F81BD') #Blue
TN_WS.cell(row=i, column=1).font = Font(b=True,
color="00FFFFFF") #White
ConditionnalFormat(TN_WS, 'B3:B5', 'STABLE')
ConditionnalFormat(TN_WS, 'B6:B6', '3')
ConditionnalFormat(TN_WS, 'B7:B7', '0')
# Create second sheet
TN_WS[idx_second_sheet]
XLS_Lines = []
TN_HEADER_ROW = ('Group ID', 'Group Type', 'Group Status', 'Member FQDN',
'Member IP address', 'Member UUID', 'Member Status')
for group in nsxclstr_json['detailed_cluster_status']['groups']:
for member in group['members']:
XLS_Lines.append([
group['group_id'], group['group_type'], group['group_status'],
member['member_fqdn'], member['member_ip'],
member['member_uuid'], member['member_status']
])
startCell = "A" + str(idx_second_sheet + 1)
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA",
"TableStyleLight9", False, startCell)
ConditionnalFormat(TN_WS, 'G11:G' + str(len(XLS_Lines) + 1), 'UP')
ConditionnalFormat(TN_WS, 'C11:C' + str(len(XLS_Lines) + 1), 'STABLE')
def CreateXLSFile(auth_list, XLS_Files, SheetFunction=None):
# Creation of CSV files
if GetOutputFormat() == 'CSV':
now = datetime.datetime.now()
DateString = now.strftime("%Y%m%d")
OUTPUT_CSV = lib.menu.XLS_Dest + os.sep + XLS_Files + "_" + DateString + ".csv"
fname = pathlib.Path(OUTPUT_CSV)
if fname.exists():
print(
str(fname) + style.RED +
'\n==> File already exists. Not attempting to overwite' +
style.NORMAL + "\n")
return None
print('\nGenerating NSX-T Manager output: ' + style.ORANGE +
XLS_Files + "_" + DateString + ".csv" + style.NORMAL + '\n')
with open(OUTPUT_CSV, 'w', newline="") as file:
WORKBOOK = Workbook()
if SheetFunction != None:
TN_WS = WORKBOOK.active
SheetFunction(auth_list, csv.writer(file), TN_WS)
return [csv.writer(file), OUTPUT_CSV]
elif GetOutputFormat() == 'JSON':
now = datetime.datetime.now()
DateString = now.strftime("%Y%m%d")
OUTPUT_JSON = lib.menu.XLS_Dest + os.sep + XLS_Files + "_" + DateString + ".json"
fname = pathlib.Path(OUTPUT_JSON)
if fname.exists():
print(
str(fname) + style.RED +
'\n==> File already exists. Not attempting to overwite' +
style.NORMAL + "\n")
return None
print('\nGenerating NSX-T Manager output: ' + style.ORANGE +
XLS_Files + "_" + DateString + ".json" + style.NORMAL + '\n')
WORKBOOK = Workbook()
if SheetFunction != None:
TN_WS = WORKBOOK.active
SheetFunction(auth_list, OUTPUT_JSON, TN_WS)
return [OUTPUT_JSON, WORKBOOK]
elif GetOutputFormat() == 'YAML':
now = datetime.datetime.now()
DateString = now.strftime("%Y%m%d")
OUTPUT_YAML = lib.menu.XLS_Dest + os.sep + XLS_Files + "_" + DateString + ".yaml"
fname = pathlib.Path(OUTPUT_YAML)
if fname.exists():
print(
str(fname) + style.RED +
'\n==> File already exists. Not attempting to overwite' +
style.NORMAL + "\n")
return None
print('\nGenerating NSX-T Manager output: ' + style.ORANGE +
XLS_Files + "_" + DateString + ".yaml" + style.NORMAL + '\n')
WORKBOOK = Workbook()
if SheetFunction != None:
TN_WS = WORKBOOK.active
SheetFunction(auth_list, OUTPUT_YAML, TN_WS)
return [OUTPUT_YAML, WORKBOOK]
else:
# Creation of Excel files
now = datetime.datetime.now()
DateString = now.strftime("%Y%m%d")
OUTPUT_XLS = lib.menu.XLS_Dest + os.sep + XLS_Files + "_" + DateString + ".xlsx"
fname = pathlib.Path(OUTPUT_XLS)
if fname.exists():
print(
str(fname) + style.RED +
'\n==> File already exists. Not attempting to overwite' +
style.NORMAL + "\n")
return None
print('\nGenerating NSX-T Manager output: ' + style.ORANGE +
XLS_Files + "_" + DateString + ".xlsx" + style.NORMAL + '\n')
WORKBOOK = Workbook()
if SheetFunction != None:
TN_WS = WORKBOOK.active
TN_WS.title = XLS_Files
SheetFunction(auth_list, WORKBOOK, TN_WS)
WORKBOOK.save(OUTPUT_XLS)
return [WORKBOOK, OUTPUT_XLS]
def SheetRouterPorts(auth_list, WORKBOOK, TN_WS, NSX_Config={}):
if 'LRPorts' not in NSX_Config:
NSX_Config['LRPorts'] = []
Dict_Ports = {}
SessionNSX = ConnectNSX(auth_list)
########### GET LogicalPortDownLink ###########
LRports_Down_url = '/api/v1/search/query?query=resource_type:LogicalRouterDownLinkPort'
LRports_Down_json = GetAPI(SessionNSX[0], LRports_Down_url, auth_list)
########### GET Logical Routers ###########
lr_ports_url = '/api/v1/search/query?query=resource_type:LogicalPort'
lr_ports_json = GetAPI(SessionNSX[0], lr_ports_url, auth_list)
########### GET Logical Routers ###########
lr_list_url = '/api/v1/logical-routers'
lr_list_json = GetAPI(SessionNSX[0], lr_list_url, auth_list)
########### CREATE LIST OF TUPLES - EDGE-ID / EDGE NAME ###########
lswitch_list = []
XLS_Lines = []
TN_HEADER_ROW = ('LR Port Name', 'ID', 'Attachment Type',
'Logical Router Name', 'Attachment ID',
'Logical Switch ID', 'Logical Switch', 'Create User',
'Admin State', 'Status')
########### GET Logical-Switches ###########
lswitch_url = '/api/v1/logical-switches'
lswitch_json = GetAPI(SessionNSX[0], lswitch_url, auth_list)
for i in lswitch_json["results"]:
lswitch_list.append(tuple((i['id'], i['display_name'])))
if lr_ports_json['result_count'] > 0:
for port in lr_ports_json["results"]:
# Check is attachment key is in Dict
if 'attachment' in port:
Attachement_type = port['attachment']['attachment_type']
Attachement_ID = port['attachment']['id']
else:
Attachement_type = 'No Attachment'
Attachement_ID = 'No Attachment'
# Get the name of LS
LS_Name = ""
LR_Name = ""
for ls in lswitch_list:
if port['logical_switch_id'] == ls[0]:
LS_Name = ls[1]
# Get Router Name
for lr in LRports_Down_json['results']:
if 'linked_logical_switch_port_id' in lr:
if port['id'] == lr[
'linked_logical_switch_port_id'][
'target_id']:
for router in lr_list_json['results']:
if lr['logical_router_id'] == router['id']:
LR_Name = router['display_name']
Dict_Ports['name'] = port['display_name']
Dict_Ports['state'] = port['admin_state']
Dict_Ports['create_user'] = port['_create_user']
Dict_Ports['router'] = LR_Name
Dict_Ports['id'] = port['id']
Dict_Ports['att_type'] = Attachement_type
Dict_Ports['att_id'] = Attachement_ID
Dict_Ports['LS_id'] = port['logical_switch_id']
Dict_Ports['LS_name'] = LS_Name
Dict_Ports['status'] = port['status']['status']
NSX_Config['LRPorts'].append(Dict_Ports)
XLS_Lines.append([
port['display_name'], port['id'], Attachement_type, LR_Name,
Attachement_ID, port['logical_switch_id'], LS_Name,
port['_create_user'], port['admin_state'],
port['status']['status']
])
else:
XLS_Lines.append(['No results', "", "", "", "", "", "", "", ""])
if GetOutputFormat() == 'CSV':
CSV = WORKBOOK
FillSheetCSV(CSV, TN_HEADER_ROW, XLS_Lines)
elif GetOutputFormat() == 'JSON':
JSON = WORKBOOK
FillSheetJSON(JSON, NSX_Config)
elif GetOutputFormat() == 'YAML':
YAML = WORKBOOK
FillSheetYAML(YAML, NSX_Config)
else:
FillSheet(WORKBOOK, TN_WS.title, TN_HEADER_ROW, XLS_Lines, "0072BA")
if len(XLS_Lines) > 0:
ConditionnalFormat(TN_WS, 'J2:J' + str(len(XLS_Lines) + 1), 'UP')
ConditionnalFormat(TN_WS, 'I2:I' + str(len(XLS_Lines) + 1), 'UP')
