From 61e7f74566367dfda02f86e70fbfe61f73b7788c Mon Sep 17 00:00:00 2001 From: Ashutosh Soni <74891251+AshuSoni-crest@users.noreply.github.com> Date: Mon, 3 May 2021 10:38:42 +0530 Subject: [PATCH] S5 dev (#106) sprint resource models and service files added --- client/bfdIfP_service.go | 100 ++++++++++++++++++ client/bgpProtP_service.go | 100 ++++++++++++++++++ client/fabricExplicitGEp_service.go | 8 +- client/hsrpSecVip_service.go | 53 ++++++++++ client/ipNexthopP_service.go | 155 ++++++++++++++++++++++++++++ client/ipRouteP_service.go | 105 +++++++++++++++++++ client/l3extMember_service.go | 53 ++++++++++ client/l3extRouteTagPol_service.go | 53 ++++++++++ models/bfd_if_p.go | 106 +++++++++++++++++++ models/bgp_prot_p.go | 86 +++++++++++++++ models/fabric_explicit_g_ep.go | 4 +- models/hsrp_sec_vip.go | 100 ++++++++++++++++++ models/ip_nexthop_p.go | 106 +++++++++++++++++++ models/ip_route_p.go | 112 ++++++++++++++++++++ models/l3ext_member.go | 112 ++++++++++++++++++++ models/l3ext_route_tag_pol.go | 100 ++++++++++++++++++ models/l3ext_virtual_l_if_p.go | 6 -- 17 files changed, 1346 insertions(+), 13 deletions(-) create mode 100644 client/bfdIfP_service.go create mode 100644 client/bgpProtP_service.go create mode 100644 client/hsrpSecVip_service.go create mode 100644 client/ipNexthopP_service.go create mode 100644 client/ipRouteP_service.go create mode 100644 client/l3extMember_service.go create mode 100644 client/l3extRouteTagPol_service.go create mode 100644 models/bfd_if_p.go create mode 100644 models/bgp_prot_p.go create mode 100644 models/hsrp_sec_vip.go create mode 100644 models/ip_nexthop_p.go create mode 100644 models/ip_route_p.go create mode 100644 models/l3ext_member.go create mode 100644 models/l3ext_route_tag_pol.go diff --git a/client/bfdIfP_service.go b/client/bfdIfP_service.go new file mode 100644 index 00000000..b298537f --- /dev/null +++ b/client/bfdIfP_service.go @@ -0,0 +1,100 @@ +package client + +import ( + "fmt" + + "github.com/ciscoecosystem/aci-go-client/container" + "github.com/ciscoecosystem/aci-go-client/models" +) + +func (sm *ServiceManager) CreateBFDInterfaceProfile(logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string, description string, bfdIfPattr models.BFDInterfaceProfileAttributes) (*models.BFDInterfaceProfile, error) { + rn := fmt.Sprintf("bfdIfP") + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s", tenant, l3_outside, logical_node_profile, logical_interface_profile) + bfdIfP := models.NewBFDInterfaceProfile(rn, parentDn, description, bfdIfPattr) + err := sm.Save(bfdIfP) + return bfdIfP, err +} + +func (sm *ServiceManager) ReadBFDInterfaceProfile(logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) (*models.BFDInterfaceProfile, error) { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/bfdIfP", tenant, l3_outside, logical_node_profile, logical_interface_profile) + cont, err := sm.Get(dn) + if err != nil { + return nil, err + } + + bfdIfP := models.BFDInterfaceProfileFromContainer(cont) + return bfdIfP, nil +} + +func (sm *ServiceManager) DeleteBFDInterfaceProfile(logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) error { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/bfdIfP", tenant, l3_outside, logical_node_profile, logical_interface_profile) + return sm.DeleteByDn(dn, models.BfdifpClassName) +} + +func (sm *ServiceManager) UpdateBFDInterfaceProfile(logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string, description string, bfdIfPattr models.BFDInterfaceProfileAttributes) (*models.BFDInterfaceProfile, error) { + rn := fmt.Sprintf("bfdIfP") + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s", tenant, l3_outside, logical_node_profile, logical_interface_profile) + bfdIfP := models.NewBFDInterfaceProfile(rn, parentDn, description, bfdIfPattr) + + bfdIfP.Status = "modified" + err := sm.Save(bfdIfP) + return bfdIfP, err + +} + +func (sm *ServiceManager) ListBFDInterfaceProfile(logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) ([]*models.BFDInterfaceProfile, error) { + + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/uni/tn-%s/out-%s/lnodep-%s/lifp-%s/bfdIfP.json", baseurlStr, tenant, l3_outside, logical_node_profile, logical_interface_profile) + + cont, err := sm.GetViaURL(dnUrl) + list := models.BFDInterfaceProfileListFromContainer(cont) + + return list, err +} + +func (sm *ServiceManager) CreateRelationbfdRsIfPolFromInterfaceProfile(parentDn, tnBfdIfPolName string) error { + dn := fmt.Sprintf("%s/bfdIfP/rsIfPol", parentDn) + containerJSON := []byte(fmt.Sprintf(`{ + "%s": { + "attributes": { + "dn": "%s","tnBfdIfPolName": "%s","annotation":"orchestrator:terraform" + + } + } + }`, "bfdRsIfPol", dn, tnBfdIfPolName)) + + jsonPayload, err := container.ParseJSON(containerJSON) + if err != nil { + return err + } + + req, err := sm.client.MakeRestRequest("POST", fmt.Sprintf("%s.json", sm.MOURL), jsonPayload, true) + if err != nil { + return err + } + + cont, _, err := sm.client.Do(req) + if err != nil { + return err + } + fmt.Printf("%+v", cont) + + return nil +} + +func (sm *ServiceManager) ReadRelationbfdRsIfPolFromInterfaceProfile(parentDn string) (interface{}, error) { + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/%s/%s.json", baseurlStr, parentDn, "bfdRsIfPol") + cont, err := sm.GetViaURL(dnUrl) + + contList := models.ListFromContainer(cont, "bfdRsIfPol") + + if len(contList) > 0 { + dat := models.G(contList[0], "tnBfdIfPolName") + return dat, err + } else { + return nil, err + } + +} diff --git a/client/bgpProtP_service.go b/client/bgpProtP_service.go new file mode 100644 index 00000000..a8495f58 --- /dev/null +++ b/client/bgpProtP_service.go @@ -0,0 +1,100 @@ +package client + +import ( + "fmt" + + "github.com/ciscoecosystem/aci-go-client/container" + "github.com/ciscoecosystem/aci-go-client/models" +) + +func (sm *ServiceManager) CreateL3outBGPProtocolProfile(logical_node_profile string, l3_outside string, tenant string, bgpProtPattr models.L3outBGPProtocolProfileAttributes) (*models.L3outBGPProtocolProfile, error) { + rn := fmt.Sprintf("protp") + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s", tenant, l3_outside, logical_node_profile) + bgpProtP := models.NewL3outBGPProtocolProfile(rn, parentDn, bgpProtPattr) + err := sm.Save(bgpProtP) + return bgpProtP, err +} + +func (sm *ServiceManager) ReadL3outBGPProtocolProfile(logical_node_profile string, l3_outside string, tenant string) (*models.L3outBGPProtocolProfile, error) { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/protp", tenant, l3_outside, logical_node_profile) + cont, err := sm.Get(dn) + if err != nil { + return nil, err + } + + bgpProtP := models.L3outBGPProtocolProfileFromContainer(cont) + return bgpProtP, nil +} + +func (sm *ServiceManager) DeleteL3outBGPProtocolProfile(logical_node_profile string, l3_outside string, tenant string) error { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/protp", tenant, l3_outside, logical_node_profile) + return sm.DeleteByDn(dn, models.BgpprotpClassName) +} + +func (sm *ServiceManager) UpdateL3outBGPProtocolProfile(logical_node_profile string, l3_outside string, tenant string, bgpProtPattr models.L3outBGPProtocolProfileAttributes) (*models.L3outBGPProtocolProfile, error) { + rn := fmt.Sprintf("protp") + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s", tenant, l3_outside, logical_node_profile) + bgpProtP := models.NewL3outBGPProtocolProfile(rn, parentDn, bgpProtPattr) + + bgpProtP.Status = "modified" + err := sm.Save(bgpProtP) + return bgpProtP, err + +} + +func (sm *ServiceManager) ListL3outBGPProtocolProfile(logical_node_profile string, l3_outside string, tenant string) ([]*models.L3outBGPProtocolProfile, error) { + + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/uni/tn-%s/out-%s/lnodep-%s/bgpProtP.json", baseurlStr, tenant, l3_outside, logical_node_profile) + + cont, err := sm.GetViaURL(dnUrl) + list := models.L3outBGPProtocolProfileListFromContainer(cont) + + return list, err +} + +func (sm *ServiceManager) CreateRelationbgpRsBgpNodeCtxPolFromL3outBGPProtocolProfile(parentDn, tnBgpCtxPolName string) error { + dn := fmt.Sprintf("%s/protp/rsbgpNodeCtxPol", parentDn) + containerJSON := []byte(fmt.Sprintf(`{ + "%s": { + "attributes": { + "dn": "%s", + "tnBgpCtxPolName": "%s", + "annotation":"orchestrator:terraform"} + } + }`, "bgpRsBgpNodeCtxPol", dn, tnBgpCtxPolName)) + + jsonPayload, err := container.ParseJSON(containerJSON) + if err != nil { + return err + } + + req, err := sm.client.MakeRestRequest("POST", fmt.Sprintf("%s.json", sm.MOURL), jsonPayload, true) + if err != nil { + return err + } + + cont, _, err := sm.client.Do(req) + if err != nil { + return err + } + fmt.Printf("%+v", cont) + + return nil +} + +func (sm *ServiceManager) ReadRelationbgpRsBgpNodeCtxPolFromL3outBGPProtocolProfile(parentDn string) (interface{}, error) { + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/%s/%s.json", baseurlStr, parentDn, "bgpRsBgpNodeCtxPol") + cont, err := sm.GetViaURL(dnUrl) + + contList := models.ListFromContainer(cont, "bgpRsBgpNodeCtxPol") + + if len(contList) > 0 { + dat := models.G(contList[0], "tnBgpCtxPolName") + return dat, err + } else { + return nil, err + } + +} diff --git a/client/fabricExplicitGEp_service.go b/client/fabricExplicitGEp_service.go index c1cb6ccc..87c91c73 100644 --- a/client/fabricExplicitGEp_service.go +++ b/client/fabricExplicitGEp_service.go @@ -9,10 +9,10 @@ import ( "github.com/ciscoecosystem/aci-go-client/models" ) -func (sm *ServiceManager) CreateVPCExplicitProtectionGroup(name string, description string, switch1 string, switch2 string, vpcDomainPolicy string, fabricExplicitGEpattr models.VPCExplicitProtectionGroupAttributes) (*models.VPCExplicitProtectionGroup, error) { +func (sm *ServiceManager) CreateVPCExplicitProtectionGroup(name string, switch1 string, switch2 string, vpcDomainPolicy string, fabricExplicitGEpattr models.VPCExplicitProtectionGroupAttributes) (*models.VPCExplicitProtectionGroup, error) { rn := fmt.Sprintf("fabric/protpol/expgep-%s", name) parentDn := fmt.Sprintf("uni") - fabricExplicitGEp := models.NewVPCExplicitProtectionGroup(rn, parentDn, description, fabricExplicitGEpattr) + fabricExplicitGEp := models.NewVPCExplicitProtectionGroup(rn, parentDn, fabricExplicitGEpattr) jsonPayload, _, err := sm.PrepareModel(fabricExplicitGEp) fabricNodePEp1 := []byte(fmt.Sprintf(` { @@ -81,10 +81,10 @@ func (sm *ServiceManager) DeleteVPCExplicitProtectionGroup(name string) error { return sm.DeleteByDn(dn, models.FabricexplicitgepClassName) } -func (sm *ServiceManager) UpdateVPCExplicitProtectionGroup(name string, description string, switch1 string, switch2 string, vpcDomainPolicy string, fabricExplicitGEpattr models.VPCExplicitProtectionGroupAttributes) (*models.VPCExplicitProtectionGroup, error) { +func (sm *ServiceManager) UpdateVPCExplicitProtectionGroup(name string, switch1 string, switch2 string, vpcDomainPolicy string, fabricExplicitGEpattr models.VPCExplicitProtectionGroupAttributes) (*models.VPCExplicitProtectionGroup, error) { rn := fmt.Sprintf("fabric/protpol/expgep-%s", name) parentDn := fmt.Sprintf("uni") - fabricExplicitGEp := models.NewVPCExplicitProtectionGroup(rn, parentDn, description, fabricExplicitGEpattr) + fabricExplicitGEp := models.NewVPCExplicitProtectionGroup(rn, parentDn, fabricExplicitGEpattr) fabricExplicitGEp.Status = "modified" jsonPayload, _, err := sm.PrepareModel(fabricExplicitGEp) diff --git a/client/hsrpSecVip_service.go b/client/hsrpSecVip_service.go new file mode 100644 index 00000000..e522a203 --- /dev/null +++ b/client/hsrpSecVip_service.go @@ -0,0 +1,53 @@ +package client + +import ( + "fmt" + + "github.com/ciscoecosystem/aci-go-client/models" +) + +func (sm *ServiceManager) CreateL3outHSRPSecondaryVIP(ip string, hsrp_group_profile string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string, description string, hsrpSecVipattr models.L3outHSRPSecondaryVIPAttributes) (*models.L3outHSRPSecondaryVIP, error) { + rn := fmt.Sprintf("hsrpSecVip-[%s]", ip) + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/hsrpIfP/hsrpGroupP-%s", tenant, l3_outside, logical_node_profile, logical_interface_profile, hsrp_group_profile) + hsrpSecVip := models.NewL3outHSRPSecondaryVIP(rn, parentDn, description, hsrpSecVipattr) + err := sm.Save(hsrpSecVip) + return hsrpSecVip, err +} + +func (sm *ServiceManager) ReadL3outHSRPSecondaryVIP(ip string, hsrp_group_profile string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) (*models.L3outHSRPSecondaryVIP, error) { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/hsrpIfP/hsrpGroupP-%s/hsrpSecVip-[%s]", tenant, l3_outside, logical_node_profile, logical_interface_profile, hsrp_group_profile, ip) + cont, err := sm.Get(dn) + if err != nil { + return nil, err + } + + hsrpSecVip := models.L3outHSRPSecondaryVIPFromContainer(cont) + return hsrpSecVip, nil +} + +func (sm *ServiceManager) DeleteL3outHSRPSecondaryVIP(ip string, hsrp_group_profile string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) error { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/hsrpIfP/hsrpGroupP-%s/hsrpSecVip-[%s]", tenant, l3_outside, logical_node_profile, logical_interface_profile, hsrp_group_profile, ip) + return sm.DeleteByDn(dn, models.HsrpsecvipClassName) +} + +func (sm *ServiceManager) UpdateL3outHSRPSecondaryVIP(ip string, hsrp_group_profile string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string, description string, hsrpSecVipattr models.L3outHSRPSecondaryVIPAttributes) (*models.L3outHSRPSecondaryVIP, error) { + rn := fmt.Sprintf("hsrpSecVip-[%s]", ip) + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/hsrpIfP/hsrpGroupP-%s", tenant, l3_outside, logical_node_profile, logical_interface_profile, hsrp_group_profile) + hsrpSecVip := models.NewL3outHSRPSecondaryVIP(rn, parentDn, description, hsrpSecVipattr) + + hsrpSecVip.Status = "modified" + err := sm.Save(hsrpSecVip) + return hsrpSecVip, err + +} + +func (sm *ServiceManager) ListL3outHSRPSecondaryVIP(hsrp_group_profile string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) ([]*models.L3outHSRPSecondaryVIP, error) { + + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/uni/tn-%s/out-%s/lnodep-%s/lifp-%s/hsrpIfP/hsrpGroupP-%s/hsrpSecVip.json", baseurlStr, tenant, l3_outside, logical_node_profile, logical_interface_profile, hsrp_group_profile) + + cont, err := sm.GetViaURL(dnUrl) + list := models.L3outHSRPSecondaryVIPListFromContainer(cont) + + return list, err +} diff --git a/client/ipNexthopP_service.go b/client/ipNexthopP_service.go new file mode 100644 index 00000000..3e7f5c51 --- /dev/null +++ b/client/ipNexthopP_service.go @@ -0,0 +1,155 @@ +package client + +import ( + "fmt" + + "github.com/ciscoecosystem/aci-go-client/container" + "github.com/ciscoecosystem/aci-go-client/models" +) + +func (sm *ServiceManager) CreateL3outStaticRouteNextHop(nhAddr string, static_route_ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string, description string, ipNexthopPattr models.L3outStaticRouteNextHopAttributes) (*models.L3outStaticRouteNextHop, error) { + rn := fmt.Sprintf("nh-[%s]", nhAddr) + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]/rt-[%s]", tenant, l3_outside, logical_node_profile, fabric_node_tDn, static_route_ip) + ipNexthopP := models.NewL3outStaticRouteNextHop(rn, parentDn, description, ipNexthopPattr) + err := sm.Save(ipNexthopP) + return ipNexthopP, err +} + +func (sm *ServiceManager) ReadL3outStaticRouteNextHop(nhAddr string, static_route_ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string) (*models.L3outStaticRouteNextHop, error) { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]/rt-[%s]/nh-[%s]", tenant, l3_outside, logical_node_profile, fabric_node_tDn, static_route_ip, nhAddr) + cont, err := sm.Get(dn) + if err != nil { + return nil, err + } + + ipNexthopP := models.L3outStaticRouteNextHopFromContainer(cont) + return ipNexthopP, nil +} + +func (sm *ServiceManager) DeleteL3outStaticRouteNextHop(nhAddr string, static_route_ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string) error { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]/rt-[%s]/nh-[%s]", tenant, l3_outside, logical_node_profile, fabric_node_tDn, static_route_ip, nhAddr) + return sm.DeleteByDn(dn, models.IpnexthoppClassName) +} + +func (sm *ServiceManager) UpdateL3outStaticRouteNextHop(nhAddr string, static_route_ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string, description string, ipNexthopPattr models.L3outStaticRouteNextHopAttributes) (*models.L3outStaticRouteNextHop, error) { + rn := fmt.Sprintf("nh-[%s]", nhAddr) + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]/rt-[%s]", tenant, l3_outside, logical_node_profile, fabric_node_tDn, static_route_ip) + ipNexthopP := models.NewL3outStaticRouteNextHop(rn, parentDn, description, ipNexthopPattr) + + ipNexthopP.Status = "modified" + err := sm.Save(ipNexthopP) + return ipNexthopP, err + +} + +func (sm *ServiceManager) ListL3outStaticRouteNextHop(static_route_ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string) ([]*models.L3outStaticRouteNextHop, error) { + + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]/rt-[%s]/ipNexthopP.json", baseurlStr, tenant, l3_outside, logical_node_profile, fabric_node_tDn, static_route_ip) + + cont, err := sm.GetViaURL(dnUrl) + list := models.L3outStaticRouteNextHopListFromContainer(cont) + + return list, err +} + +func (sm *ServiceManager) CreateRelationipRsNexthopRouteTrackFromL3outStaticRouteNextHop(parentDn, tDn string) error { + dn := fmt.Sprintf("%s/rsNexthopRouteTrack", parentDn) + containerJSON := []byte(fmt.Sprintf(`{ + "%s": { + "attributes": { + "dn": "%s", + "tDn": "%s", + "annotation":"orchestrator:terraform"} + } + }`, "ipRsNexthopRouteTrack", dn, tDn)) + + jsonPayload, err := container.ParseJSON(containerJSON) + if err != nil { + return err + } + + req, err := sm.client.MakeRestRequest("POST", fmt.Sprintf("%s.json", sm.MOURL), jsonPayload, true) + if err != nil { + return err + } + + cont, _, err := sm.client.Do(req) + if err != nil { + return err + } + fmt.Printf("%+v", cont) + + return nil +} + +func (sm *ServiceManager) DeleteRelationipRsNexthopRouteTrackFromL3outStaticRouteNextHop(parentDn string) error { + dn := fmt.Sprintf("%s/rsNexthopRouteTrack", parentDn) + return sm.DeleteByDn(dn, "ipRsNexthopRouteTrack") +} + +func (sm *ServiceManager) ReadRelationipRsNexthopRouteTrackFromL3outStaticRouteNextHop(parentDn string) (interface{}, error) { + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/%s/%s.json", baseurlStr, parentDn, "ipRsNexthopRouteTrack") + cont, err := sm.GetViaURL(dnUrl) + + contList := models.ListFromContainer(cont, "ipRsNexthopRouteTrack") + + if len(contList) > 0 { + dat := models.G(contList[0], "tDn") + return dat, err + } else { + return nil, err + } + +} +func (sm *ServiceManager) CreateRelationipRsNHTrackMemberFromL3outStaticRouteNextHop(parentDn, tDn string) error { + dn := fmt.Sprintf("%s/rsNHTrackMember", parentDn) + containerJSON := []byte(fmt.Sprintf(`{ + "%s": { + "attributes": { + "dn": "%s", + "tDn": "%s", + "annotation":"orchestrator:terraform"} + } + }`, "ipRsNHTrackMember", dn, tDn)) + + jsonPayload, err := container.ParseJSON(containerJSON) + if err != nil { + return err + } + + req, err := sm.client.MakeRestRequest("POST", fmt.Sprintf("%s.json", sm.MOURL), jsonPayload, true) + if err != nil { + return err + } + + cont, _, err := sm.client.Do(req) + if err != nil { + return err + } + fmt.Printf("%+v", cont) + + return nil +} + +func (sm *ServiceManager) DeleteRelationipRsNHTrackMemberFromL3outStaticRouteNextHop(parentDn string) error { + dn := fmt.Sprintf("%s/rsNHTrackMember", parentDn) + return sm.DeleteByDn(dn, "ipRsNHTrackMember") +} + +func (sm *ServiceManager) ReadRelationipRsNHTrackMemberFromL3outStaticRouteNextHop(parentDn string) (interface{}, error) { + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/%s/%s.json", baseurlStr, parentDn, "ipRsNHTrackMember") + cont, err := sm.GetViaURL(dnUrl) + + contList := models.ListFromContainer(cont, "ipRsNHTrackMember") + + if len(contList) > 0 { + dat := models.G(contList[0], "tDn") + return dat, err + } else { + return nil, err + } + +} diff --git a/client/ipRouteP_service.go b/client/ipRouteP_service.go new file mode 100644 index 00000000..6f22e87c --- /dev/null +++ b/client/ipRouteP_service.go @@ -0,0 +1,105 @@ +package client + +import ( + "fmt" + + "github.com/ciscoecosystem/aci-go-client/container" + "github.com/ciscoecosystem/aci-go-client/models" +) + +func (sm *ServiceManager) CreateL3outStaticRoute(ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string, description string, ipRoutePattr models.L3outStaticRouteAttributes) (*models.L3outStaticRoute, error) { + rn := fmt.Sprintf("rt-[%s]", ip) + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]", tenant, l3_outside, logical_node_profile, fabric_node_tDn) + ipRouteP := models.NewL3outStaticRoute(rn, parentDn, description, ipRoutePattr) + err := sm.Save(ipRouteP) + return ipRouteP, err +} + +func (sm *ServiceManager) ReadL3outStaticRoute(ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string) (*models.L3outStaticRoute, error) { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]/rt-[%s]", tenant, l3_outside, logical_node_profile, fabric_node_tDn, ip) + cont, err := sm.Get(dn) + if err != nil { + return nil, err + } + + ipRouteP := models.L3outStaticRouteFromContainer(cont) + return ipRouteP, nil +} + +func (sm *ServiceManager) DeleteL3outStaticRoute(ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string) error { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]/rt-[%s]", tenant, l3_outside, logical_node_profile, fabric_node_tDn, ip) + return sm.DeleteByDn(dn, models.IproutepClassName) +} + +func (sm *ServiceManager) UpdateL3outStaticRoute(ip string, fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string, description string, ipRoutePattr models.L3outStaticRouteAttributes) (*models.L3outStaticRoute, error) { + rn := fmt.Sprintf("rt-[%s]", ip) + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]", tenant, l3_outside, logical_node_profile, fabric_node_tDn) + ipRouteP := models.NewL3outStaticRoute(rn, parentDn, description, ipRoutePattr) + + ipRouteP.Status = "modified" + err := sm.Save(ipRouteP) + return ipRouteP, err + +} + +func (sm *ServiceManager) ListL3outStaticRoute(fabric_node_tDn string, logical_node_profile string, l3_outside string, tenant string) ([]*models.L3outStaticRoute, error) { + + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/uni/tn-%s/out-%s/lnodep-%s/rsnodeL3OutAtt-[%s]/ipRouteP.json", baseurlStr, tenant, l3_outside, logical_node_profile, fabric_node_tDn) + + cont, err := sm.GetViaURL(dnUrl) + list := models.L3outStaticRouteListFromContainer(cont) + + return list, err +} + +func (sm *ServiceManager) CreateRelationipRsRouteTrackFromL3outStaticRoute(parentDn, tDn string) error { + dn := fmt.Sprintf("%s/rsRouteTrack", parentDn) + containerJSON := []byte(fmt.Sprintf(`{ + "%s": { + "attributes": { + "dn": "%s", + "tDn": "%s", + "annotation":"orchestrator:terraform"} + } + }`, "ipRsRouteTrack", dn, tDn)) + + jsonPayload, err := container.ParseJSON(containerJSON) + if err != nil { + return err + } + + req, err := sm.client.MakeRestRequest("POST", fmt.Sprintf("%s.json", sm.MOURL), jsonPayload, true) + if err != nil { + return err + } + + cont, _, err := sm.client.Do(req) + if err != nil { + return err + } + fmt.Printf("%+v", cont) + + return nil +} + +func (sm *ServiceManager) DeleteRelationipRsRouteTrackFromL3outStaticRoute(parentDn string) error { + dn := fmt.Sprintf("%s/rsRouteTrack", parentDn) + return sm.DeleteByDn(dn, "ipRsRouteTrack") +} + +func (sm *ServiceManager) ReadRelationipRsRouteTrackFromL3outStaticRoute(parentDn string) (interface{}, error) { + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/%s/%s.json", baseurlStr, parentDn, "ipRsRouteTrack") + cont, err := sm.GetViaURL(dnUrl) + + contList := models.ListFromContainer(cont, "ipRsRouteTrack") + + if len(contList) > 0 { + dat := models.G(contList[0], "tDn") + return dat, err + } else { + return nil, err + } + +} diff --git a/client/l3extMember_service.go b/client/l3extMember_service.go new file mode 100644 index 00000000..430bb118 --- /dev/null +++ b/client/l3extMember_service.go @@ -0,0 +1,53 @@ +package client + +import ( + "fmt" + + "github.com/ciscoecosystem/aci-go-client/models" +) + +func (sm *ServiceManager) CreateL3outVPCMember(side string, leaf_port_tDn string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string, description string, l3extMemberattr models.L3outVPCMemberAttributes) (*models.L3outVPCMember, error) { + rn := fmt.Sprintf("mem-%s", side) + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/rspathL3OutAtt-[%s]", tenant, l3_outside, logical_node_profile, logical_interface_profile, leaf_port_tDn) + l3extMember := models.NewL3outVPCMember(rn, parentDn, description, l3extMemberattr) + err := sm.Save(l3extMember) + return l3extMember, err +} + +func (sm *ServiceManager) ReadL3outVPCMember(side string, leaf_port_tDn string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) (*models.L3outVPCMember, error) { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/rspathL3OutAtt-[%s]/mem-%s", tenant, l3_outside, logical_node_profile, logical_interface_profile, leaf_port_tDn, side) + cont, err := sm.Get(dn) + if err != nil { + return nil, err + } + + l3extMember := models.L3outVPCMemberFromContainer(cont) + return l3extMember, nil +} + +func (sm *ServiceManager) DeleteL3outVPCMember(side string, leaf_port_tDn string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) error { + dn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/rspathL3OutAtt-[%s]/mem-%s", tenant, l3_outside, logical_node_profile, logical_interface_profile, leaf_port_tDn, side) + return sm.DeleteByDn(dn, models.L3extmemberClassName) +} + +func (sm *ServiceManager) UpdateL3outVPCMember(side string, leaf_port_tDn string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string, description string, l3extMemberattr models.L3outVPCMemberAttributes) (*models.L3outVPCMember, error) { + rn := fmt.Sprintf("mem-%s", side) + parentDn := fmt.Sprintf("uni/tn-%s/out-%s/lnodep-%s/lifp-%s/rspathL3OutAtt-[%s]", tenant, l3_outside, logical_node_profile, logical_interface_profile, leaf_port_tDn) + l3extMember := models.NewL3outVPCMember(rn, parentDn, description, l3extMemberattr) + + l3extMember.Status = "modified" + err := sm.Save(l3extMember) + return l3extMember, err + +} + +func (sm *ServiceManager) ListL3outVPCMember(leaf_port_tDn string, logical_interface_profile string, logical_node_profile string, l3_outside string, tenant string) ([]*models.L3outVPCMember, error) { + + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/uni/tn-%s/out-%s/lnodep-%s/lifp-%s/rspathL3OutAtt-[%s]/l3extMember.json", baseurlStr, tenant, l3_outside, logical_node_profile, logical_interface_profile, leaf_port_tDn) + + cont, err := sm.GetViaURL(dnUrl) + list := models.L3outVPCMemberListFromContainer(cont) + + return list, err +} diff --git a/client/l3extRouteTagPol_service.go b/client/l3extRouteTagPol_service.go new file mode 100644 index 00000000..0b067aa4 --- /dev/null +++ b/client/l3extRouteTagPol_service.go @@ -0,0 +1,53 @@ +package client + +import ( + "fmt" + + "github.com/ciscoecosystem/aci-go-client/models" +) + +func (sm *ServiceManager) CreateL3outRouteTagPolicy(name string, tenant string, description string, l3extRouteTagPolattr models.L3outRouteTagPolicyAttributes) (*models.L3outRouteTagPolicy, error) { + rn := fmt.Sprintf("rttag-%s", name) + parentDn := fmt.Sprintf("uni/tn-%s", tenant) + l3extRouteTagPol := models.NewL3outRouteTagPolicy(rn, parentDn, description, l3extRouteTagPolattr) + err := sm.Save(l3extRouteTagPol) + return l3extRouteTagPol, err +} + +func (sm *ServiceManager) ReadL3outRouteTagPolicy(name string, tenant string) (*models.L3outRouteTagPolicy, error) { + dn := fmt.Sprintf("uni/tn-%s/rttag-%s", tenant, name) + cont, err := sm.Get(dn) + if err != nil { + return nil, err + } + + l3extRouteTagPol := models.L3outRouteTagPolicyFromContainer(cont) + return l3extRouteTagPol, nil +} + +func (sm *ServiceManager) DeleteL3outRouteTagPolicy(name string, tenant string) error { + dn := fmt.Sprintf("uni/tn-%s/rttag-%s", tenant, name) + return sm.DeleteByDn(dn, models.L3extroutetagpolClassName) +} + +func (sm *ServiceManager) UpdateL3outRouteTagPolicy(name string, tenant string, description string, l3extRouteTagPolattr models.L3outRouteTagPolicyAttributes) (*models.L3outRouteTagPolicy, error) { + rn := fmt.Sprintf("rttag-%s", name) + parentDn := fmt.Sprintf("uni/tn-%s", tenant) + l3extRouteTagPol := models.NewL3outRouteTagPolicy(rn, parentDn, description, l3extRouteTagPolattr) + + l3extRouteTagPol.Status = "modified" + err := sm.Save(l3extRouteTagPol) + return l3extRouteTagPol, err + +} + +func (sm *ServiceManager) ListL3outRouteTagPolicy(tenant string) ([]*models.L3outRouteTagPolicy, error) { + + baseurlStr := "/api/node/class" + dnUrl := fmt.Sprintf("%s/uni/tn-%s/l3extRouteTagPol.json", baseurlStr, tenant) + + cont, err := sm.GetViaURL(dnUrl) + list := models.L3outRouteTagPolicyListFromContainer(cont) + + return list, err +} diff --git a/models/bfd_if_p.go b/models/bfd_if_p.go new file mode 100644 index 00000000..ce18d597 --- /dev/null +++ b/models/bfd_if_p.go @@ -0,0 +1,106 @@ +package models + +import ( + "fmt" + "strconv" + + "github.com/ciscoecosystem/aci-go-client/container" +) + +const BfdifpClassName = "bfdIfP" + +type BFDInterfaceProfile struct { + BaseAttributes + BFDInterfaceProfileAttributes +} + +type BFDInterfaceProfileAttributes struct { + Annotation string `json:",omitempty"` + + Key string `json:",omitempty"` + + KeyId string `json:",omitempty"` + + NameAlias string `json:",omitempty"` + + InterfaceProfileType string `json:",omitempty"` +} + +func NewBFDInterfaceProfile(bfdIfPRn, parentDn, description string, bfdIfPattr BFDInterfaceProfileAttributes) *BFDInterfaceProfile { + dn := fmt.Sprintf("%s/%s", parentDn, bfdIfPRn) + return &BFDInterfaceProfile{ + BaseAttributes: BaseAttributes{ + DistinguishedName: dn, + Description: description, + Status: "created, modified", + ClassName: BfdifpClassName, + Rn: bfdIfPRn, + }, + + BFDInterfaceProfileAttributes: bfdIfPattr, + } +} + +func (bfdIfP *BFDInterfaceProfile) ToMap() (map[string]string, error) { + bfdIfPMap, err := bfdIfP.BaseAttributes.ToMap() + if err != nil { + return nil, err + } + + A(bfdIfPMap, "annotation", bfdIfP.Annotation) + + A(bfdIfPMap, "key", bfdIfP.Key) + + A(bfdIfPMap, "keyId", bfdIfP.KeyId) + + A(bfdIfPMap, "nameAlias", bfdIfP.NameAlias) + + A(bfdIfPMap, "type", bfdIfP.InterfaceProfileType) + + return bfdIfPMap, err +} + +func BFDInterfaceProfileFromContainerList(cont *container.Container, index int) *BFDInterfaceProfile { + + InterfaceProfileCont := cont.S("imdata").Index(index).S(BfdifpClassName, "attributes") + return &BFDInterfaceProfile{ + BaseAttributes{ + DistinguishedName: G(InterfaceProfileCont, "dn"), + Description: G(InterfaceProfileCont, "descr"), + Status: G(InterfaceProfileCont, "status"), + ClassName: BfdifpClassName, + Rn: G(InterfaceProfileCont, "rn"), + }, + + BFDInterfaceProfileAttributes{ + + Annotation: G(InterfaceProfileCont, "annotation"), + + Key: G(InterfaceProfileCont, "key"), + + KeyId: G(InterfaceProfileCont, "keyId"), + + NameAlias: G(InterfaceProfileCont, "nameAlias"), + + InterfaceProfileType: G(InterfaceProfileCont, "type"), + }, + } +} + +func BFDInterfaceProfileFromContainer(cont *container.Container) *BFDInterfaceProfile { + + return BFDInterfaceProfileFromContainerList(cont, 0) +} + +func BFDInterfaceProfileListFromContainer(cont *container.Container) []*BFDInterfaceProfile { + length, _ := strconv.Atoi(G(cont, "totalCount")) + + arr := make([]*BFDInterfaceProfile, length) + + for i := 0; i < length; i++ { + + arr[i] = BFDInterfaceProfileFromContainerList(cont, i) + } + + return arr +} diff --git a/models/bgp_prot_p.go b/models/bgp_prot_p.go new file mode 100644 index 00000000..6a561dc4 --- /dev/null +++ b/models/bgp_prot_p.go @@ -0,0 +1,86 @@ +package models + +import ( + "fmt" + "strconv" + + "github.com/ciscoecosystem/aci-go-client/container" +) + +const BgpprotpClassName = "bgpProtP" + +type L3outBGPProtocolProfile struct { + BaseAttributes + L3outBGPProtocolProfileAttributes +} + +type L3outBGPProtocolProfileAttributes struct { + Annotation string `json:",omitempty"` + + NameAlias string `json:",omitempty"` +} + +func NewL3outBGPProtocolProfile(bgpProtPRn, parentDn string, bgpProtPattr L3outBGPProtocolProfileAttributes) *L3outBGPProtocolProfile { + dn := fmt.Sprintf("%s/%s", parentDn, bgpProtPRn) + return &L3outBGPProtocolProfile{ + BaseAttributes: BaseAttributes{ + DistinguishedName: dn, + Status: "created, modified", + ClassName: BgpprotpClassName, + Rn: bgpProtPRn, + }, + + L3outBGPProtocolProfileAttributes: bgpProtPattr, + } +} + +func (bgpProtP *L3outBGPProtocolProfile) ToMap() (map[string]string, error) { + bgpProtPMap, err := bgpProtP.BaseAttributes.ToMap() + if err != nil { + return nil, err + } + + A(bgpProtPMap, "annotation", bgpProtP.Annotation) + + A(bgpProtPMap, "nameAlias", bgpProtP.NameAlias) + + return bgpProtPMap, err +} + +func L3outBGPProtocolProfileFromContainerList(cont *container.Container, index int) *L3outBGPProtocolProfile { + + L3outBGPProtocolProfileCont := cont.S("imdata").Index(index).S(BgpprotpClassName, "attributes") + return &L3outBGPProtocolProfile{ + BaseAttributes{ + DistinguishedName: G(L3outBGPProtocolProfileCont, "dn"), + Status: G(L3outBGPProtocolProfileCont, "status"), + ClassName: BgpprotpClassName, + Rn: G(L3outBGPProtocolProfileCont, "rn"), + }, + + L3outBGPProtocolProfileAttributes{ + + Annotation: G(L3outBGPProtocolProfileCont, "annotation"), + + NameAlias: G(L3outBGPProtocolProfileCont, "nameAlias"), + }, + } +} + +func L3outBGPProtocolProfileFromContainer(cont *container.Container) *L3outBGPProtocolProfile { + + return L3outBGPProtocolProfileFromContainerList(cont, 0) +} + +func L3outBGPProtocolProfileListFromContainer(cont *container.Container) []*L3outBGPProtocolProfile { + length, _ := strconv.Atoi(G(cont, "totalCount")) + + arr := make([]*L3outBGPProtocolProfile, length) + + for i := 0; i < length; i++ { + + arr[i] = L3outBGPProtocolProfileFromContainerList(cont, i) + } + + return arr +} diff --git a/models/fabric_explicit_g_ep.go b/models/fabric_explicit_g_ep.go index 2bc43e2a..417337e4 100644 --- a/models/fabric_explicit_g_ep.go +++ b/models/fabric_explicit_g_ep.go @@ -25,12 +25,11 @@ type VPCExplicitProtectionGroupAttributes struct { VpcDomainPolicy string `json:",omitempty"` } -func NewVPCExplicitProtectionGroup(fabricExplicitGEpRn, parentDn, description string, fabricExplicitGEpattr VPCExplicitProtectionGroupAttributes) *VPCExplicitProtectionGroup { +func NewVPCExplicitProtectionGroup(fabricExplicitGEpRn, parentDn string, fabricExplicitGEpattr VPCExplicitProtectionGroupAttributes) *VPCExplicitProtectionGroup { dn := fmt.Sprintf("%s/%s", parentDn, fabricExplicitGEpRn) return &VPCExplicitProtectionGroup{ BaseAttributes: BaseAttributes{ DistinguishedName: dn, - Description: description, Status: "created, modified", ClassName: FabricexplicitgepClassName, Rn: fabricExplicitGEpRn, @@ -82,7 +81,6 @@ func VPCExplicitProtectionGroupFromContainerList(cont *container.Container, inde return &VPCExplicitProtectionGroup{ BaseAttributes{ DistinguishedName: G(VPCExplicitProtectionGroupCont, "dn"), - Description: G(VPCExplicitProtectionGroupCont, "descr"), Status: G(VPCExplicitProtectionGroupCont, "status"), ClassName: FabricexplicitgepClassName, Rn: G(VPCExplicitProtectionGroupCont, "rn"), diff --git a/models/hsrp_sec_vip.go b/models/hsrp_sec_vip.go new file mode 100644 index 00000000..926ee289 --- /dev/null +++ b/models/hsrp_sec_vip.go @@ -0,0 +1,100 @@ +package models + +import ( + "fmt" + "strconv" + + "github.com/ciscoecosystem/aci-go-client/container" +) + +const HsrpsecvipClassName = "hsrpSecVip" + +type L3outHSRPSecondaryVIP struct { + BaseAttributes + L3outHSRPSecondaryVIPAttributes +} + +type L3outHSRPSecondaryVIPAttributes struct { + Ip string `json:",omitempty"` + + Annotation string `json:",omitempty"` + + ConfigIssues string `json:",omitempty"` + + NameAlias string `json:",omitempty"` +} + +func NewL3outHSRPSecondaryVIP(hsrpSecVipRn, parentDn, description string, hsrpSecVipattr L3outHSRPSecondaryVIPAttributes) *L3outHSRPSecondaryVIP { + dn := fmt.Sprintf("%s/%s", parentDn, hsrpSecVipRn) + return &L3outHSRPSecondaryVIP{ + BaseAttributes: BaseAttributes{ + DistinguishedName: dn, + Description: description, + Status: "created, modified", + ClassName: HsrpsecvipClassName, + Rn: hsrpSecVipRn, + }, + + L3outHSRPSecondaryVIPAttributes: hsrpSecVipattr, + } +} + +func (hsrpSecVip *L3outHSRPSecondaryVIP) ToMap() (map[string]string, error) { + hsrpSecVipMap, err := hsrpSecVip.BaseAttributes.ToMap() + if err != nil { + return nil, err + } + + A(hsrpSecVipMap, "ip", hsrpSecVip.Ip) + + A(hsrpSecVipMap, "annotation", hsrpSecVip.Annotation) + + A(hsrpSecVipMap, "configIssues", hsrpSecVip.ConfigIssues) + + A(hsrpSecVipMap, "nameAlias", hsrpSecVip.NameAlias) + + return hsrpSecVipMap, err +} + +func L3outHSRPSecondaryVIPFromContainerList(cont *container.Container, index int) *L3outHSRPSecondaryVIP { + + L3outHSRPSecondaryVIPCont := cont.S("imdata").Index(index).S(HsrpsecvipClassName, "attributes") + return &L3outHSRPSecondaryVIP{ + BaseAttributes{ + DistinguishedName: G(L3outHSRPSecondaryVIPCont, "dn"), + Description: G(L3outHSRPSecondaryVIPCont, "descr"), + Status: G(L3outHSRPSecondaryVIPCont, "status"), + ClassName: HsrpsecvipClassName, + Rn: G(L3outHSRPSecondaryVIPCont, "rn"), + }, + + L3outHSRPSecondaryVIPAttributes{ + + Ip: G(L3outHSRPSecondaryVIPCont, "ip"), + + Annotation: G(L3outHSRPSecondaryVIPCont, "annotation"), + + ConfigIssues: G(L3outHSRPSecondaryVIPCont, "configIssues"), + + NameAlias: G(L3outHSRPSecondaryVIPCont, "nameAlias"), + }, + } +} + +func L3outHSRPSecondaryVIPFromContainer(cont *container.Container) *L3outHSRPSecondaryVIP { + + return L3outHSRPSecondaryVIPFromContainerList(cont, 0) +} + +func L3outHSRPSecondaryVIPListFromContainer(cont *container.Container) []*L3outHSRPSecondaryVIP { + length, _ := strconv.Atoi(G(cont, "totalCount")) + + arr := make([]*L3outHSRPSecondaryVIP, length) + + for i := 0; i < length; i++ { + + arr[i] = L3outHSRPSecondaryVIPFromContainerList(cont, i) + } + + return arr +} diff --git a/models/ip_nexthop_p.go b/models/ip_nexthop_p.go new file mode 100644 index 00000000..34173138 --- /dev/null +++ b/models/ip_nexthop_p.go @@ -0,0 +1,106 @@ +package models + +import ( + "fmt" + "strconv" + + "github.com/ciscoecosystem/aci-go-client/container" +) + +const IpnexthoppClassName = "ipNexthopP" + +type L3outStaticRouteNextHop struct { + BaseAttributes + L3outStaticRouteNextHopAttributes +} + +type L3outStaticRouteNextHopAttributes struct { + NhAddr string `json:",omitempty"` + + Annotation string `json:",omitempty"` + + NameAlias string `json:",omitempty"` + + Pref string `json:",omitempty"` + + NexthopProfile_type string `json:",omitempty"` +} + +func NewL3outStaticRouteNextHop(ipNexthopPRn, parentDn, description string, ipNexthopPattr L3outStaticRouteNextHopAttributes) *L3outStaticRouteNextHop { + dn := fmt.Sprintf("%s/%s", parentDn, ipNexthopPRn) + return &L3outStaticRouteNextHop{ + BaseAttributes: BaseAttributes{ + DistinguishedName: dn, + Description: description, + Status: "created, modified", + ClassName: IpnexthoppClassName, + Rn: ipNexthopPRn, + }, + + L3outStaticRouteNextHopAttributes: ipNexthopPattr, + } +} + +func (ipNexthopP *L3outStaticRouteNextHop) ToMap() (map[string]string, error) { + ipNexthopPMap, err := ipNexthopP.BaseAttributes.ToMap() + if err != nil { + return nil, err + } + + A(ipNexthopPMap, "nhAddr", ipNexthopP.NhAddr) + + A(ipNexthopPMap, "annotation", ipNexthopP.Annotation) + + A(ipNexthopPMap, "nameAlias", ipNexthopP.NameAlias) + + A(ipNexthopPMap, "pref", ipNexthopP.Pref) + + A(ipNexthopPMap, "type", ipNexthopP.NexthopProfile_type) + + return ipNexthopPMap, err +} + +func L3outStaticRouteNextHopFromContainerList(cont *container.Container, index int) *L3outStaticRouteNextHop { + + L3outStaticRouteNextHopCont := cont.S("imdata").Index(index).S(IpnexthoppClassName, "attributes") + return &L3outStaticRouteNextHop{ + BaseAttributes{ + DistinguishedName: G(L3outStaticRouteNextHopCont, "dn"), + Description: G(L3outStaticRouteNextHopCont, "descr"), + Status: G(L3outStaticRouteNextHopCont, "status"), + ClassName: IpnexthoppClassName, + Rn: G(L3outStaticRouteNextHopCont, "rn"), + }, + + L3outStaticRouteNextHopAttributes{ + + NhAddr: G(L3outStaticRouteNextHopCont, "nhAddr"), + + Annotation: G(L3outStaticRouteNextHopCont, "annotation"), + + NameAlias: G(L3outStaticRouteNextHopCont, "nameAlias"), + + Pref: G(L3outStaticRouteNextHopCont, "pref"), + + NexthopProfile_type: G(L3outStaticRouteNextHopCont, "type"), + }, + } +} + +func L3outStaticRouteNextHopFromContainer(cont *container.Container) *L3outStaticRouteNextHop { + + return L3outStaticRouteNextHopFromContainerList(cont, 0) +} + +func L3outStaticRouteNextHopListFromContainer(cont *container.Container) []*L3outStaticRouteNextHop { + length, _ := strconv.Atoi(G(cont, "totalCount")) + + arr := make([]*L3outStaticRouteNextHop, length) + + for i := 0; i < length; i++ { + + arr[i] = L3outStaticRouteNextHopFromContainerList(cont, i) + } + + return arr +} diff --git a/models/ip_route_p.go b/models/ip_route_p.go new file mode 100644 index 00000000..0e0db746 --- /dev/null +++ b/models/ip_route_p.go @@ -0,0 +1,112 @@ +package models + +import ( + "fmt" + "strconv" + + "github.com/ciscoecosystem/aci-go-client/container" +) + +const IproutepClassName = "ipRouteP" + +type L3outStaticRoute struct { + BaseAttributes + L3outStaticRouteAttributes +} + +type L3outStaticRouteAttributes struct { + Ip string `json:",omitempty"` + + Aggregate string `json:",omitempty"` + + Annotation string `json:",omitempty"` + + NameAlias string `json:",omitempty"` + + Pref string `json:",omitempty"` + + RtCtrl string `json:",omitempty"` +} + +func NewL3outStaticRoute(ipRoutePRn, parentDn, description string, ipRoutePattr L3outStaticRouteAttributes) *L3outStaticRoute { + dn := fmt.Sprintf("%s/%s", parentDn, ipRoutePRn) + return &L3outStaticRoute{ + BaseAttributes: BaseAttributes{ + DistinguishedName: dn, + Description: description, + Status: "created, modified", + ClassName: IproutepClassName, + Rn: ipRoutePRn, + }, + + L3outStaticRouteAttributes: ipRoutePattr, + } +} + +func (ipRouteP *L3outStaticRoute) ToMap() (map[string]string, error) { + ipRoutePMap, err := ipRouteP.BaseAttributes.ToMap() + if err != nil { + return nil, err + } + + A(ipRoutePMap, "ip", ipRouteP.Ip) + + A(ipRoutePMap, "aggregate", ipRouteP.Aggregate) + + A(ipRoutePMap, "annotation", ipRouteP.Annotation) + + A(ipRoutePMap, "nameAlias", ipRouteP.NameAlias) + + A(ipRoutePMap, "pref", ipRouteP.Pref) + + A(ipRoutePMap, "rtCtrl", ipRouteP.RtCtrl) + + return ipRoutePMap, err +} + +func L3outStaticRouteFromContainerList(cont *container.Container, index int) *L3outStaticRoute { + + L3outStaticRouteCont := cont.S("imdata").Index(index).S(IproutepClassName, "attributes") + return &L3outStaticRoute{ + BaseAttributes{ + DistinguishedName: G(L3outStaticRouteCont, "dn"), + Description: G(L3outStaticRouteCont, "descr"), + Status: G(L3outStaticRouteCont, "status"), + ClassName: IproutepClassName, + Rn: G(L3outStaticRouteCont, "rn"), + }, + + L3outStaticRouteAttributes{ + + Ip: G(L3outStaticRouteCont, "ip"), + + Aggregate: G(L3outStaticRouteCont, "aggregate"), + + Annotation: G(L3outStaticRouteCont, "annotation"), + + NameAlias: G(L3outStaticRouteCont, "nameAlias"), + + Pref: G(L3outStaticRouteCont, "pref"), + + RtCtrl: G(L3outStaticRouteCont, "rtCtrl"), + }, + } +} + +func L3outStaticRouteFromContainer(cont *container.Container) *L3outStaticRoute { + + return L3outStaticRouteFromContainerList(cont, 0) +} + +func L3outStaticRouteListFromContainer(cont *container.Container) []*L3outStaticRoute { + length, _ := strconv.Atoi(G(cont, "totalCount")) + + arr := make([]*L3outStaticRoute, length) + + for i := 0; i < length; i++ { + + arr[i] = L3outStaticRouteFromContainerList(cont, i) + } + + return arr +} diff --git a/models/l3ext_member.go b/models/l3ext_member.go new file mode 100644 index 00000000..fc98a50b --- /dev/null +++ b/models/l3ext_member.go @@ -0,0 +1,112 @@ +package models + +import ( + "fmt" + "strconv" + + "github.com/ciscoecosystem/aci-go-client/container" +) + +const L3extmemberClassName = "l3extMember" + +type L3outVPCMember struct { + BaseAttributes + L3outVPCMemberAttributes +} + +type L3outVPCMemberAttributes struct { + Side string `json:",omitempty"` + + Addr string `json:",omitempty"` + + Annotation string `json:",omitempty"` + + Ipv6Dad string `json:",omitempty"` + + LlAddr string `json:",omitempty"` + + NameAlias string `json:",omitempty"` +} + +func NewL3outVPCMember(l3extMemberRn, parentDn, description string, l3extMemberattr L3outVPCMemberAttributes) *L3outVPCMember { + dn := fmt.Sprintf("%s/%s", parentDn, l3extMemberRn) + return &L3outVPCMember{ + BaseAttributes: BaseAttributes{ + DistinguishedName: dn, + Description: description, + Status: "created, modified", + ClassName: L3extmemberClassName, + Rn: l3extMemberRn, + }, + + L3outVPCMemberAttributes: l3extMemberattr, + } +} + +func (l3extMember *L3outVPCMember) ToMap() (map[string]string, error) { + l3extMemberMap, err := l3extMember.BaseAttributes.ToMap() + if err != nil { + return nil, err + } + + A(l3extMemberMap, "side", l3extMember.Side) + + A(l3extMemberMap, "addr", l3extMember.Addr) + + A(l3extMemberMap, "annotation", l3extMember.Annotation) + + A(l3extMemberMap, "ipv6Dad", l3extMember.Ipv6Dad) + + A(l3extMemberMap, "llAddr", l3extMember.LlAddr) + + A(l3extMemberMap, "nameAlias", l3extMember.NameAlias) + + return l3extMemberMap, err +} + +func L3outVPCMemberFromContainerList(cont *container.Container, index int) *L3outVPCMember { + + L3outVPCMemberCont := cont.S("imdata").Index(index).S(L3extmemberClassName, "attributes") + return &L3outVPCMember{ + BaseAttributes{ + DistinguishedName: G(L3outVPCMemberCont, "dn"), + Description: G(L3outVPCMemberCont, "descr"), + Status: G(L3outVPCMemberCont, "status"), + ClassName: L3extmemberClassName, + Rn: G(L3outVPCMemberCont, "rn"), + }, + + L3outVPCMemberAttributes{ + + Side: G(L3outVPCMemberCont, "side"), + + Addr: G(L3outVPCMemberCont, "addr"), + + Annotation: G(L3outVPCMemberCont, "annotation"), + + Ipv6Dad: G(L3outVPCMemberCont, "ipv6Dad"), + + LlAddr: G(L3outVPCMemberCont, "llAddr"), + + NameAlias: G(L3outVPCMemberCont, "nameAlias"), + }, + } +} + +func L3outVPCMemberFromContainer(cont *container.Container) *L3outVPCMember { + + return L3outVPCMemberFromContainerList(cont, 0) +} + +func L3outVPCMemberListFromContainer(cont *container.Container) []*L3outVPCMember { + length, _ := strconv.Atoi(G(cont, "totalCount")) + + arr := make([]*L3outVPCMember, length) + + for i := 0; i < length; i++ { + + arr[i] = L3outVPCMemberFromContainerList(cont, i) + } + + return arr +} diff --git a/models/l3ext_route_tag_pol.go b/models/l3ext_route_tag_pol.go new file mode 100644 index 00000000..ba6c9f4b --- /dev/null +++ b/models/l3ext_route_tag_pol.go @@ -0,0 +1,100 @@ +package models + +import ( + "fmt" + "strconv" + + "github.com/ciscoecosystem/aci-go-client/container" +) + +const L3extroutetagpolClassName = "l3extRouteTagPol" + +type L3outRouteTagPolicy struct { + BaseAttributes + L3outRouteTagPolicyAttributes +} + +type L3outRouteTagPolicyAttributes struct { + Name string `json:",omitempty"` + + Annotation string `json:",omitempty"` + + NameAlias string `json:",omitempty"` + + Tag string `json:",omitempty"` +} + +func NewL3outRouteTagPolicy(l3extRouteTagPolRn, parentDn, description string, l3extRouteTagPolattr L3outRouteTagPolicyAttributes) *L3outRouteTagPolicy { + dn := fmt.Sprintf("%s/%s", parentDn, l3extRouteTagPolRn) + return &L3outRouteTagPolicy{ + BaseAttributes: BaseAttributes{ + DistinguishedName: dn, + Description: description, + Status: "created, modified", + ClassName: L3extroutetagpolClassName, + Rn: l3extRouteTagPolRn, + }, + + L3outRouteTagPolicyAttributes: l3extRouteTagPolattr, + } +} + +func (l3extRouteTagPol *L3outRouteTagPolicy) ToMap() (map[string]string, error) { + l3extRouteTagPolMap, err := l3extRouteTagPol.BaseAttributes.ToMap() + if err != nil { + return nil, err + } + + A(l3extRouteTagPolMap, "name", l3extRouteTagPol.Name) + + A(l3extRouteTagPolMap, "annotation", l3extRouteTagPol.Annotation) + + A(l3extRouteTagPolMap, "nameAlias", l3extRouteTagPol.NameAlias) + + A(l3extRouteTagPolMap, "tag", l3extRouteTagPol.Tag) + + return l3extRouteTagPolMap, err +} + +func L3outRouteTagPolicyFromContainerList(cont *container.Container, index int) *L3outRouteTagPolicy { + + L3outRouteTagPolicyCont := cont.S("imdata").Index(index).S(L3extroutetagpolClassName, "attributes") + return &L3outRouteTagPolicy{ + BaseAttributes{ + DistinguishedName: G(L3outRouteTagPolicyCont, "dn"), + Description: G(L3outRouteTagPolicyCont, "descr"), + Status: G(L3outRouteTagPolicyCont, "status"), + ClassName: L3extroutetagpolClassName, + Rn: G(L3outRouteTagPolicyCont, "rn"), + }, + + L3outRouteTagPolicyAttributes{ + + Name: G(L3outRouteTagPolicyCont, "name"), + + Annotation: G(L3outRouteTagPolicyCont, "annotation"), + + NameAlias: G(L3outRouteTagPolicyCont, "nameAlias"), + + Tag: G(L3outRouteTagPolicyCont, "tag"), + }, + } +} + +func L3outRouteTagPolicyFromContainer(cont *container.Container) *L3outRouteTagPolicy { + + return L3outRouteTagPolicyFromContainerList(cont, 0) +} + +func L3outRouteTagPolicyListFromContainer(cont *container.Container) []*L3outRouteTagPolicy { + length, _ := strconv.Atoi(G(cont, "totalCount")) + + arr := make([]*L3outRouteTagPolicy, length) + + for i := 0; i < length; i++ { + + arr[i] = L3outRouteTagPolicyFromContainerList(cont, i) + } + + return arr +} diff --git a/models/l3ext_virtual_l_if_p.go b/models/l3ext_virtual_l_if_p.go index 4323c14b..c70fd1a6 100644 --- a/models/l3ext_virtual_l_if_p.go +++ b/models/l3ext_virtual_l_if_p.go @@ -40,8 +40,6 @@ type VirtualLogicalInterfaceProfileAttributes struct { Mtu string `json:",omitempty"` TargetDscp string `json:",omitempty"` - - Userdom string `json:",omitempty"` } func NewVirtualLogicalInterfaceProfile(l3extVirtualLIfPRn, parentDn, description string, l3extVirtualLIfPattr VirtualLogicalInterfaceProfileAttributes) *VirtualLogicalInterfaceProfile { @@ -91,8 +89,6 @@ func (l3extVirtualLIfP *VirtualLogicalInterfaceProfile) ToMap() (map[string]stri A(l3extVirtualLIfPMap, "targetDscp", l3extVirtualLIfP.TargetDscp) - A(l3extVirtualLIfPMap, "userdom", l3extVirtualLIfP.Userdom) - return l3extVirtualLIfPMap, err } @@ -135,8 +131,6 @@ func VirtualLogicalInterfaceProfileFromContainerList(cont *container.Container, Mtu: G(VirtualLogicalInterfaceProfileCont, "mtu"), TargetDscp: G(VirtualLogicalInterfaceProfileCont, "targetDscp"), - - Userdom: G(VirtualLogicalInterfaceProfileCont, "userdom"), }, } }