def consume_exported_contract(self, epg_name='web-frontend'):
session = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
# Create the Tenant
tenant = Tenant('multisite')
# Create the Application Profile
app = AppProfile('my-demo-app', tenant)
# Create the EPGs
web_epg = EPG(epg_name, app)
contract = Contract('Site1:multisite_mysqlcontract', tenant)
web_epg.consume(contract)
tenant.push_to_apic(session)
# Verify that the EPG is indeed consuming the contract
tenants = Tenant.get_deep(session, names=['multisite'], limit_to=['fvTenant', 'fvAp', 'fvAEPg',
'fvRsCons', 'vzBrCP'])
self.assertTrue(len(tenants) > 0)
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, epg_name)
self.assertIsNotNone(epg)
contract = multisite_tenant.get_child(Contract, 'Site1:multisite_mysqlcontract')
self.assertIsNotNone(contract)
self.assertTrue(epg.does_consume(contract))
def consume_exported_contract(self, epg_name='web-frontend'):
session = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
# Create the Tenant
tenant = Tenant('multisite')
# Create the Application Profile
app = AppProfile('my-demo-app', tenant)
# Create the EPGs
web_epg = EPG(epg_name, app)
contract = Contract('Site1:multisite_mysqlcontract', tenant)
web_epg.consume(contract)
tenant.push_to_apic(session)
# Verify that the EPG is indeed consuming the contract
tenants = Tenant.get_deep(
session,
names=['multisite'],
limit_to=['fvTenant', 'fvAp', 'fvAEPg', 'fvRsCons', 'vzBrCP'])
self.assertTrue(len(tenants) > 0)
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, epg_name)
self.assertIsNotNone(epg)
contract = multisite_tenant.get_child(Contract,
'Site1:multisite_mysqlcontract')
self.assertIsNotNone(contract)
self.assertTrue(epg.does_consume(contract))
def test_preexisting_endpoints_consume_imported_contract(self):
self.setup_export_contract()
self.consume_exported_contract()
session2 = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
tenant = Tenant('multisite')
app = AppProfile('my-demo-app', tenant)
new_epg_name = 'another-epg'
web_epg = EPG(new_epg_name, app)
# Create the Endpoint
mac = '00:77:55:44:33:22'
ip = '8.3.2.1'
ep = Endpoint(mac, web_epg)
ep.mac = mac
ep.ip = ip
intf = Interface('eth', '1', '101', '1', '38')
# Create a VLAN interface and attach to the physical interface
vlan_intf = L2Interface('vlan-5', 'vlan', '5')
vlan_intf.attach(intf)
# Attach the EPG to the VLAN interface
web_epg.attach(vlan_intf)
# Assign Endpoint to the L2Interface
ep.attach(vlan_intf)
resp = tenant.push_to_apic(session2)
self.assertTrue(resp.ok)
self.consume_exported_contract(epg_name=new_epg_name)
tenants = Tenant.get_deep(session2, names=['multisite'])
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, new_epg_name)
self.assertIsNotNone(epg)
multisite_ep = epg.get_child(Endpoint, mac)
self.assertIsNotNone(multisite_ep)
session1 = self._login_session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
self._assert_l3extsubnet_exists(session1,
tenant_name='multisite',
mac=mac,
ip=ip)
self.unconsume_exported_contract(new_epg_name)
time.sleep(2)
self._assert_l3extsubnet_does_not_exist(session1,
tenant_name='multisite',
mac=mac,
ip=ip)
web_epg.mark_as_deleted()
tenant.push_to_apic(session2)
time.sleep(1)
self.teardown_export_contract()
def test_preexisting_endpoints_consume_imported_contract(self):
self.setup_export_contract()
self.consume_exported_contract()
session2 = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
tenant = Tenant('multisite')
app = AppProfile('my-demo-app', tenant)
new_epg_name = 'another-epg'
web_epg = EPG(new_epg_name, app)
# Create the Endpoint
mac = '00:77:55:44:33:22'
ip = '8.3.2.1'
ep = Endpoint(mac, web_epg)
ep.mac = mac
ep.ip = ip
intf = Interface('eth', '1', '101', '1', '38')
# Create a VLAN interface and attach to the physical interface
vlan_intf = L2Interface('vlan-5', 'vlan', '5')
vlan_intf.attach(intf)
# Attach the EPG to the VLAN interface
web_epg.attach(vlan_intf)
# Assign Endpoint to the L2Interface
ep.attach(vlan_intf)
resp = tenant.push_to_apic(session2)
self.assertTrue(resp.ok)
self.consume_exported_contract(epg_name=new_epg_name)
tenants = Tenant.get_deep(session2, names=['multisite'])
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, new_epg_name)
self.assertIsNotNone(epg)
multisite_ep = epg.get_child(Endpoint, mac)
self.assertIsNotNone(multisite_ep)
session1 = self._login_session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
self._assert_l3extsubnet_exists(session1,
tenant_name='multisite',
mac=mac,
ip=ip)
self.unconsume_exported_contract(new_epg_name)
time.sleep(2)
self._assert_l3extsubnet_does_not_exist(session1,
tenant_name='multisite',
mac=mac,
ip=ip)
web_epg.mark_as_deleted()
tenant.push_to_apic(session2)
time.sleep(1)
self.teardown_export_contract()
def main():
""" Create 2 EPGs within the same Context and have
1 EPG provide a contract to the other EPG.
"""
description = ('Create 2 EPGs within the same Context and have'
'1 EPG provide a contract to the other EPG.')
creds = Credentials('apic', description)
args = creds.get()
# Create the Tenant
tenant = Tenant('aci-toolkit-demo')
# Create the Application Profile
app = AppProfile('my-demo-app', tenant)
# Create the EPGs
web_epg = EPG('web-frontend', app)
db_epg = EPG('database-backend', app)
web_epg.set_intra_epg_isolation(False)
db_epg.set_intra_epg_isolation(True)
# Create a Context and BridgeDomain
# Place both EPGs in the Context and in the same BD
context = Context('VRF-1', tenant)
bd = BridgeDomain('BD-1', tenant)
bd.add_context(context)
web_epg.add_bd(bd)
db_epg.add_bd(bd)
# Define a contract with a single entry
contract = Contract('mysql-contract', tenant)
entry1 = FilterEntry('entry1',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='3306',
dToPort='3306',
etherT='ip',
prot='tcp',
sFromPort='1',
sToPort='65535',
tcpRules='unspecified',
parent=contract)
# Provide the contract from 1 EPG and consume from the other
db_epg.provide(contract)
web_epg.consume(contract)
# Login to APIC and push the config
session = Session(args.url, args.login, args.password)
session.login()
# Cleanup (uncomment the next line to delete the config)
#tenant.mark_as_deleted()
resp = tenant.push_to_apic(session)
if resp.ok:
# Print what was sent
print('Pushed the following JSON to the APIC')
print('URL: ' + str(tenant.get_url()))
print('JSON: ' + str(tenant.get_json()))
def main():
""" Create 2 EPGs within the same Context and have
1 EPG provide a contract to the other EPG.
"""
description = ('Create 2 EPGs within the same Context and have'
'1 EPG provide a contract to the other EPG.')
creds = Credentials('apic', description)
args = creds.get()
# Create the Tenant
tenant = Tenant('aci-toolkit-demo')
# Create the Application Profile
app = AppProfile('my-demo-app', tenant)
# Create the EPGs
web_epg = EPG('web-frontend', app)
db_epg = EPG('database-backend', app)
web_epg.set_intra_epg_isolation(False)
db_epg.set_intra_epg_isolation(True)
# Create a Context and BridgeDomain
# Place both EPGs in the Context and in the same BD
context = Context('VRF-1', tenant)
bd = BridgeDomain('BD-1', tenant)
bd.add_context(context)
web_epg.add_bd(bd)
db_epg.add_bd(bd)
# Define a contract with a single entry
contract = Contract('mysql-contract', tenant)
entry1 = FilterEntry('entry1',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='3306',
dToPort='3306',
etherT='ip',
prot='tcp',
sFromPort='1',
sToPort='65535',
tcpRules='unspecified',
parent=contract)
# Provide the contract from 1 EPG and consume from the other
db_epg.provide(contract)
web_epg.consume(contract)
# Login to APIC and push the config
session = Session(args.url, args.login, args.password)
session.login()
# Cleanup (uncomment the next line to delete the config)
#tenant.mark_as_deleted()
resp = tenant.push_to_apic(session)
if resp.ok:
# Print what was sent
print('Pushed the following JSON to the APIC')
print('URL: ' + str(tenant.get_url()))
print('JSON: ' + str(tenant.get_json()))
def add_consuming_static_endpoint(self,
mac,
ip,
site1=False,
epg_name='web-frontend'):
if site1:
session = self._login_session(SITE1_URL, SITE1_LOGIN,
SITE1_PASSWORD)
else:
session = self._login_session(SITE2_URL, SITE2_LOGIN,
SITE2_PASSWORD)
tenant = Tenant('multisite')
app = AppProfile('my-demo-app', tenant)
web_epg = EPG(epg_name, app)
# Create the Endpoint
ep = Endpoint(mac, web_epg)
ep.mac = mac
ep.ip = ip
intf = Interface('eth', '1', '101', '1', '38')
# Create a VLAN interface and attach to the physical interface
vlan_intf = L2Interface('vlan-5', 'vlan', '5')
vlan_intf.attach(intf)
# Attach the EPG to the VLAN interface
web_epg.attach(vlan_intf)
# Assign Endpoint to the L2Interface
ep.attach(vlan_intf)
resp = tenant.push_to_apic(session)
self.assertTrue(resp.ok)
tenants = Tenant.get_deep(session, names=['multisite'])
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, epg_name)
self.assertIsNotNone(epg)
ep = epg.get_child(Endpoint, mac)
self.assertIsNotNone(ep)
if site1:
session = self._login_session(SITE2_URL, SITE2_LOGIN,
SITE2_PASSWORD)
else:
session = self._login_session(SITE1_URL, SITE1_LOGIN,
SITE1_PASSWORD)
self._assert_l3extsubnet_exists(session,
tenant_name='multisite',
mac=mac,
ip=ip)
def create_application_profile(tenant_name, ap_name):
session = Session(config_data.get('url'), config_data.get('login'),
config_data.get('password'))
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
tenant = Tenant(tenant_name)
ap = AppProfile(ap_name, tenant)
resp = tenant.push_to_apic(session)
if not resp.ok:
print('%% Error: Could not push configuration to APIC')
print(resp.text)
def del_tenant(tenant_name):
session = Session(config_data.get('url'), config_data.get('login'),
config_data.get('password'))
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
tenant = Tenant(tenant_name)
tenant.mark_as_deleted()
resp = tenant.push_to_apic(session)
if not resp.ok:
print('%% Error: Could not push configuration to APIC')
print(resp.text)
def unconsume_exported_contract(self, epg_name):
session = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
# Create the Tenant
tenant = Tenant('multisite')
# Create the Application Profile
app = AppProfile('my-demo-app', tenant)
# Create the EPGs
web_epg = EPG(epg_name, app)
contract = Contract('Site1:multisite_mysqlcontract', tenant)
web_epg.consume(contract)
web_epg.dont_consume(contract)
resp = tenant.push_to_apic(session)
if not resp.ok:
print resp, resp.text
self.assertTrue(resp.ok)
def del_epg(tenant_name, ap_name, epg_name, bd_name):
session = Session(config_data.get('url'), config_data.get('login'), config_data.get('password'))
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
tenant = Tenant(tenant_name)
ap = AppProfile(ap_name, tenant)
bd = BridgeDomain(bd_name, tenant)
epg = EPG(epg_name, ap)
epg.mark_as_deleted()
resp = tenant.push_to_apic(session)
if not resp.ok:
print('%% Error: Could not push configuration to APIC')
print(resp.text)
def unconsume_exported_contract(self, epg_name):
session = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
# Create the Tenant
tenant = Tenant('multisite')
# Create the Application Profile
app = AppProfile('my-demo-app', tenant)
# Create the EPGs
web_epg = EPG(epg_name, app)
contract = Contract('Site1:multisite_mysqlcontract', tenant)
web_epg.consume(contract)
web_epg.dont_consume(contract)
resp = tenant.push_to_apic(session)
if not resp.ok:
print resp, resp.text
self.assertTrue(resp.ok)
def add_consuming_static_endpoint(self, mac, ip, site1=False, epg_name='web-frontend'):
if site1:
session = self._login_session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
else:
session = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
tenant = Tenant('multisite')
app = AppProfile('my-demo-app', tenant)
web_epg = EPG(epg_name, app)
# Create the Endpoint
ep = Endpoint(mac, web_epg)
ep.mac = mac
ep.ip = ip
intf = Interface('eth', '1', '101', '1', '38')
# Create a VLAN interface and attach to the physical interface
vlan_intf = L2Interface('vlan-5', 'vlan', '5')
vlan_intf.attach(intf)
# Attach the EPG to the VLAN interface
web_epg.attach(vlan_intf)
# Assign Endpoint to the L2Interface
ep.attach(vlan_intf)
resp = tenant.push_to_apic(session)
self.assertTrue(resp.ok)
tenants = Tenant.get_deep(session, names=['multisite'])
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, epg_name)
self.assertIsNotNone(epg)
ep = epg.get_child(Endpoint, mac)
self.assertIsNotNone(ep)
if site1:
session = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
else:
session = self._login_session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
self._assert_l3extsubnet_exists(session,
tenant_name='multisite',
mac=mac,
ip=ip)
def add_providing_static_endpoint(self, mac, ip):
session = self._login_session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
tenant = Tenant('multisite')
app = AppProfile('my-demo-app', tenant)
web_epg = EPG('database-backend', app)
# Create the Endpoint
ep = Endpoint(mac, web_epg)
ep.mac = mac
ep.ip = ip
intf = Interface('eth', '1', '101', '1', '38')
# Create a VLAN interface and attach to the physical interface
vlan_intf = L2Interface('vlan-5', 'vlan', '5')
vlan_intf.attach(intf)
# Attach the EPG to the VLAN interface
web_epg.attach(vlan_intf)
# Assign Endpoint to the L2Interface
ep.attach(vlan_intf)
resp = tenant.push_to_apic(session)
if not resp.ok:
self.assertTrue(resp.ok)
print resp, resp.text
time.sleep(1)
# Verify that the Endpoint was pushed successfully
tenants = Tenant.get_deep(session, names=['multisite'])
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, 'database-backend')
self.assertIsNotNone(epg)
ep = epg.get_child(Endpoint, mac)
self.assertIsNotNone(ep)
# Verify that the entry was pushed to the other site
session = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
self._assert_l3extsubnet_exists(session,
tenant_name='multisite',
mac=mac,
ip=ip)
def add_providing_static_endpoint(self, mac, ip):
session = self._login_session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
tenant = Tenant('multisite')
app = AppProfile('my-demo-app', tenant)
web_epg = EPG('database-backend', app)
# Create the Endpoint
ep = Endpoint(mac, web_epg)
ep.mac = mac
ep.ip = ip
intf = Interface('eth', '1', '101', '1', '38')
# Create a VLAN interface and attach to the physical interface
vlan_intf = L2Interface('vlan-5', 'vlan', '5')
vlan_intf.attach(intf)
# Attach the EPG to the VLAN interface
web_epg.attach(vlan_intf)
# Assign Endpoint to the L2Interface
ep.attach(vlan_intf)
resp = tenant.push_to_apic(session)
if not resp.ok:
self.assertTrue(resp.ok)
print resp, resp.text
time.sleep(1)
# Verify that the Endpoint was pushed successfully
tenants = Tenant.get_deep(session, names=['multisite'])
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, 'database-backend')
self.assertIsNotNone(epg)
ep = epg.get_child(Endpoint, mac)
self.assertIsNotNone(ep)
# Verify that the entry was pushed to the other site
session = self._login_session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
self._assert_l3extsubnet_exists(session,
tenant_name='multisite',
mac=mac,
ip=ip)
def dettach_epg_provide_contract(tenant_name, ap_name, epg_name, provided_contract="", consumed_contract=""):
session = Session(config_data.get('url'), config_data.get('login'), config_data.get('password'))
resp = session.login()
if not resp.ok:
print('%% Could not login to APIC')
tenant = Tenant(tenant_name)
ap = AppProfile(ap_name, tenant)
epg = EPG(epg_name, ap)
if provided_contract:
provided_contract = Contract(provided_contract, tenant)
epg.dont_provide(provided_contract)
if consumed_contract:
consumed_contract = Contract(consumed_contract, tenant)
epg.dont_consume(consumed_contract)
resp = tenant.push_to_apic(session)
if not resp.ok:
print('%% Error: Could not push configuration to APIC')
print(resp.text)
def remove_providing_static_endpoint(self, mac, ip):
session = self._login_session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
tenant = Tenant('multisite')
app = AppProfile('my-demo-app', tenant)
web_epg = EPG('database-backend', app)
# Create the Endpoint
ep = Endpoint(mac, web_epg)
ep.mac = mac
ep.ip = ip
intf = Interface('eth', '1', '101', '1', '38')
# Create a VLAN interface and attach to the physical interface
vlan_intf = L2Interface('vlan-5', 'vlan', '5')
vlan_intf.attach(intf)
# Attach the EPG to the VLAN interface
web_epg.attach(vlan_intf)
# Assign Endpoint to the L2Interface
ep.attach(vlan_intf)
# Mark the Endpoint as deleted
ep.mark_as_deleted()
resp = tenant.push_to_apic(session)
self.assertTrue(resp.ok)
# Verify that the Endpoint has been removed
time.sleep(1)
tenants = Tenant.get_deep(session, names=['multisite'])
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, 'web-frontend')
self.assertIsNotNone(epg)
ep = epg.get_child(Endpoint, mac)
self.assertIsNone(ep)
def remove_providing_static_endpoint(self, mac, ip):
session = self._login_session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
tenant = Tenant('multisite')
app = AppProfile('my-demo-app', tenant)
web_epg = EPG('database-backend', app)
# Create the Endpoint
ep = Endpoint(mac, web_epg)
ep.mac = mac
ep.ip = ip
intf = Interface('eth', '1', '101', '1', '38')
# Create a VLAN interface and attach to the physical interface
vlan_intf = L2Interface('vlan-5', 'vlan', '5')
vlan_intf.attach(intf)
# Attach the EPG to the VLAN interface
web_epg.attach(vlan_intf)
# Assign Endpoint to the L2Interface
ep.attach(vlan_intf)
# Mark the Endpoint as deleted
ep.mark_as_deleted()
resp = tenant.push_to_apic(session)
self.assertTrue(resp.ok)
# Verify that the Endpoint has been removed
time.sleep(1)
tenants = Tenant.get_deep(session, names=['multisite'])
multisite_tenant = tenants[0]
app = multisite_tenant.get_child(AppProfile, 'my-demo-app')
self.assertIsNotNone(app)
epg = app.get_child(EPG, 'web-frontend')
self.assertIsNotNone(epg)
ep = epg.get_child(Endpoint, mac)
self.assertIsNone(ep)
def main():
description = ('Create 3 EPGs within the same Bridge Domain and have'
'2 EPGs provide a contract to the other EPG.')
creds = Credentials('apic', description)
args = creds.get()
# Login to APIC and push the config
session = Session(args.url, args.login, args.password, verify_ssl=False)
log = session.login()
if log.ok:
print('Login to APIC successful !!!')
if not log.ok:
print('Error: Could not login to APIC')
print(log.status_code)
# Create the Tenant
name_tenant = input('Enter Tenant name: ')
tenant = Tenant(name_tenant)
tenant_resp = tenant.push_to_apic(session)
if tenant_resp.ok:
print('Tenant created successfully !!!')
if not tenant_resp.ok:
print('Error: Could not create Tenant')
print(tenant_resp.status_code)
# Gets vmm domain from APIC
vmm = VmmDomain.get_by_name(session, 'vCenter-ACI')
vmm_resp = tenant.push_to_apic(session)
if vmm_resp.ok:
print('VmmDomain: vCenter-ACI, opened successfully !!!')
if not vmm_resp.ok:
print('Error: Could not open VmmDomain: vCenter-ACI')
print(vmm_resp.status_code)
# Create the Application Profile
name_ap = input('Enter Application Profile name: ')
app = AppProfile(name_ap, tenant)
app_resp = tenant.push_to_apic(session)
if app_resp.ok:
print('Application Profile created successfully !!!')
if not app_resp.ok:
print('Error: Could not create Application Profile')
print(app_resp.status_code)
# Create the WEB EPG
web_epg = EPG('WEB', app)
web_resp = tenant.push_to_apic(session)
if web_resp.ok:
print('WEB epg created successfully !!!')
if not web_resp.ok:
print('Error: Could not create WEB epg')
print(web_resp.status_code)
# Create the DATA EPG
db_epg = EPG('DATA', app)
db_resp = tenant.push_to_apic(session)
if db_resp.ok:
print('DATA epg created successfully !!!')
if not db_resp.ok:
print('Error: Could not create DATA epg')
print(db_epg.status_code)
# Create the APP EPG
app_epg = EPG('APP', app)
app_resp = tenant.push_to_apic(session)
if app_resp.ok:
print('APP epg created successfully !!!')
if not app_resp.ok:
print('Error: Could not create APP epg')
print(app_epg.status_code)
# Associating EPGs to Vmm Domain
web_epg.attach(vmm)
db_epg.attach(vmm)
app_epg.attach(vmm)
# Create a BridgeDomain
# Place both EPGs in the Context and in the same BD
bd = BridgeDomain('BD-1', tenant)
web_epg.add_bd(bd)
db_epg.add_bd(bd)
app_epg.add_bd(bd)
# Define web-to app contract
contract1 = Contract('web-to-app', tenant)
entry1 = FilterEntry('entry1',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='443',
dToPort='443',
etherT='ip',
prot='tcp',
sFromPort='1',
sToPort='65535',
tcpRules='unspecified',
parent=contract1)
# Define app-to-data contract
contract2 = Contract('app-to-data', tenant)
entry2 = FilterEntry('entry2',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='1433',
dToPort='1433',
etherT='ip',
prot='tcp',
sFromPort='1',
sToPort='65535',
tcpRules='unspecified',
parent=contract2)
# Provide the contract from 1 EPG and consume from the other
db_epg.provide(contract2)
web_epg.provide(contract1)
app_epg.consume(contract1)
app_epg.consume(contract2)
########### ClEANUP (uncomment the next line to delete the tenant)
#tenant.mark_as_deleted()
####################################
#Push all the config to apic
resp = tenant.push_to_apic(session)
if resp.ok:
print('All the configuration was pushed to APIC !!!')
if not resp.ok:
print('Error: Could not push configuration to APIC')
print(resp.status_code)
def main():
description = ('Create 2 EPGs within the same Context and have'
'1 EPG provide a contract to the other EPG.')
creds = Credentials('apic', description)
args = creds.get()
session = Session(args.url, args.login, args.password)
session.login()
for line in data:
line = line.strip("\n")
tnt = line.split(",")[0]
appro = line.split(",")[1]
epg1 = line.split(",")[2]
epg2 = line.split(",")[3]
contractn = line.split(",")[4]
bd1 = line.split(",")[5]
vrf1 = line.split(",")[6]
# Create the Tenant
tenant = Tenant(tnt)
# Create the Application Profile
app = AppProfile(appro, tenant)
# Create the EPGs
epg_obj1 = EPG(epg1, app)
epg_obj2 = EPG(epg2, app)
epg_obj1.set_intra_epg_isolation(False)
epg_obj2.set_intra_epg_isolation(True)
# Create a Context and BridgeDomain
# Place both EPGs in the Context and in the same BD
context = Context(vrf1, tenant)
bd = BridgeDomain(bd1, tenant)
bd.add_context(context)
epg_obj1.add_bd(bd)
epg_obj2.add_bd(bd)
# Define a contract with a single entry
contract = Contract(contractn, tenant)
entry1 = FilterEntry('entry1',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='3306',
dToPort='3306',
etherT='ip',
prot='tcp',
sFromPort='1',
sToPort='65535',
tcpRules='unspecified',
parent=contract)
# Provide the contract from 1 EPG and consume from the other
epg_obj2.provide(contract)
epg_obj1.consume(contract)
# Login to APIC and push the config
# Cleanup (uncomment the next line to delete the config)
# tenant.mark_as_deleted()
resp = tenant.push_to_apic(session)
if resp.ok:
# Print what was sent
print('Pushed the following JSON to the APIC')
print('URL: ' + str(tenant.get_url()))
print('JSON: ' + str(tenant.get_json()))
def setup_multisite_test(printonly=False, delete=False):
# Create the Tenant
tenant1 = Tenant('multisite')
# Create the Application Profile
app = AppProfile('my-demo-app', tenant1)
# Create the EPGs
web_epg = EPG('web-frontend', app)
db_epg = EPG('database-backend', app)
# Create a Context and BridgeDomain
# Place both EPGs in the Context and in the same BD
context = Context('VRF-1', tenant1)
bd = BridgeDomain('BD-1', tenant1)
bd.add_context(context)
web_epg.add_bd(bd)
db_epg.add_bd(bd)
# Define a contract with a single entry
contract = Contract('multisite_mysqlcontract', tenant1)
entry1 = FilterEntry('entry1',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='3306',
dToPort='3306',
etherT='ip',
prot='tcp',
sFromPort='1',
sToPort='65535',
tcpRules='unspecified',
parent=contract)
# Provide the contract from 1 EPG and consume from the other
db_epg.provide(contract)
web_epg.consume(contract)
context = Context('ctx0', tenant1)
#contract = Contract('contract', tenant)
phyif = Interface('eth', '1', '102', '1', '25')
l2if = L2Interface('eth 1/102/1/25', 'vlan', '500')
l2if.attach(phyif)
l3if = L3Interface('l3if')
l3if.set_l3if_type('ext-svi')
l3if.set_addr('20.0.0.1/16')
l3if.add_context(context)
l3if.attach(l2if)
#l3if.networks.append('1.1.1.1/32')
#outside.provide(contract)
l3if.attach(l2if)
rtr = OSPFRouter('rtr-1')
rtr.set_router_id('101.101.101.101')
rtr.set_node_id('102')
# net1 = OutsideNetwork('1.1.1.1/32')
# net1.network = '1.1.1.1/32'
# net1.provide(contract)
ospfif = OSPFInterface('ospfif-1', router=rtr, area_id='0.0.0.1')
ospfif.attach(l3if)
# ospfif.networks.append(net1)
outside = OutsideEPG('multisite-l3out', tenant1)
outside.attach(ospfif)
#outside.add_context(context)
# Create the Tenant
tenant2 = Tenant('multisite')
# Create the Application Profile
app = AppProfile('my-demo-app', tenant2)
# Create the EPGs
web_epg = EPG('web-frontend', app)
# Create a Context and BridgeDomain
# Place both EPGs in the Context and in the same BD
context = Context('VRF-1', tenant2)
bd = BridgeDomain('BD-1', tenant2)
bd.add_context(context)
web_epg.add_bd(bd)
context = Context('ctx0', tenant2)
#contract = Contract('contract', tenant)
phyif = Interface('eth', '1', '102', '1', '25')
l2if = L2Interface('eth 1/102/1/25', 'vlan', '500')
l2if.attach(phyif)
l3if = L3Interface('l3if')
l3if.set_l3if_type('ext-svi')
l3if.set_addr('20.0.0.2/16')
l3if.add_context(context)
l3if.attach(l2if)
#outside.provide(contract)
l3if.attach(l2if)
rtr = OSPFRouter('rtr-1')
rtr.set_router_id('102.102.102.102')
rtr.set_node_id('102')
ospfif = OSPFInterface('ospfif-1', router=rtr, area_id='0.0.0.1')
ospfif.attach(l3if)
#ospfif.networks.append('1.1.1.1/32')
#ospfif.networks.append('1.1.1.2/32')
outside = OutsideEPG('multisite-l3out', tenant2)
outside.attach(ospfif)
if not printonly:
# Login to APIC and push the config
session = Session(SITE1_URL, SITE1_LOGIN, SITE1_PASSWORD)
session.login()
# Cleanup (uncomment the next line to delete the config)
if delete:
print 'Deleting...'
tenant1.mark_as_deleted()
resp = tenant1.push_to_apic(session)
if resp.ok:
# Print what was sent
print('Pushed the following JSON to the APIC', resp.text)
else:
print resp, resp.text
print('URL: ' + str(tenant1.get_url()))
print('JSON:')
print json.dumps(tenant1.get_json(), indent=4, separators=(',',':'))
if not printonly:
# Login to APIC and push the config
session = Session(SITE2_URL, SITE2_LOGIN, SITE2_PASSWORD)
session.login()
# Cleanup (uncomment the next line to delete the config)
if delete:
tenant2.mark_as_deleted()
resp = tenant2.push_to_apic(session)
if resp.ok:
# Print what was sent
print('Pushed the following JSON to the APIC', resp.text)
else:
print resp, resp.text
print('URL: ' + str(tenant2.get_url()))
print('JSON:')
print json.dumps(tenant2.get_json(), indent=4, separators=(',',':'))
def main():
# Setup or credentials and session
description = ('Create 3 EPGs within the same Context, have them '
'provide and consume contracts and attach them to '
'a vmm domain.')
creds = Credentials('apic', description)
args = creds.get()
# Login to APIC
session = Session(args.url, args.login, args.password)
session.login()
# Get the virtual domain we are going to use
vdomain = EPGDomain.get_by_name(session, vmmdomain)
# Create the Tenant
tenant = Tenant(this_tenant)
# Create the Application Profile
app = AppProfile(this_app, tenant)
# Create the EPGs
t1_epg = EPG(tier1_epg, app)
t2_epg = EPG(tier2_epg, app)
t3_epg = EPG(tier3_epg, app)
# Create a Context and BridgeDomain
# Place all EPGs in the Context and in the same BD
context = Context(private_net, tenant)
bd = BridgeDomain(bridge_domain, tenant)
bd.add_context(context)
t1_epg.add_bd(bd)
t1_epg.add_infradomain(vdomain)
t2_epg.add_bd(bd)
t2_epg.add_infradomain(vdomain)
t3_epg.add_bd(bd)
'''
Define a contract with a single entry
Additional entries can be added by duplicating the FilterEntry
Push to APIC after each FilterEntry if it is not the last
'''
contract1 = Contract('mysql-contract', tenant)
entry1 = FilterEntry('SQL',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='3306',
dToPort='3306',
etherT='ip',
prot='tcp',
tcpRules='unspecified',
parent=contract1)
contract2 = Contract('app-contract', tenant)
contract2.set_scope('application-profile')
entry1 = FilterEntry('Flask',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='5000',
dToPort='5000',
etherT='ip',
prot='tcp',
tcpRules='unspecified',
parent=contract2)
tenant.push_to_apic(session)
entry2 = FilterEntry('Flask2',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='5050',
dToPort='5050',
etherT='ip',
prot='tcp',
tcpRules='unspecified',
parent=contract2)
contract3 = Contract('web-contract', tenant)
contract3.set_scope('application-profile')
entry1 = FilterEntry('HTTPS',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='443',
dToPort='443',
etherT='ip',
prot='tcp',
tcpRules='unspecified',
parent=contract3)
# Provide the contract from 1 EPG and consume from the other
t3_epg.provide(contract1)
t2_epg.consume(contract1)
t2_epg.provide(contract2)
t1_epg.consume(contract2)
t1_epg.provide(contract3)
# Finally, push all this to the APIC
# Cleanup (uncomment the next line to delete the config)
# CAUTION: The next line will DELETE the tenant
# tenant.mark_as_deleted()
resp = tenant.push_to_apic(session)
if resp.ok:
# Print some confirmation
print('The configuration was sucessfully pushed to the APIC.')
def main():
required = collect_required()
# Setup or credentials and session
description = ('Create 5 EPGs within the same Context, have them '
'provide and consume the same contract so that they '
'can communicate between eachother.')
creds = Credentials('apic', description)
args = creds.get()
# Login to APIC
session = Session(args.url, args.login, args.password)
session.login()
# Get the virtual domain we are going to use
try:
vdomain = EPGDomain.get_by_name(session, required[1])
except:
print "There was an error using " + required[
1] + " as the VMMDomain. Are you sure it exists?"
exit()
# Create the Tenant
tenant = Tenant(required[0])
# Create the Application Profile
app = AppProfile(this_app, tenant)
# Create the EPGs
t1_epg = EPG(tier1_epg, app)
t2_epg = EPG(tier2_epg, app)
t3_epg = EPG(tier3_epg, app)
t4_epg = EPG(tier4_epg, app)
t5_epg = EPG(tier5_epg, app)
# Create a Context and BridgeDomain
# Place all EPGs in the Context and in the same BD
context = Context(private_net, tenant)
bd = BridgeDomain(bridge_domain, tenant)
bd.add_context(context)
# Add all the IP Addresses to the bridge domain
bd_subnet5 = Subnet(tier1_epg, bd)
bd_subnet5.set_addr(tier1_subnet)
bd_subnet5.set_scope(subnet_scope)
bd.add_subnet(bd_subnet5)
bd_subnet6 = Subnet(tier2_epg, bd)
bd_subnet6.set_addr(tier2_subnet)
bd_subnet6.set_scope(subnet_scope)
bd.add_subnet(bd_subnet6)
bd_subnet7 = Subnet(tier3_epg, bd)
bd_subnet7.set_addr(tier3_subnet)
bd_subnet7.set_scope(subnet_scope)
bd.add_subnet(bd_subnet7)
bd_subnet8 = Subnet(tier4_epg, bd)
bd_subnet8.set_addr(tier4_subnet)
bd_subnet8.set_scope(subnet_scope)
bd.add_subnet(bd_subnet8)
bd_subnet9 = Subnet(tier5_epg, bd)
bd_subnet9.set_addr(tier5_subnet)
bd_subnet9.set_scope(subnet_scope)
bd.add_subnet(bd_subnet9)
t1_epg.add_bd(bd)
t1_epg.add_infradomain(vdomain)
t2_epg.add_bd(bd)
t2_epg.add_infradomain(vdomain)
t3_epg.add_bd(bd)
t3_epg.add_infradomain(vdomain)
t4_epg.add_bd(bd)
t4_epg.add_infradomain(vdomain)
t5_epg.add_bd(bd)
t5_epg.add_infradomain(vdomain)
'''
Define a contract with a single entry
Additional entries can be added by duplicating "entry1"
'''
contract1 = Contract('allow_all', tenant)
entry1 = FilterEntry('all',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='unspecified',
dToPort='unspecified',
etherT='unspecified',
prot='unspecified',
tcpRules='unspecified',
parent=contract1)
# All the EPGs provide and consume the contract
t1_epg.consume(contract1)
t1_epg.provide(contract1)
t2_epg.consume(contract1)
t2_epg.provide(contract1)
t3_epg.consume(contract1)
t3_epg.provide(contract1)
t4_epg.consume(contract1)
t4_epg.provide(contract1)
t5_epg.consume(contract1)
t5_epg.provide(contract1)
# Finally, push all this to the APIC
# Cleanup (uncomment the next line to delete the config)
# CAUTION: The next line will DELETE the tenant
# tenant.mark_as_deleted()
resp = tenant.push_to_apic(session)
if resp.ok:
# Print some confirmation
print('The configuration was sucessfully pushed to the APIC.')
# Uncomment the next lines if you want to see the configuration
# print('URL: ' + str(tenant.get_url()))
# print('JSON: ' + str(tenant.get_json()))
else:
print resp
print resp.text
print('URL: ' + str(tenant.get_url()))
print('JSON: ' + str(tenant.get_json()))
def main():
required = collect_required()
# Setup or credentials and session
description = ('Create 5 EPGs within the same Context, have them '
'provide and consume the same contract so that they '
'can communicate between eachother.')
creds = Credentials('apic', description)
args = creds.get()
# Login to APIC
session = Session(args.url, args.login, args.password)
session.login()
# Get the virtual domain we are going to use
try:
vdomain = EPGDomain.get_by_name(session,required[1])
except:
print "There was an error using " + required[1] + " as the VMMDomain. Are you sure it exists?"
exit()
# Create the Tenant
tenant = Tenant(required[0])
# Create the Application Profile
app = AppProfile(this_app, tenant)
# Create the EPGs
t1_epg = EPG(tier1_epg, app)
t2_epg = EPG(tier2_epg, app)
t3_epg = EPG(tier3_epg, app)
t4_epg = EPG(tier4_epg, app)
t5_epg = EPG(tier5_epg, app)
# Create a Context and BridgeDomain
# Place all EPGs in the Context and in the same BD
context = Context(private_net, tenant)
bd = BridgeDomain(bridge_domain, tenant)
bd.add_context(context)
# Add all the IP Addresses to the bridge domain
bd_subnet5 = Subnet(tier1_epg, bd)
bd_subnet5.set_addr(tier1_subnet)
bd_subnet5.set_scope(subnet_scope)
bd.add_subnet(bd_subnet5)
bd_subnet6 = Subnet(tier2_epg, bd)
bd_subnet6.set_addr(tier2_subnet)
bd_subnet6.set_scope(subnet_scope)
bd.add_subnet(bd_subnet6)
bd_subnet7 = Subnet(tier3_epg, bd)
bd_subnet7.set_addr(tier3_subnet)
bd_subnet7.set_scope(subnet_scope)
bd.add_subnet(bd_subnet7)
bd_subnet8 = Subnet(tier4_epg, bd)
bd_subnet8.set_addr(tier4_subnet)
bd_subnet8.set_scope(subnet_scope)
bd.add_subnet(bd_subnet8)
bd_subnet9 = Subnet(tier5_epg, bd)
bd_subnet9.set_addr(tier5_subnet)
bd_subnet9.set_scope(subnet_scope)
bd.add_subnet(bd_subnet9)
t1_epg.add_bd(bd)
t1_epg.add_infradomain(vdomain)
t2_epg.add_bd(bd)
t2_epg.add_infradomain(vdomain)
t3_epg.add_bd(bd)
t3_epg.add_infradomain(vdomain)
t4_epg.add_bd(bd)
t4_epg.add_infradomain(vdomain)
t5_epg.add_bd(bd)
t5_epg.add_infradomain(vdomain)
'''
Define a contract with a single entry
Additional entries can be added by duplicating "entry1"
'''
contract1 = Contract('allow_all', tenant)
entry1 = FilterEntry('all',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='unspecified',
dToPort='unspecified',
etherT='unspecified',
prot='unspecified',
tcpRules='unspecified',
parent=contract1)
# All the EPGs provide and consume the contract
t1_epg.consume(contract1)
t1_epg.provide(contract1)
t2_epg.consume(contract1)
t2_epg.provide(contract1)
t3_epg.consume(contract1)
t3_epg.provide(contract1)
t4_epg.consume(contract1)
t4_epg.provide(contract1)
t5_epg.consume(contract1)
t5_epg.provide(contract1)
# Finally, push all this to the APIC
# Cleanup (uncomment the next line to delete the config)
# CAUTION: The next line will DELETE the tenant
# tenant.mark_as_deleted()
resp = tenant.push_to_apic(session)
if resp.ok:
# Print some confirmation
print('The configuration was sucessfully pushed to the APIC.')
# Uncomment the next lines if you want to see the configuration
# print('URL: ' + str(tenant.get_url()))
# print('JSON: ' + str(tenant.get_json()))
else:
print resp
print resp.text
print('URL: ' + str(tenant.get_url()))
print('JSON: ' + str(tenant.get_json()))
def main():
# Setup or credentials and session
description = ('Create 3 EPGs within the same Context, have them '
'provide and consume contracts and attach them to '
'a vmm domain.')
creds = Credentials('apic', description)
args = creds.get()
# Login to APIC
session = Session(args.url, args.login, args.password)
session.login()
# Get the virtual domain we are going to use
vdomain = EPGDomain.get_by_name(session,vmmdomain)
# Create the Tenant
tenant = Tenant(this_tenant)
# Create the Application Profile
app = AppProfile(this_app, tenant)
# Create the EPGs
t1_epg = EPG(tier1_epg, app)
t2_epg = EPG(tier2_epg, app)
t3_epg = EPG(tier3_epg, app)
# Create a Context and BridgeDomain
# Place all EPGs in the Context and in the same BD
context = Context(private_net, tenant)
bd = BridgeDomain(bridge_domain, tenant)
bd.add_context(context)
t1_epg.add_bd(bd)
t1_epg.add_infradomain(vdomain)
t2_epg.add_bd(bd)
t2_epg.add_infradomain(vdomain)
t3_epg.add_bd(bd)
'''
Define a contract with a single entry
Additional entries can be added by duplicating the FilterEntry
Push to APIC after each FilterEntry if it is not the last
'''
contract1 = Contract('mysql-contract', tenant)
entry1 = FilterEntry('SQL',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='3306',
dToPort='3306',
etherT='ip',
prot='tcp',
tcpRules='unspecified',
parent=contract1)
contract2 = Contract('app-contract', tenant)
contract2.set_scope('application-profile')
entry1 = FilterEntry('Flask',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='5000',
dToPort='5000',
etherT='ip',
prot='tcp',
tcpRules='unspecified',
parent=contract2)
tenant.push_to_apic(session)
entry2 = FilterEntry('Flask2',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='5050',
dToPort='5050',
etherT='ip',
prot='tcp',
tcpRules='unspecified',
parent=contract2)
contract3 = Contract('web-contract', tenant)
contract3.set_scope('application-profile')
entry1 = FilterEntry('HTTPS',
applyToFrag='no',
arpOpc='unspecified',
dFromPort='443',
dToPort='443',
etherT='ip',
prot='tcp',
tcpRules='unspecified',
parent=contract3)
# Provide the contract from 1 EPG and consume from the other
t3_epg.provide(contract1)
t2_epg.consume(contract1)
t2_epg.provide(contract2)
t1_epg.consume(contract2)
t1_epg.provide(contract3)
# Finally, push all this to the APIC
# Cleanup (uncomment the next line to delete the config)
# CAUTION: The next line will DELETE the tenant
# tenant.mark_as_deleted()
resp = tenant.push_to_apic(session)
if resp.ok:
# Print some confirmation
print('The configuration was sucessfully pushed to the APIC.')
