+ public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> buildStateInterfaceId(String interfaceName) {
+ InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> idBuilder =
+ InstanceIdentifier.builder(InterfacesState.class)
+ .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class,
+ new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey(
+ interfaceName));
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> id = idBuilder.build();
+ return id;
+}
+ public static Boolean readMonitoringStateFromDS(DataBroker dataBroker) {
+ InstanceIdentifier<TunnelMonitorEnabled> iid = InstanceIdentifier.create(TunnelMonitorEnabled.class);
+ Optional<TunnelMonitorEnabled> tunnelMonitorEnabledOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
+ iid, dataBroker);
+ if(tunnelMonitorEnabledOptional.isPresent())
+ return tunnelMonitorEnabledOptional.get().isEnabled();
+ return null;
+ }
+
+ public static Integer readMonitorIntervalfromDS(DataBroker dataBroker) {
+ InstanceIdentifier<TunnelMonitorInterval> iid = InstanceIdentifier.create(TunnelMonitorInterval.class);
+ Optional<TunnelMonitorInterval> tunnelMonitorIOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, iid, dataBroker);
+ if(tunnelMonitorIOptional.isPresent())
+ return tunnelMonitorIOptional.get().getInterval();
+ return null;
+ }
+ public static List<String> getTunnelsofTzone(List<HwVtep> hwVteps, String tzone, DataBroker dataBroker, Boolean hwVtepsExist) {
+ List<String> tunnels = new ArrayList<String>();
+ InstanceIdentifier<TransportZone> path = InstanceIdentifier.builder(TransportZones.class).
+ child(TransportZone.class, new TransportZoneKey(tzone)).build();
+ Optional<TransportZone> tZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
+ Class<? extends TunnelTypeBase> tunType = tZoneOptional.get().getTunnelType();
+ if (tZoneOptional.isPresent()) {
+ if (tZoneOptional.get().getSubnets() != null && !tZoneOptional.get().getSubnets().isEmpty()) {
+ for (Subnets sub : tZoneOptional.get().getSubnets()) {
+ if (sub.getVteps() != null && !sub.getVteps().isEmpty()) {
+ for (Vteps vtepLocal : sub.getVteps()) {
+ for (Vteps vtepRemote : sub.getVteps()) {
+ if (!vtepLocal.equals(vtepRemote)) {
+ InternalTunnelKey key = new InternalTunnelKey(vtepRemote.getDpnId(), vtepLocal.getDpnId(), tunType);
+ InstanceIdentifier<InternalTunnel> intIID =
+ InstanceIdentifier.builder(TunnelList.class).
+ child(InternalTunnel.class, key).build();
+ Optional<InternalTunnel> TunnelsOptional =
+ ItmUtils.read(LogicalDatastoreType.CONFIGURATION, intIID, dataBroker);
+ if (TunnelsOptional.isPresent()) {
+ LOG.trace("Internal Tunnel added {}",TunnelsOptional.get().getTunnelInterfaceName());
+ tunnels.add(TunnelsOptional.get().getTunnelInterfaceName());
+ }
+ }
+ }
+ if(hwVteps!= null && !hwVteps.isEmpty()) {
+ for (HwVtep hwVtep : hwVteps) {
+ tunnels.add(getExtTunnel(hwVtep.getNode_id(), vtepLocal.getDpnId().toString(),
+ tunType, dataBroker));
+ tunnels.add(getExtTunnel(vtepLocal.getDpnId().toString(), hwVtep.getNode_id(),
+ tunType, dataBroker));
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if (hwVtepsExist) {
+ for (HwVtep hwVtep : hwVteps) {
+ for (HwVtep hwVtepOther : hwVteps) {
+ if (!hwVtep.getHwIp().equals(hwVtepOther.getHwIp())) {
+ tunnels.add(getExtTunnel(hwVtep.getNode_id(), hwVtepOther.getNode_id(), tunType, dataBroker));
+ tunnels.add(getExtTunnel(hwVtepOther.getNode_id(), hwVtep.getNode_id(), tunType, dataBroker));
+ }
+ }
+ }
+ }
+ return tunnels;
+ }
+ public static List<String> getInternalTunnelsofTzone(String tzone, DataBroker dataBroker) {
+ List<String> tunnels = new ArrayList<String>();
+ LOG.trace("Getting internal tunnels of {}",tzone);
+ InstanceIdentifier<TransportZone> path = InstanceIdentifier.builder(TransportZones.class).
+ child(TransportZone.class, new TransportZoneKey(tzone)).build();
+ Optional<TransportZone> tZoneOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION, path, dataBroker);
+ if (tZoneOptional.isPresent()) {
+ if (tZoneOptional.get().getSubnets() != null && !tZoneOptional.get().getSubnets().isEmpty()) {
+ for (Subnets sub : tZoneOptional.get().getSubnets()) {
+ if (sub.getVteps() != null && !sub.getVteps().isEmpty()) {
+ for (Vteps vtepLocal : sub.getVteps()) {
+ for (Vteps vtepRemote : sub.getVteps()) {
+ if (!vtepLocal.equals(vtepRemote)) {
+ InternalTunnelKey key = new InternalTunnelKey(vtepRemote.getDpnId(), vtepLocal.getDpnId(), tZoneOptional.get().getTunnelType());
+ InstanceIdentifier<InternalTunnel> intIID =
+ InstanceIdentifier.builder(TunnelList.class).
+ child(InternalTunnel.class, key).build();
+ Optional<InternalTunnel> TunnelsOptional =
+ ItmUtils.read(LogicalDatastoreType.CONFIGURATION, intIID, dataBroker);
+ if (TunnelsOptional.isPresent()) {
+ LOG.trace("Internal Tunnel added {}",
+ TunnelsOptional.get().getTunnelInterfaceName());
+ tunnels.add(TunnelsOptional.get().getTunnelInterfaceName());
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ return tunnels;
+ }
+ private static String getExtTunnel(String node_id, String dpId,Class<? extends TunnelTypeBase> tunType, DataBroker dataBroker) {
+ LOG.trace("getting ext tunnel for {} and dpId {}",node_id,dpId);
+ ExternalTunnelKey key = getExternalTunnelKey(dpId,node_id, tunType);
+ InstanceIdentifier<ExternalTunnel> intIID = InstanceIdentifier.builder(ExternalTunnelList.class).
+ child(ExternalTunnel.class, key).build();
+ Optional<ExternalTunnel> TunnelsOptional =
+ ItmUtils.read(LogicalDatastoreType.CONFIGURATION, intIID, dataBroker);
+ if (TunnelsOptional.isPresent()) {
+ LOG.trace("ext tunnel returned {} ",TunnelsOptional.get().getTunnelInterfaceName());
+ return TunnelsOptional.get().getTunnelInterfaceName();
+ }
+ return null;
+ }
+ public static ExternalTunnelKey getExternalTunnelKey(String dst , String src, Class<? extends TunnelTypeBase> tunType) {
+ if (src.indexOf("physicalswitch") > 0) {
+ src = src.substring(0, src.indexOf("physicalswitch") - 1);
+ }
+ if (dst.indexOf("physicalswitch") > 0) {
+ dst = dst.substring(0, dst.indexOf("physicalswitch") - 1);
+ }
+ return new ExternalTunnelKey(dst, src, tunType);
+ }
+ public static List<TunnelEndPoints> getTEPsForDpn( BigInteger srcDpn, List<DPNTEPsInfo> dpnList) {
+ for (DPNTEPsInfo dpn : dpnList) {
+ if( dpn.getDPNID().equals(srcDpn)) {
+ return dpn.getTunnelEndPoints() ;
+ }
+ }
+ return null ;
+ }
+ public static TunnelList getAllInternalTunnels(DataBroker broker) {
+ InstanceIdentifier<TunnelList> tunnelListInstanceIdentifier = InstanceIdentifier.builder(TunnelList.class).build();
+ Optional<TunnelList> tunnelList = read(LogicalDatastoreType.CONFIGURATION, tunnelListInstanceIdentifier, broker);
+ if (tunnelList.isPresent()) {
+ return tunnelList.get();
+ }
+ return null;
+ }
+ public static InternalTunnel getInternalTunnel(String interfaceName, DataBroker broker) {
+ InternalTunnel internalTunnel = null;
+ TunnelList tunnelList = getAllInternalTunnels(broker);
+ if (tunnelList != null && tunnelList.getInternalTunnel() != null) {
+ List<InternalTunnel> internalTunnels = tunnelList.getInternalTunnel();
+ for (InternalTunnel tunnel : internalTunnels) {
+ if (tunnel.getTunnelInterfaceName().equalsIgnoreCase(interfaceName)) {
+ internalTunnel = tunnel;
+ break;
+ }
+ }
+ }
+ return internalTunnel;
+ }
+ public static ExternalTunnel getExternalTunnel(String interfaceName, DataBroker broker) {
+ ExternalTunnel externalTunnel = null;
+ List<ExternalTunnel> externalTunnels = getAllExternalTunnels(broker);
+ for (ExternalTunnel tunnel : externalTunnels) {
+ if (StringUtils.equalsIgnoreCase(interfaceName, tunnel.getTunnelInterfaceName())) {
+ externalTunnel = tunnel;
+ break;
+ }
+ }
+ return externalTunnel;
+ }
+ public static List<ExternalTunnel> getAllExternalTunnels(DataBroker broker) {
+ List<ExternalTunnel> result = null;
+ InstanceIdentifier<ExternalTunnelList> id = InstanceIdentifier.builder(ExternalTunnelList.class).build();
+ Optional<ExternalTunnelList> tunnelList = read(LogicalDatastoreType.CONFIGURATION, id, broker);
+ if (tunnelList.isPresent()) {
+ result = tunnelList.get().getExternalTunnel();
+ }
+ if (result == null) {
+ result = Collections.emptyList();
+ }
+ return result;
+ }
+ public static String convertTunnelTypetoString(Class<? extends TunnelTypeBase> tunType ) {
+ String tunnelType = ITMConstants.TUNNEL_TYPE_VXLAN;
+ if( tunType.equals(TunnelTypeVxlan.class))
+ tunnelType = ITMConstants.TUNNEL_TYPE_VXLAN ;
+ else if( tunType.equals(TunnelTypeGre.class) )
+ tunnelType = ITMConstants.TUNNEL_TYPE_GRE ;
+ else if (tunnelType.equals(TunnelTypeMplsOverGre.class))
+ tunnelType = ITMConstants.TUNNEL_TYPE_MPLS_OVER_GRE;
+ return tunnelType ;
+ }
+ public static boolean isItmIfType(Class<? extends InterfaceType> ifType) {
+ if( (ifType != null) && (ifType.isAssignableFrom(Tunnel.class)) ) {
+ return true;
+ }
+ return false;
+ }
+ public static StateTunnelListKey getTunnelStateKey( org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface iface) {
+ StateTunnelListKey key = null;
+ if(isItmIfType(iface.getType())) {
+ key = new StateTunnelListKey(iface.getName());
+ }
+ return key;
+ }
+ public static void updateTunnelsCache(DataBroker broker) {
+ List<InternalTunnel> internalTunnels = getAllInternalTunnels(broker, LogicalDatastoreType.CONFIGURATION);
+ for (InternalTunnel tunnel : internalTunnels) {
+ itmCache.addInternalTunnel(tunnel);
+ }
+ List<ExternalTunnel> externalTunnels = getAllExternalTunnels(broker, LogicalDatastoreType.CONFIGURATION);
+ for (ExternalTunnel tunnel : externalTunnels) {
+ itmCache.addExternalTunnel(tunnel);
+ }
+ }
+ public static List<ExternalTunnel> getAllExternalTunnels(DataBroker dataBroker, LogicalDatastoreType datastoreType) {
+ List<ExternalTunnel> result = null;
+ InstanceIdentifier<ExternalTunnelList> iid = InstanceIdentifier.builder(ExternalTunnelList.class).build();
+ Optional<ExternalTunnelList> tunnelList = read(LogicalDatastoreType.CONFIGURATION, iid, dataBroker);
+ if (tunnelList.isPresent()) {
+ result = tunnelList.get().getExternalTunnel();
+ }
+ if (result == null) {
+ result = Collections.emptyList();
+ }
+ return result;
+ }
+ public static List<InternalTunnel> getAllInternalTunnels(DataBroker dataBroker, LogicalDatastoreType datastoreType) {
+ List<InternalTunnel> result = null;
+ InstanceIdentifier<TunnelList> iid = InstanceIdentifier.builder(TunnelList.class).build();
+ Optional<TunnelList> tunnelList = read(LogicalDatastoreType.CONFIGURATION, iid, dataBroker);
+ if (tunnelList.isPresent()) {
+ result = tunnelList.get().getInternalTunnel();
+ }
+ if (result == null) {
+ result = Collections.emptyList();
+ }
+ return result;
+ }
+ public static Interface getInterface(
+ String name, DataBroker broker) {
+ Interface result = itmCache.getInterface(name);
+ if (result == null) {
+ InstanceIdentifier<Interface> iid =
+ InstanceIdentifier.builder(Interfaces.class)
+ .child(Interface.class, new InterfaceKey(name)).build();
+ Optional<Interface> optInterface = read(LogicalDatastoreType.CONFIGURATION, iid, broker);
+ if (optInterface.isPresent()) {
+ result = optInterface.get();
+ itmCache.addInterface(result);
+ }
+ }
+ return result;
+ }
Code Review / vpnservice.git / commitdiff