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()))
Exemple #3
0
def main():
    """
    Main execution routine

    :return: None
    """
    # Create a tenant
    tenant = Tenant('Coke')

    # Create a Context and a BridgeDomain
    context = Context('VRF-1', tenant)
    context.set_allow_all()
    bd = BridgeDomain('BD-1', tenant)
    bd.add_context(context)

    # Create an App Profile and an EPG
    app = AppProfile('sap', tenant)
    epg = EPG('sapepg', app)

    # Attach the EPG to 2 interfaces using VLAN 5 as the encap
    if1 = Interface('eth', '1', '101', '1', '62')
    if2 = Interface('eth', '1', '101', '1', '63')
    vlan5_on_if1 = L2Interface('vlan5_on_if1', 'vlan', '5')
    vlan5_on_if2 = L2Interface('vlan5_on_if2', 'vlan', '5')
    vlan5_on_if1.attach(if1)
    vlan5_on_if2.attach(if2)
    epg.attach(vlan5_on_if1)
    epg.attach(vlan5_on_if2)

    # Dump the necessary configuration
    print('URL: '  + str(tenant.get_url()))
    print('JSON: ' + str(tenant.get_json()))

    send_to_apic(tenant)
def get_tree():
    """
    Will build an object tree with attributes in each object
    :return:
    """
    tenant = Tenant('tenant')
    tenant.dn = '/tn-tenant'
    app1 = AppProfile('app1', tenant)
    app1.dn = app1._parent.dn + '/app-app1'
    app2 = AppProfile('app2', tenant)
    app2.dn = app2._parent.dn + '/app-app2'
    epg11 = EPG('epg11', app1)
    epg11.dn = epg11._parent.dn + '/epg-epg11'
    epg12 = EPG('epg12', app1)
    epg12.dn = epg12._parent.dn + '/epg-epg12'
    epg21 = EPG('epg21', app2)
    epg21.dn = epg21._parent.dn + '/epg-epg21'
    epg22 = EPG('epg22', app2)
    epg22.dn = epg22._parent.dn + '/epg-epg22'
    bd1 = BridgeDomain('bd1', tenant)
    bd1.dn = bd1._parent.dn + '/bd-bd1'
    bd2 = BridgeDomain('bd2', tenant)
    bd2.dn = bd2._parent.dn + '/bd-bd2'
    epg11.add_bd(bd1)
    epg12.add_bd(bd2)
    epg21.add_bd(bd1)
    epg22.add_bd(bd2)
    context = Context('ctx', tenant)
    context.dn = context._parent.dn + '/ctx-ctx'
    bd1.add_context(context)
    bd2.add_context(context)
    contract1 = Contract('contract-1', tenant)
    contract1.dn = contract1._parent.dn + '/con-contract1'
    entry1 = FilterEntry('entry1',
                         applyToFrag='no',
                         arpOpc='unspecified',
                         dFromPort='80',
                         dToPort='80',
                         etherT='ip',
                         prot='tcp',
                         sFromPort='1',
                         sToPort='65535',
                         tcpRules='unspecified',
                         parent=contract1)
    subjects = contract1.get_children(ContractSubject)
    for subject in subjects:
        subject.dn = subject._parent.dn + '/subj-' + subject.name
    filters = tenant.get_children(Filter)
    for atk_filter in filters:
        atk_filter.dn = atk_filter._parent.dn + '/flt-' + atk_filter.name

    entry1.dn = entry1._parent.dn + '/flte-entry1'

    epg11.provide(contract1)
    epg11.consume(contract1)
    epg12.consume(contract1)

    epg11.value1 = 'value2'
    bd1.value2 = 'value1'
    return tenant
def create_base():
    global theTenant, theBD
    # This creates the tenant, vrf, and bridge domain
    theTenant = Tenant(tenant)
    theVRF = Context(vrf, theTenant)
    theBD = BridgeDomain(bridge_domain, theTenant)
    theBD.add_context(theVRF)

    for ipSubnet in ipSubnets:
        aSubnet = Subnet('VLAN', theBD)
        aSubnet.set_addr(ipSubnet)
        aSubnet.set_scope(subnet_scope)
        theBD.add_subnet(aSubnet)

    return
Exemple #6
0
def main():
    """
    Main execution routine

    :return: None
    """
    creds = Credentials('apic')
    creds.add_argument('--tenant', help='The name of Tenant')
    creds.add_argument('--app', help='The name of ApplicationProfile')
    creds.add_argument('--bd', help='The name of BridgeDomain')
    creds.add_argument('--epg', help='The name of EPG')
    creds.add_argument('--json',
                       const='false',
                       nargs='?',
                       help='Json output only')

    args = creds.get()
    session = Session(args.url, args.login, args.password)
    session.login()

    tenant = Tenant(args.tenant)
    app = AppProfile(args.app, tenant)
    bd = BridgeDomain(args.bd, tenant)
    epg = EPG(args.epg, app)
    epg.add_bd(bd)

    if args.json:
        print(tenant.get_json())
    else:
        resp = session.push_to_apic(tenant.get_url(), tenant.get_json())

        if not resp.ok:
            print('%% Error: Could not push configuration to APIC')
            print(resp.text)
def build_base():
    global theTenant, pushing_svi, pushcount
    count = 0
    pushcount = 0

    # This creates the tenant, vrf, and bridge domain
    theTenant = Tenant(tenant)
    theVRF = Context(tenant + vrf_extension, theTenant)

    for svi in all_svi:
        pushing_svi = svi
        if svi.ip == None:
            continue
        if svi.name == None:
            current_svi.set_name("vlan_" + svi.number)

        theBD = BridgeDomain(svi.name + bd_extension, theTenant)
        theBD.add_context(theVRF)
        aSubnet = Subnet('VLAN', theBD)
        subnet = svi.ip + svi.mask
        aSubnet.set_addr(subnet)
        aSubnet.set_scope(subnet_scope)
        theBD.add_subnet(aSubnet)

        # push_to_APIC()

        aApp = AppProfile(appProfile, theTenant)
        # push_to_APIC()

        theEPG = EPG(svi.name, aApp)
        theEPG.add_bd(theBD)
        theEPG.add_infradomain(theVmmDomain)

        push_to_APIC()

        pushcount += 1
        count += 1
        rand = random.randint(10,18)
        if count >= rand:
            print ("--Number of SVIs created so far: {0}".format(str(pushcount)))
            count = 0
Exemple #8
0
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 create_base():
    global theTenant, theBD
    # This creates the tenant, vrf, and bridge domain
    theTenant = Tenant(tenant)
    theVRF = Context(vrf, theTenant)
    theBD = BridgeDomain(bridge_domain, theTenant)
    theBD.add_context(theVRF)

    for ipSubnet in ipSubnets:
        aSubnet = Subnet('VLAN', theBD)
        aSubnet.set_addr(ipSubnet)
        aSubnet.set_scope(subnet_scope)
        theBD.add_subnet(aSubnet)

    return
def build_base():
    global theTenant, pushing_svi, pushcount
    count = 0
    pushcount = 0

    # This creates the tenant, vrf, and bridge domain
    theTenant = Tenant(tenant)
    theVRF = Context(tenant + vrf_extension, theTenant)

    for svi in all_svi:
        pushing_svi = svi
        if svi.ip == None:
            continue
        if svi.name == None:
            current_svi.set_name("vlan_" + svi.number)

        theBD = BridgeDomain(svi.name + bd_extension, theTenant)
        theBD.add_context(theVRF)
        aSubnet = Subnet('VLAN', theBD)
        subnet = svi.ip + svi.mask
        aSubnet.set_addr(subnet)
        aSubnet.set_scope(subnet_scope)
        theBD.add_subnet(aSubnet)

        # push_to_APIC()

        aApp = AppProfile(appProfile, theTenant)
        # push_to_APIC()

        theEPG = EPG(svi.name, aApp)
        theEPG.add_bd(theBD)
        theEPG.add_infradomain(theVmmDomain)

        push_to_APIC()

        pushcount += 1
        count += 1
        rand = random.randint(10, 18)
        if count >= rand:
            print("--Number of SVIs created so far: {0}".format(
                str(pushcount)))
            count = 0
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():

    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()))
Exemple #13
0
def main():
    """
    Main create tenant routine
    :return: None
    """
    # Get all the arguments
    description = 'It logs in to the APIC and will create the tenant.'
    creds = aci.Credentials('apic', description)
    creds.add_argument('-t',
                       '--tenant',
                       help='The name of tenant',
                       default=TENANT_NAME)
    args = creds.get()

    # Login to the APIC
    session = aci.Session(args.url,
                          args.login,
                          args.password,
                          subscription_enabled=False)
    resp = session.login()
    if not resp.ok:
        print('%% Could not login to APIC')

    # Create the Tenant
    tenant = aci.Tenant(TENANT_NAME)
    app = aci.AppProfile(APP_NAME, tenant)
    epg = aci.EPG(EPG_NAME, app)

    # 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)
    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
    epg.provide(contract)

    # Create the physical interface object
    intf = aci.Interface(INTERFACE['type'], INTERFACE['pod'],
                         INTERFACE['node'], INTERFACE['module'],
                         INTERFACE['port'])

    # Create a VLAN interface and attach to the physical interface
    vlan_intf = aci.L2Interface(VLAN['name'], VLAN['encap_type'],
                                VLAN['encap_id'])
    vlan_intf.attach(intf)

    # Attach the EPG to the VLAN interface
    epg.attach(vlan_intf)

    # Create the Endpoint
    mac = '00:11:11:11:11:11'
    ip = '10.2.1.4'

    # Assign it to the L2Interface
    #ep.attach(vlan_intf)

    # Push the tenant to the APIC
    resp = session.push_to_apic(tenant.get_url(), tenant.get_json())

    # Download all of the tenants
    print("-------------------------")
    print("LIST OF AVAILABLE TENANTS")
    print("-------------------------")
    tenants = aci.Tenant.get(session)
    for tenant in tenants:
        print(tenant.name)

    if not resp.ok:
        print('%% Error: Could not push configuration to APIC')
        print(resp.text)
def main():
    """
    Main create tenant routine
    :return: None
    """
    # Get all the arguments
    description = 'It logs in to the APIC and will create the tenant.'
    creds = aci.Credentials('apic', description)
    creds.add_argument('-t', '--tenant', help='The name of tenant',
                       default=TENANT_NAME)
    args = creds.get()

    # Login to the APIC
    session = aci.Session(args.url, args.login, args.password, subscription_enabled=False)
    resp = session.login()
    if not resp.ok:
        print('%% Could not login to APIC')

    # Create the Tenant
    tenant = aci.Tenant(TENANT_NAME)
    app = aci.AppProfile(APP_NAME, tenant)
    epg = aci.EPG(EPG_NAME, app)
    

    # 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)
    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 
    epg.provide(contract)
    


    # Create the physical interface object
    intf = aci.Interface(INTERFACE['type'],
                         INTERFACE['pod'],
                         INTERFACE['node'],
                         INTERFACE['module'],
                         INTERFACE['port'])

    # Create a VLAN interface and attach to the physical interface
    vlan_intf = aci.L2Interface(VLAN['name'], VLAN['encap_type'], VLAN['encap_id'])
    vlan_intf.attach(intf)

    # Attach the EPG to the VLAN interface
    epg.attach(vlan_intf)


      # Create the Endpoint
    mac = '00:11:11:11:11:11'
    ip = '10.2.1.4'
    

    # Assign it to the L2Interface
    #ep.attach(vlan_intf)


    # Push the tenant to the APIC
    resp = session.push_to_apic(tenant.get_url(),
                                tenant.get_json())
    
    # Download all of the tenants
    print("-------------------------")
    print("LIST OF AVAILABLE TENANTS")
    print("-------------------------")
    tenants = aci.Tenant.get(session)
    for tenant in tenants:
        print(tenant.name)

    if not resp.ok:
        print('%% Error: Could not push configuration to APIC')
        print(resp.text)
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=(',',':'))
Exemple #16
0
    session = Session(args.url, args.login, args.password)
    response = session.login()
    if response.ok is False:
        fatal(response.content)
    else:
        output("[+] Successfully connected to %s" % args.url)
    
    # First of all, let's retrieve a bunch of data from the fabric we connected to
    existing_tenants = {}
    tenants_modified = {}
    tenants = Tenant.get(session)
    print("[+] Objects discovered on the current fabric '%s'" % args.url)
    for t in tenants:
        print(" |_ Tenant '%s'" % t.name)
        existing_tenants[t.name]={'object': t, 'bds':{}}
        bds = BridgeDomain.get(session, t)
        for b in bds:
            print(" |  |_ BD '%s'" % b.name)
            existing_tenants[t.name]['bds'][b.name]={'object':b, 'subnets':{}}
            subnets = Subnet.get(session, b, t)
            for s in subnets:
                existing_tenants[t.name]['bds'][b.name]['subnets'][s.get_addr()]=s
                print(" |  |  |_ GW '%s'" % s.get_addr())
               
    # Now, let's read the input file and for each GW, update the config on 
    # the fabric
    f = open(args.input, "r")
    input_tenants={}
    print("[+] Changes to be applied to the current fabric '%s'" % args.url)
    for gw_info in csv.DictReader(f):
def get_tree():
    """
        Will build an object tree with attributes in each object
        :return:
        """
    tenant = Tenant('tenant')
    tenant.dn = '/tn-tenant'
    app1 = AppProfile('app1', tenant)
    app1.dn = app1._parent.dn + '/app-app1'
    app2 = AppProfile('app2', tenant)
    app2.dn = app2._parent.dn + '/app-app2'
    epg11 = EPG('epg11', app1)
    epg11.dn = epg11._parent.dn + '/epg-epg11'
    epg12 = EPG('epg12', app1)
    epg12.dn = epg12._parent.dn + '/epg-epg12'
    epg21 = EPG('epg21', app2)
    epg21.dn = epg21._parent.dn + '/epg-epg21'
    epg22 = EPG('epg22', app2)
    epg22.dn = epg22._parent.dn + '/epg-epg22'
    bd1 = BridgeDomain('bd1', tenant)
    bd1.dn = bd1._parent.dn + '/bd-bd1'
    bd2 = BridgeDomain('bd2', tenant)
    bd2.dn = bd2._parent.dn + '/bd-bd2'
    epg11.add_bd(bd1)
    epg12.add_bd(bd2)
    epg21.add_bd(bd1)
    epg22.add_bd(bd2)
    context = Context('ctx', tenant)
    context.dn = context._parent.dn + '/ctx-ctx'
    bd1.add_context(context)
    bd2.add_context(context)
    contract1 = Contract('contract-1', tenant)
    contract1.dn = contract1._parent.dn + '/con-contract1'
    entry1 = FilterEntry('entry1',
                         applyToFrag='no',
                         arpOpc='unspecified',
                         dFromPort='80',
                         dToPort='80',
                         etherT='ip',
                         prot='tcp',
                         sFromPort='1',
                         sToPort='65535',
                         tcpRules='unspecified',
                         parent=contract1)
    subjects = contract1.get_children(ContractSubject)
    for subject in subjects:
        subject.dn = subject._parent.dn + '/subj-' + subject.name
    filters = tenant.get_children(Filter)
    for atk_filter in filters:
        atk_filter.dn = atk_filter._parent.dn + '/flt-' + atk_filter.name

    entry1.dn = entry1._parent.dn + '/flte-entry1'

    epg11.provide(contract1)
    epg11.consume(contract1)
    epg12.consume(contract1)

    epg11.value1 = 'value2'
    bd1.value2 = 'value1'
    return tenant
Exemple #18
0
def main():
    """
    Main execution routine

    :return: None
    """
    creds = Credentials('apic')
    creds.add_argument('--tenant', help='The name of Tenant')
    creds.add_argument('--vrf', help='The name of VRF')
    creds.add_argument('--bd', help='The name of BridgeDomain')
    creds.add_argument('--address', help='Subnet IPv4 Address')
    creds.add_argument('--scope', help='The scope of subnet ("public", "private", "shared", "public,shared", "private,shared", "shared,public", "shared,private")')

    args = creds.get()
    session = Session(args.url, args.login, args.password)
    session.login()

    tenant = Tenant(args.tenant)
    vrf = Context(args.vrf)
    bd = BridgeDomain(args.bd, tenant)
    bd.add_context(vrf)

    if args.address is None:
        bd.set_arp_flood('yes')
        bd.set_unicast_route('no')
    else:
        bd.set_arp_flood('no')
        bd.set_unicast_route('yes')

        subnet = Subnet('', bd)
        subnet.addr = args.address

        if args.scope is None:
            subnet.set_scope("private")
        else:
            subnet.set_scope(args.scope)

    resp = session.push_to_apic(tenant.get_url(),
                                tenant.get_json())

    if not resp.ok:
        print('%% Error: Could not push configuration to APIC')
        print(resp.text)
def main():
    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():

    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)
Exemple #21
0
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.')