import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ContractKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ExternalImplicitGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ExternalImplicitGroupKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.SubjectFeatureInstances;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.Clause;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.ClauseKey;
public static InstanceIdentifier<Renderers> renderersIid() {
return InstanceIdentifier.builder(Renderers.class).build();
}
+
+ public static InstanceIdentifier<ExternalImplicitGroup> externalImplicitGroupIid(TenantId tenantId,
+ EndpointGroupId epgId) {
+ return InstanceIdentifier.builder(Tenants.class)
+ .child(Tenant.class, new TenantKey(tenantId))
+ .child(Policy.class)
+ .child(ExternalImplicitGroup.class, new ExternalImplicitGroupKey(epgId))
+ .build();
+ }
+
}
<artifactId>groupbasedpolicy</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>ofoverlay-renderer</artifactId>
- <version>${project.version}</version>
- </dependency>
<dependency>
<groupId>org.opendaylight.neutron</groupId>
<artifactId>neutron-spi</artifactId>
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.FloatingIpAssociationMappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.NeutronByGbpMappings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.FloatingIpPortsByInternalPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.InternalPortsByFloatingIpPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.floating.ip.ports.by.internal.ports.FloatingIpPortByInternalPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.floating.ip.ports.by.internal.ports.FloatingIpPortByInternalPortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByFloatingIpPorts;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByRouterGatewayPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByRouterInterfacePorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router._interface.ports.EndpointByRouterInterfacePort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router._interface.ports.EndpointByRouterInterfacePortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router.gateway.ports.EndpointByRouterGatewayPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router.gateway.ports.EndpointByRouterGatewayPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ExternalGatewaysAsL3Endpoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ExternalNetworksByL2FloodDomains;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.FloatingIpPortsByEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.PortsByEndpoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.RouterGatewayPortsByEndpoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.RouterInterfacePortsByEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3EndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.networks.by.l2.flood.domains.ExternalNetworkByL2FloodDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.networks.by.l2.flood.domains.ExternalNetworkByL2FloodDomainKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.floating.ip.ports.by.endpoints.FloatingIpPortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.floating.ip.ports.by.endpoints.FloatingIpPortByEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router._interface.ports.by.endpoints.RouterInterfacePortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router._interface.ports.by.endpoints.RouterInterfacePortByEndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router.gateway.ports.by.endpoints.RouterGatewayPortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router.gateway.ports.by.endpoints.RouterGatewayPortByEndpointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
.build();
}
- public static InstanceIdentifier<EndpointByRouterGatewayPort> endpointByRouterGatewayPortIid(UniqueId portId) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(GbpByNeutronMappings.class)
- .child(EndpointsByRouterGatewayPorts.class)
- .child(EndpointByRouterGatewayPort.class, new EndpointByRouterGatewayPortKey(portId))
- .build();
- }
-
- public static InstanceIdentifier<RouterGatewayPortByEndpoint> routerGatewayPortByEndpointIid(
- L2BridgeDomainId l2BdId, MacAddress mac) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(NeutronByGbpMappings.class)
- .child(RouterGatewayPortsByEndpoints.class)
- .child(RouterGatewayPortByEndpoint.class, new RouterGatewayPortByEndpointKey(l2BdId, mac))
- .build();
- }
-
- public static InstanceIdentifier<EndpointByRouterInterfacePort> endpointByRouterInterfacePortIid(UniqueId portId) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(GbpByNeutronMappings.class)
- .child(EndpointsByRouterInterfacePorts.class)
- .child(EndpointByRouterInterfacePort.class, new EndpointByRouterInterfacePortKey(portId))
- .build();
- }
-
- public static InstanceIdentifier<RouterInterfacePortByEndpoint> routerInterfacePortByEndpointIid(
- L2BridgeDomainId l2BdId, MacAddress mac) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(NeutronByGbpMappings.class)
- .child(RouterInterfacePortsByEndpoints.class)
- .child(RouterInterfacePortByEndpoint.class, new RouterInterfacePortByEndpointKey(l2BdId, mac))
- .build();
- }
-
- public static InstanceIdentifier<EndpointByFloatingIpPort> endpointByFloatingIpPortIid(UniqueId portId) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(GbpByNeutronMappings.class)
- .child(EndpointsByFloatingIpPorts.class)
- .child(EndpointByFloatingIpPort.class, new EndpointByFloatingIpPortKey(portId))
- .build();
- }
-
- public static InstanceIdentifier<FloatingIpPortByEndpoint> floatingIpPortByEndpointIid(L2BridgeDomainId l2BdId,
- MacAddress mac) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(NeutronByGbpMappings.class)
- .child(FloatingIpPortsByEndpoints.class)
- .child(FloatingIpPortByEndpoint.class, new FloatingIpPortByEndpointKey(l2BdId, mac))
- .build();
- }
-
- public static InstanceIdentifier<InternalPortByFloatingIpPort> internalPortByFloatingIpPortIid(
- UniqueId floatingIpPortId) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(FloatingIpAssociationMappings.class)
- .child(InternalPortsByFloatingIpPorts.class)
- .child(InternalPortByFloatingIpPort.class, new InternalPortByFloatingIpPortKey(floatingIpPortId))
- .build();
- }
-
- public static InstanceIdentifier<FloatingIpPortByInternalPort> floatingIpPortByInternalPortIid(
- UniqueId floatingIpPortId) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(FloatingIpAssociationMappings.class)
- .child(FloatingIpPortsByInternalPorts.class)
- .child(FloatingIpPortByInternalPort.class, new FloatingIpPortByInternalPortKey(floatingIpPortId))
- .build();
- }
-
public static InstanceIdentifier<ExternalGatewayAsL3Endpoint> externalGatewayAsL3Endpoint(L3ContextId l3Context,
IpAddress ipAddress) {
return InstanceIdentifier.builder(
.build();
}
- public static InstanceIdentifier<ExternalNetworkByL2FloodDomain> externalNetworkByL2FloodDomain(L2FloodDomainId l2FdId) {
- return InstanceIdentifier.builder(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings.class)
- .child(NeutronByGbpMappings.class)
- .child(ExternalNetworksByL2FloodDomains.class)
- .child(ExternalNetworkByL2FloodDomain.class, new ExternalNetworkByL2FloodDomainKey(l2FdId))
- .build();
- }
-
}
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronFloatingIpAware;
import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronNetworkAware;
+import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronNetworkDao;
import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronPortAware;
import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronRouterAware;
import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronSubnetAware;
}
private void registerAwareProviders(DataBroker dataProvider, EndpointService epService, BundleContext context) {
- ServiceRegistration<INeutronNetworkAware> neutronNetworkAwareRegistration =
- context.registerService(INeutronNetworkAware.class, new NeutronNetworkAware(dataProvider), null);
- registrations.add(neutronNetworkAwareRegistration);
+ SecGroupDao secGroupDao = new SecGroupDao();
+ SecRuleDao secRuleDao = new SecRuleDao();
+ NeutronNetworkDao networkDao = new NeutronNetworkDao();
ServiceRegistration<INeutronSubnetAware> neutronSubnetAwareRegistration =
- context.registerService(INeutronSubnetAware.class, new NeutronSubnetAware(dataProvider), null);
+ context.registerService(INeutronSubnetAware.class, new NeutronSubnetAware(dataProvider, networkDao), null);
registrations.add(neutronSubnetAwareRegistration);
- SecGroupDao secGroupDao = new SecGroupDao();
- SecRuleDao secRuleDao = new SecRuleDao();
NeutronSecurityRuleAware securityRuleAware = new NeutronSecurityRuleAware(dataProvider, secRuleDao, secGroupDao);
ServiceRegistration<INeutronSecurityRuleAware> neutronSecurityRuleAwareRegistration =
context.registerService(INeutronSecurityRuleAware.class, securityRuleAware, null);
context.registerService(INeutronSecurityGroupAware.class, securityGroupAware, null);
registrations.add(neutronSecurityGroupAwareRegistration);
+ ServiceRegistration<INeutronNetworkAware> neutronNetworkAwareRegistration = context.registerService(
+ INeutronNetworkAware.class, new NeutronNetworkAware(dataProvider, securityGroupAware, networkDao), null);
+ registrations.add(neutronNetworkAwareRegistration);
+
NeutronPortAware portAware =
new NeutronPortAware(dataProvider, epService, securityRuleAware, securityGroupAware);
ServiceRegistration<INeutronPortAware> neutronPortAwareRegistration =
context.registerService(INeutronPortAware.class, portAware, null);
registrations.add(neutronPortAwareRegistration);
- NeutronRouterAware routerAware = new NeutronRouterAware(dataProvider, epService, securityRuleAware);
+ NeutronRouterAware routerAware = new NeutronRouterAware(dataProvider, epService);
ServiceRegistration<INeutronRouterAware> neutronRouterAwareRegistration =
context.registerService(INeutronRouterAware.class, routerAware, null);
registrations.add(neutronRouterAwareRegistration);
ServiceRegistration<INeutronFloatingIPAware> neutronFloatingIpAwareRegistration = context
- .registerService(INeutronFloatingIPAware.class, new NeutronFloatingIpAware(dataProvider, epService), null);
+ .registerService(INeutronFloatingIPAware.class, new NeutronFloatingIpAware(dataProvider), null);
registrations.add(neutronFloatingIpAwareRegistration);
}
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import javax.annotation.Nullable;
-
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils;
-import org.opendaylight.groupbasedpolicy.util.IidFactory;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClauseName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SelectorName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection.Direction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRefBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.EndpointIdentificationConstraintsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.L3EndpointIdentificationConstraints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.L3EndpointIdentificationConstraintsBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.endpoint.identification.constraints.endpoint.identification.constraints.l3.endpoint.identification.constraints.PrefixConstraintBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValueBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.Contract;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ContractBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup.IntraGroupPolicy;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.Clause;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.ClauseBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.Subject;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.SubjectBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.clause.ConsumerMatchers;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.clause.ConsumerMatchersBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.clause.ProviderMatchers;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.clause.ProviderMatchersBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.Rule;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.contract.subject.RuleBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ConsumerNamedSelector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ConsumerNamedSelectorBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderNamedSelector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.endpoint.group.ProviderNamedSelectorBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstance;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstanceBuilder;
-
-import com.google.common.collect.ImmutableList;
-
-public class Router {
-
- private static final ClassifierName IPV4_NAME = new ClassifierName("IPv4");
- private static final ClassifierName IPV6_NAME = new ClassifierName("IPv6");
- private static final SubjectName ROUTER_SUBJECT_NAME = new SubjectName("ALLOW_IPv4_IPv6");
- private static final Description ROUTER_CONTRACT_DESC =
- new Description("Allow IPv4 and IPv6 communication between router interfaces and endpoints.");
- /**
- * ID of {@link Contract}
- */
- public static final ContractId CONTRACT_ID = new ContractId("111bc60e-1110-11e5-885d-feff819cdc9f");
- /**
- * Contains rules with action {@link MappingUtils#ACTION_REF_ALLOW} matching IPv4 and IPv6
- * communication in both directions
- */
- public static final Contract CONTRACT;
-
- private static final Name ROUTER_EPG_NAME = new Name("ROUTER_PORTS");
- private static final Description ROUTER_EPG_DESC = new Description("Represents router's interfaces.");
- /**
- * ID of {@link #EPG}
- */
- public static final EndpointGroupId EPG_ID = new EndpointGroupId("1118172e-cd84-4933-a35f-749f9a651de9");
- /**
- * Router endpoint-group providing {@link #CONTRACT}
- */
- public static final EndpointGroup EPG;
- /**
- * {@link ConsumerNamedSelector} pointing to {@link #CONTRACT}
- */
- public static final ConsumerNamedSelector CONTRACT_CONSUMER_SELECTOR;
-
- static {
- CONTRACT = createContractRouter();
- CONTRACT_CONSUMER_SELECTOR = createConsumerSelector(CONTRACT);
- EPG = createRouterEpg();
- }
-
- private static EndpointGroup createRouterEpg() {
- ProviderNamedSelector routerProviderSelector = createProviderSelector(CONTRACT);
- return new EndpointGroupBuilder().setId(EPG_ID)
- .setName(ROUTER_EPG_NAME)
- .setProviderNamedSelector(ImmutableList.of(routerProviderSelector))
- .setIntraGroupPolicy(IntraGroupPolicy.RequireContract)
- .setDescription(ROUTER_EPG_DESC)
- .build();
- }
-
- private static ProviderNamedSelector createProviderSelector(Contract contract) {
- SelectorName selectorName = new SelectorName(contract.getSubject().get(0).getName().getValue());
- return new ProviderNamedSelectorBuilder().setName(selectorName)
- .setContract(ImmutableList.of(contract.getId()))
- .build();
- }
-
- private static ConsumerNamedSelector createConsumerSelector(Contract contract) {
- SelectorName selectorName = new SelectorName(contract.getSubject().get(0).getName().getValue());
- return new ConsumerNamedSelectorBuilder().setName(selectorName)
- .setContract(ImmutableList.of(contract.getId()))
- .build();
- }
-
- private static Contract createContractRouter() {
- Rule endpointRouterIpv4Rule = createRuleAllow(IPV4_NAME, Direction.In);
- Rule routerEndpointIpv4Rule = createRuleAllow(IPV4_NAME, Direction.Out);
- Rule endpointRouterIpv6Rule = createRuleAllow(IPV6_NAME, Direction.In);
- Rule routerEndpointIpv6Rule = createRuleAllow(IPV6_NAME, Direction.Out);
- Subject subject = new SubjectBuilder().setName(ROUTER_SUBJECT_NAME)
- .setOrder(0)
- .setRule(ImmutableList.of(endpointRouterIpv4Rule, routerEndpointIpv4Rule, endpointRouterIpv6Rule,
- routerEndpointIpv6Rule))
- .build();
- return new ContractBuilder().setId(CONTRACT_ID)
- .setSubject(ImmutableList.of(subject))
- .setDescription(ROUTER_CONTRACT_DESC)
- .build();
- }
-
- private static Rule createRuleAllow(ClassifierName classifierName, Direction direction) {
- ClassifierName name =
- new ClassifierName(direction.name() + MappingUtils.NAME_DOUBLE_DELIMETER + classifierName.getValue());
- ClassifierRef classifierRef = new ClassifierRefBuilder().setName(name)
- .setInstanceName(classifierName)
- .setDirection(direction)
- .build();
- return new RuleBuilder().setName(new RuleName(name))
- .setActionRef(MappingUtils.ACTION_REF_ALLOW)
- .setClassifierRef(ImmutableList.of(classifierRef))
- .build();
- }
-
- /**
- * puts clause with {@link L3EndpointIdentificationConstraints} in {@link ConsumerMatchers}
- * and {@link ProviderMatchers}. This clause points to subject in {@link #CONTRACT}.
- *
- * @param tenantId location of {@link #CONTRACT}
- * @param ipPrefix used in {@link L3EndpointIdentificationConstraints}
- * @param wTx transaction where entities are written
- */
- public static void writeRouterClauseWithConsProvEic(TenantId tenantId, @Nullable IpPrefix ipPrefix,
- WriteTransaction wTx) {
- Clause clause = createClauseWithConsProvEic(ipPrefix, ROUTER_SUBJECT_NAME);
- wTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.clauseIid(tenantId, CONTRACT_ID, clause.getName()),
- clause, true);
- }
-
- private static Clause createClauseWithConsProvEic(@Nullable IpPrefix ipPrefix, SubjectName subjectName) {
- ConsumerMatchers consumerMatchers = null;
- ProviderMatchers providerMatchers = null;
- StringBuilder clauseName = new StringBuilder();
- clauseName.append(subjectName.getValue());
- if (ipPrefix != null) {
- clauseName.append(MappingUtils.NAME_DOUBLE_DELIMETER).append(Utils.getStringIpPrefix(ipPrefix));
- consumerMatchers =
- new ConsumerMatchersBuilder()
- .setEndpointIdentificationConstraints(new EndpointIdentificationConstraintsBuilder()
- .setL3EndpointIdentificationConstraints(new L3EndpointIdentificationConstraintsBuilder()
- .setPrefixConstraint(
- ImmutableList.of(new PrefixConstraintBuilder().setIpPrefix(ipPrefix).build()))
- .build())
- .build())
- .build();
- providerMatchers =
- new ProviderMatchersBuilder()
- .setEndpointIdentificationConstraints(new EndpointIdentificationConstraintsBuilder()
- .setL3EndpointIdentificationConstraints(new L3EndpointIdentificationConstraintsBuilder()
- .setPrefixConstraint(
- ImmutableList.of(new PrefixConstraintBuilder().setIpPrefix(ipPrefix).build()))
- .build())
- .build())
- .build();
- }
- return new ClauseBuilder().setName(new ClauseName(clauseName.toString()))
- .setSubjectRefs(ImmutableList.of(subjectName))
- .setConsumerMatchers(consumerMatchers)
- .setProviderMatchers(providerMatchers)
- .build();
- }
-
- /**
- * Puts router entities (classifier-instances, {@link #CONTRACT} and {@link #EPG}) to
- * {@link LogicalDatastoreType#CONFIGURATION}
- *
- * @param tenantId location of router entities
- * @param wTx transaction where router entities are written
- */
- public static void writeRouterEntitiesToTenant(TenantId tenantId, WriteTransaction wTx) {
- Set<ClassifierInstance> classifierInstances = getAllClassifierInstances();
- for (ClassifierInstance ci : classifierInstances) {
- wTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.classifierInstanceIid(tenantId, ci.getName()), ci,
- true);
- }
- wTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.contractIid(tenantId, CONTRACT_ID), CONTRACT, true);
- wTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.endpointGroupIid(tenantId, EPG_ID), EPG, true);
- }
-
- /**
- * @return All classifier-instances used in {@link CONTRACT}
- */
- public static Set<ClassifierInstance> getAllClassifierInstances() {
- HashSet<ClassifierInstance> cis = new HashSet<>();
- cis.add(createIpv4());
- cis.add(createIpv6());
- return cis;
- }
-
- private static ClassifierInstance createIpv4() {
- return new ClassifierInstanceBuilder().setName(IPV4_NAME)
- .setClassifierDefinitionId(EtherTypeClassifierDefinition.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv4_VALUE))
- .build();
- }
-
- private static ClassifierInstance createIpv6() {
- return new ClassifierInstanceBuilder().setName(IPV6_NAME)
- .setClassifierDefinitionId(EtherTypeClassifierDefinition.DEFINITION.getId())
- .setParameterValue(createParams(EtherTypeClassifierDefinition.IPv6_VALUE))
- .build();
- }
-
- private static List<ParameterValue> createParams(long etherType) {
- List<ParameterValue> params = new ArrayList<>();
- params.add(new ParameterValueBuilder().setName(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM))
- .setIntValue(etherType)
- .build());
- return params;
- }
-}
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Key;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPortBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPortBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router._interface.ports.EndpointByRouterInterfacePort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router._interface.ports.EndpointByRouterInterfacePortBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router.gateway.ports.EndpointByRouterGatewayPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router.gateway.ports.EndpointByRouterGatewayPortBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3EndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3EndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.floating.ip.ports.by.endpoints.FloatingIpPortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.floating.ip.ports.by.endpoints.FloatingIpPortByEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpointBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router._interface.ports.by.endpoints.RouterInterfacePortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router._interface.ports.by.endpoints.RouterInterfacePortByEndpointBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router.gateway.ports.by.endpoints.RouterGatewayPortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router.gateway.ports.by.endpoints.RouterGatewayPortByEndpointBuilder;
public class MappingFactory {
.build();
}
- public static EndpointByRouterGatewayPort createEndpointByRouterGatewayPort(EndpointKey epKey, UniqueId portId) {
- return new EndpointByRouterGatewayPortBuilder().setPortId(portId)
- .setL2Context(epKey.getL2Context())
- .setMacAddress(epKey.getMacAddress())
- .build();
- }
-
- public static RouterGatewayPortByEndpoint createRouterGatewayPortByEndpoint(UniqueId portId, EndpointKey epKey) {
- return new RouterGatewayPortByEndpointBuilder().setPortId(portId)
- .setL2Context(epKey.getL2Context())
- .setMacAddress(epKey.getMacAddress())
- .build();
- }
-
- public static EndpointByRouterInterfacePort createEndpointByRouterInterfacePort(EndpointKey epKey, UniqueId portId) {
- return new EndpointByRouterInterfacePortBuilder().setPortId(portId)
- .setL2Context(epKey.getL2Context())
- .setMacAddress(epKey.getMacAddress())
- .build();
- }
-
- public static RouterInterfacePortByEndpoint createRouterInterfacePortByEndpoint(UniqueId portId, EndpointKey epKey) {
- return new RouterInterfacePortByEndpointBuilder().setPortId(portId)
- .setL2Context(epKey.getL2Context())
- .setMacAddress(epKey.getMacAddress())
- .build();
- }
-
- public static EndpointByFloatingIpPort createEndpointByFloatingIpPort(EndpointKey epKey, UniqueId portId) {
- return new EndpointByFloatingIpPortBuilder().setPortId(portId)
- .setL2Context(epKey.getL2Context())
- .setMacAddress(epKey.getMacAddress())
- .build();
- }
-
- public static FloatingIpPortByEndpoint createFloatingIpPortByEndpoint(UniqueId portId, EndpointKey epKey) {
- return new FloatingIpPortByEndpointBuilder().setPortId(portId)
- .setL2Context(epKey.getL2Context())
- .setMacAddress(epKey.getMacAddress())
- .build();
- }
-
public static ExternalGatewayAsL3Endpoint createExternalGatewayByL3Endpoint(EndpointL3Key epL3Key) {
return new ExternalGatewayAsL3EndpointBuilder().setKey(
new ExternalGatewayAsL3EndpointKey(epL3Key.getIpAddress(), epL3Key.getL3Context()))
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.neutron.gbp.util.NeutronGbpIidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.neutron.spi.INeutronFloatingIPAware;
-import org.opendaylight.neutron.spi.INeutronPortCRUD;
-import org.opendaylight.neutron.spi.NeutronCRUDInterfaces;
import org.opendaylight.neutron.spi.NeutronFloatingIP;
-import org.opendaylight.neutron.spi.NeutronPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.floating.ip.ports.by.internal.ports.FloatingIpPortByInternalPortBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPortBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddressBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public static final Logger LOG = LoggerFactory.getLogger(NeutronFloatingIpAware.class);
private final DataBroker dataProvider;
- private final EndpointService epService;
- public NeutronFloatingIpAware(DataBroker dataProvider, EndpointService epService) {
+ public NeutronFloatingIpAware(DataBroker dataProvider) {
this.dataProvider = checkNotNull(dataProvider);
- this.epService = checkNotNull(epService);
}
@Override
@Override
public int canUpdateFloatingIP(NeutronFloatingIP delta, NeutronFloatingIP original) {
LOG.trace("canUpdateFloatingIP - delta: {} original: {}", delta, original);
- // floating IP UUID is same as device ID of a port representing floating IP
- UniqueId floatingIpPortId = NeutronPortAware.getFloatingIpPortIdByDeviceId(original.getFloatingIPUUID());
- if (floatingIpPortId == null) {
- LOG.warn("Illegal state - Port representing floating ip where floating IP uuid is {} does not exist.",
- original.getFloatingIPUUID());
- return StatusCode.INTERNAL_SERVER_ERROR;
- }
-
- ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
String oldFixedIPAddress = Strings.nullToEmpty(original.getFixedIPAddress());
- String oldPortUUID = Strings.nullToEmpty(original.getPortUUID());
String newFixedIPAddress = Strings.nullToEmpty(delta.getFixedIPAddress());
- String newPortUUID = Strings.nullToEmpty(delta.getPortUUID());
- if (oldFixedIPAddress.equals(newFixedIPAddress) && oldPortUUID.equals(newPortUUID)) {
+ if (oldFixedIPAddress.equals(newFixedIPAddress)) {
// interesting fields were not changed
return StatusCode.OK;
}
- if ((!oldFixedIPAddress.isEmpty() && newFixedIPAddress.isEmpty())
- || (!oldPortUUID.isEmpty() && newPortUUID.isEmpty())) {
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.internalPortByFloatingIpPortIid(floatingIpPortId), rwTx);
+ ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
+ L3ContextId routerL3Context = new L3ContextId(delta.getRouterUUID());
+ String newFloatingIp = Strings.nullToEmpty(delta.getFloatingIPAddress());
+ if (!newFixedIPAddress.isEmpty() && !newFloatingIp.isEmpty()) {
+ IpAddress epIp = Utils.createIpAddress(newFixedIPAddress);
+ IpAddress epNatIp = Utils.createIpAddress(newFloatingIp);
+ NatAddress nat = new NatAddressBuilder().setNatAddress(epNatIp).build();
+ rwTx.put(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.l3EndpointIid(routerL3Context, epIp).augmentation(NatAddress.class), nat, true);
+ }
+ if (!oldFixedIPAddress.isEmpty()) {
DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.floatingIpPortByInternalPortIid(new UniqueId(oldPortUUID)), rwTx);
- // TODO unregister EP representing floating ip port
- } else if (!newFixedIPAddress.isEmpty() && !newPortUUID.isEmpty()) {
- // workaround for https://bugs.opendaylight.org/show_bug.cgi?id=3368
- // otherwise we will create port representing floating IP in NeutronPortAware
- Integer errorCode = registerFloatingIpPort(original.getTenantUUID(), floatingIpPortId.getValue(), rwTx);
- if (errorCode != null) {
- rwTx.cancel();
- return errorCode;
- }
-
- UniqueId internalPortId = new UniqueId(newPortUUID);
- InternalPortByFloatingIpPort internalPortByFloatingIpPort = new InternalPortByFloatingIpPortBuilder().setFloatingIpPortId(
- floatingIpPortId)
- .setFloatingIpPortIpAddress(Utils.createIpAddress(original.getFloatingIPAddress()))
- .setInternalPortId(internalPortId)
- .setInternalPortIpAddress(Utils.createIpAddress(newFixedIPAddress))
- .build();
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.internalPortByFloatingIpPortIid(floatingIpPortId),
- internalPortByFloatingIpPort, true);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.floatingIpPortByInternalPortIid(internalPortId),
- new FloatingIpPortByInternalPortBuilder(internalPortByFloatingIpPort).build(), true);
+ IidFactory.l3EndpointIid(routerL3Context, Utils.createIpAddress(oldFixedIPAddress))
+ .augmentation(NatAddress.class),
+ rwTx);
}
+
boolean isSubmitToDsSuccessful = DataStoreHelper.submitToDs(rwTx);
if (!isSubmitToDsSuccessful) {
return StatusCode.INTERNAL_SERVER_ERROR;
return StatusCode.OK;
}
- private Integer registerFloatingIpPort(String tenantUUID, String floatingIpPortUUID, ReadWriteTransaction rwTx) {
- NeutronCRUDInterfaces neutronCRUDInterface = new NeutronCRUDInterfaces().fetchINeutronPortCRUD(this);
- INeutronPortCRUD portInterface = neutronCRUDInterface.getPortInterface();
- if (portInterface == null) {
- LOG.warn("Illegal state - No provider for {}", INeutronPortCRUD.class.getName());
- return StatusCode.INTERNAL_SERVER_ERROR;
- }
- NeutronPort floatingIpPort = portInterface.getPort(floatingIpPortUUID);
- // TenantId tenantId = new TenantId(Utils.normalizeUuid());
- floatingIpPort.setTenantID(tenantUUID);
- boolean isNeutronPortCreated = NeutronPortAware.addNeutronPort(floatingIpPort, rwTx, epService);
- if (!isNeutronPortCreated) {
- rwTx.cancel();
- return StatusCode.INTERNAL_SERVER_ERROR;
- }
- return null;
- }
-
@Override
public void neutronFloatingIPUpdated(NeutronFloatingIP floatingIP) {
LOG.trace("neutronFloatingIPUpdated - {}", floatingIP);
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.neutron.gbp.util.NeutronGbpIidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkClient;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkService;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.Router;
+import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.group.NeutronSecurityGroupAware;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.NeutronMapperIidFactory;
+import org.opendaylight.groupbasedpolicy.neutron.mapper.util.NeutronUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils;
import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.neutron.spi.INeutronNetworkAware;
import org.opendaylight.neutron.spi.NeutronNetwork;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
+import org.opendaylight.neutron.spi.NeutronSecurityGroup;
+import org.opendaylight.neutron.spi.NeutronSecurityRule;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.networks.by.l2.flood.domains.ExternalNetworkByL2FloodDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.networks.by.l2.flood.domains.ExternalNetworkByL2FloodDomainBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.mapper.rev150223.mappings.network.mappings.NetworkMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.mapper.rev150223.mappings.network.mappings.NetworkMappingBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomainBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3Context;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3ContextBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ExternalImplicitGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ExternalImplicitGroupBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
public class NeutronNetworkAware implements INeutronNetworkAware {
private static final Logger LOG = LoggerFactory.getLogger(NeutronNetworkAware.class);
private final DataBroker dataProvider;
private final Set<TenantId> tenantsWithRouterAndNetworkSeviceEntities = new HashSet<>();
+ private final NeutronSecurityGroupAware secGrpAware;
+ private final NeutronNetworkDao networkDao;
- public NeutronNetworkAware(DataBroker dataProvider) {
+ public NeutronNetworkAware(DataBroker dataProvider, NeutronSecurityGroupAware secGrpAware, NeutronNetworkDao networkDao) {
this.dataProvider = checkNotNull(dataProvider);
+ this.secGrpAware = checkNotNull(secGrpAware);
+ this.networkDao = checkNotNull(networkDao);
}
/**
if (!tenantsWithRouterAndNetworkSeviceEntities.contains(tenantId)) {
tenantsWithRouterAndNetworkSeviceEntities.add(tenantId);
- Router.writeRouterEntitiesToTenant(tenantId, rwTx);
- Router.writeRouterClauseWithConsProvEic(tenantId, null, rwTx);
NetworkService.writeNetworkServiceEntitiesToTenant(tenantId, rwTx);
NetworkService.writeDhcpClauseWithConsProvEic(tenantId, null, rwTx);
NetworkService.writeDnsClauseWithConsProvEic(tenantId, null, rwTx);
NetworkService.writeMgmtClauseWithConsProvEic(tenantId, null, rwTx);
NetworkClient.writeNetworkClientEntitiesToTenant(tenantId, rwTx);
- NetworkClient.writeConsumerNamedSelector(tenantId, Router.CONTRACT_CONSUMER_SELECTOR, rwTx);
NetworkClient.writeConsumerNamedSelector(tenantId, NetworkService.DHCP_CONTRACT_CONSUMER_SELECTOR, rwTx);
NetworkClient.writeConsumerNamedSelector(tenantId, NetworkService.DNS_CONTRACT_CONSUMER_SELECTOR, rwTx);
NetworkClient.writeConsumerNamedSelector(tenantId, NetworkService.MGMT_CONTRACT_CONSUMER_SELECTOR, rwTx);
}
+ networkDao.addNetwork(network);
if (network.getRouterExternal() != null && network.getRouterExternal() == true) {
- addEpgExternalIfMissing(tenantId, rwTx);
- addExternalNetworkIfMissing(l2Fd.getId(), rwTx);
+ addEigEpgExternalWithContracts(tenantId, rwTx);
}
DataStoreHelper.submitToDs(rwTx);
}
- private void addExternalNetworkIfMissing(L2FloodDomainId l2FdId, ReadWriteTransaction rwTx) {
- InstanceIdentifier<ExternalNetworkByL2FloodDomain> iid =
- NeutronGbpIidFactory.externalNetworkByL2FloodDomain(l2FdId);
- Optional<ExternalNetworkByL2FloodDomain> externalPresent =
- DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rwTx);
- if (!externalPresent.isPresent()) {
- ExternalNetworkByL2FloodDomainBuilder builder =
- new ExternalNetworkByL2FloodDomainBuilder().setL2FloodDomainId(l2FdId);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.externalNetworkByL2FloodDomain(l2FdId),
- builder.build(), true);
- }
- }
-
- private void addEpgExternalIfMissing(TenantId tenantId, ReadWriteTransaction rwTx) {
- Optional<EndpointGroup> potentialEpgExternal = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
- IidFactory.endpointGroupIid(tenantId, MappingUtils.EPG_EXTERNAL_ID), rwTx);
- if (!potentialEpgExternal.isPresent()) {
- EndpointGroup epgExternal = new EndpointGroupBuilder().setId(MappingUtils.EPG_EXTERNAL_ID)
- .setName(new Name("EXTERNAL_group"))
- .setDescription(new Description(MappingUtils.NEUTRON_EXTERNAL + "epg_external_networks"))
- .build();
- rwTx.put(LogicalDatastoreType.CONFIGURATION,
- IidFactory.endpointGroupIid(tenantId, MappingUtils.EPG_EXTERNAL_ID), epgExternal, true);
+ private void addEigEpgExternalWithContracts(TenantId tenantId, ReadWriteTransaction rwTx) {
+ Uuid tenantUuid = new Uuid(tenantId.getValue());
+ NeutronSecurityRule inIpv4 = new NeutronSecurityRule();
+ inIpv4.setID("19b85ad2-bdfc-11e5-9912-ba0be0483c18");
+ inIpv4.setSecurityRuleDirection(NeutronUtils.INGRESS);
+ inIpv4.setSecurityRuleEthertype(NeutronUtils.IPv4);
+ inIpv4.setSecurityRuleGroupID(MappingUtils.EPG_EXTERNAL_ID.getValue());
+ inIpv4.setTenantID(tenantUuid);
+ NeutronSecurityRule outIpv4 = new NeutronSecurityRule();
+ outIpv4.setID("19b85eba-bdfc-11e5-9912-ba0be0483c18");
+ outIpv4.setSecurityRuleDirection(NeutronUtils.EGRESS);
+ outIpv4.setSecurityRuleEthertype(NeutronUtils.IPv4);
+ outIpv4.setSecurityRuleGroupID(MappingUtils.EPG_EXTERNAL_ID.getValue());
+ outIpv4.setTenantID(tenantUuid);
+ NeutronSecurityRule inIpv6 = new NeutronSecurityRule();
+ inIpv6.setID("19b86180-bdfc-11e5-9912-ba0be0483c18");
+ inIpv6.setSecurityRuleDirection(NeutronUtils.INGRESS);
+ inIpv6.setSecurityRuleEthertype(NeutronUtils.IPv6);
+ inIpv6.setSecurityRuleGroupID(MappingUtils.EPG_EXTERNAL_ID.getValue());
+ inIpv6.setTenantID(tenantUuid);
+ NeutronSecurityRule outIpv6 = new NeutronSecurityRule();
+ outIpv6.setID("19b86270-bdfc-11e5-9912-ba0be0483c18");
+ outIpv6.setSecurityRuleDirection(NeutronUtils.EGRESS);
+ outIpv6.setSecurityRuleEthertype(NeutronUtils.IPv6);
+ outIpv6.setSecurityRuleGroupID(MappingUtils.EPG_EXTERNAL_ID.getValue());
+ outIpv6.setTenantID(tenantUuid);
+ NeutronSecurityGroup externalSecGrp = new NeutronSecurityGroup();
+ externalSecGrp.setID(MappingUtils.EPG_EXTERNAL_ID.getValue());
+ externalSecGrp.setSecurityGroupName("EXTERNAL_group");
+ externalSecGrp.setTenantID(tenantUuid);
+ externalSecGrp.setSecurityRules(ImmutableList.of(inIpv4, outIpv4, inIpv6, outIpv6));
+ boolean isAddedNeutronSecurityGroup = secGrpAware.addNeutronSecurityGroup(externalSecGrp, rwTx);
+ if (!isAddedNeutronSecurityGroup) {
+ LOG.error("Problem with adding External Neutron Security Group representing External Implicit Group. {}", externalSecGrp);
+ return;
}
+ ExternalImplicitGroup eig = new ExternalImplicitGroupBuilder().setId(MappingUtils.EPG_EXTERNAL_ID).build();
+ rwTx.put(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.externalImplicitGroupIid(tenantId, eig.getId()), eig, true);
}
/**
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.neutron.mapper.mapping;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.opendaylight.neutron.spi.NeutronNetwork;
+
+import com.google.common.base.Preconditions;
+
+public class NeutronNetworkDao {
+
+ private final Set<String> externalNetworks = new HashSet<>();
+
+ public void addNetwork(NeutronNetwork network) {
+ Preconditions.checkNotNull(network);
+ if (network.getRouterExternal() != null && network.getRouterExternal() == true) {
+ externalNetworks.add(network.getID());
+ }
+ }
+
+ /**
+ * Checks if neutron network is external
+ * @param networkId UUID of the network
+ * @return {@code true} if {@link NeutronNetwork#getRouterExternal()} is {@code true}; {@code false} otherwise
+ */
+ public boolean isExternalNetwork(String networkId) {
+ return externalNetworks.contains(networkId);
+ }
+
+}
import java.util.ArrayList;
import java.util.Collection;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
-import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import org.opendaylight.groupbasedpolicy.neutron.gbp.util.NeutronGbpIidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkClient;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkService;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.Router;
import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.group.NeutronSecurityGroupAware;
import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.NeutronSecurityRuleAware;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L2Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L3;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.unregister.endpoint.input.L3Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router._interface.ports.EndpointByRouterInterfacePort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router.gateway.ports.EndpointByRouterGatewayPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3Endpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.floating.ip.ports.by.endpoints.FloatingIpPortByEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router._interface.ports.by.endpoints.RouterInterfacePortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router.gateway.ports.by.endpoints.RouterGatewayPortByEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextInputBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.slf4j.Logger;
private final EndpointService epService;
private final NeutronSecurityRuleAware secRuleAware;
private final NeutronSecurityGroupAware secGrpAware;
- private final static Map<String, UniqueId> floatingIpPortByDeviceId = new HashMap<>();
public NeutronPortAware(DataBroker dataProvider, EndpointService epService, NeutronSecurityRuleAware secRuleAware, NeutronSecurityGroupAware secGrpAware) {
this.dataProvider = checkNotNull(dataProvider);
}
if (isFloatingIpPort(port)) {
LOG.trace("Port is floating ip - {} device id - {}", port.getID(), port.getDeviceID());
- floatingIpPortByDeviceId.put(port.getDeviceID(), new UniqueId(port.getID()));
return;
}
ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
}
EndpointKey epKey = new EndpointKey(fwCtx.getL2BridgeDomain().getId(), new MacAddress(port.getMacAddress()));
addNeutronGbpMapping(port, epKey, rwTx);
-
try {
RegisterEndpointInput registerEpRpcInput = createRegisterEndpointInput(port, fwCtx);
RpcResult<Void> rpcResult = epService.registerEndpoint(registerEpRpcInput).get();
return true;
}
+ private static void addNeutronGbpMapping(NeutronPort port, EndpointKey epKey, ReadWriteTransaction rwTx) {
+ UniqueId portId = new UniqueId(port.getID());
+ if (!isRouterInterfacePort(port) && !isRouterGatewayPort(port) && !isFloatingIpPort(port)) {
+ LOG.trace("Adding Port-Endpoint mapping for port {} (device owner {}) and endpoint {}", port.getID(),
+ port.getDeviceOwner(), epKey);
+ EndpointByPort endpointByPort = MappingFactory.createEndpointByPort(epKey, portId);
+ rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.endpointByPortIid(portId), endpointByPort,
+ true);
+ PortByEndpoint portByEndpoint = MappingFactory.createPortByEndpoint(portId, epKey);
+ rwTx.put(LogicalDatastoreType.OPERATIONAL,
+ NeutronGbpIidFactory.portByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()), portByEndpoint,
+ true);
+ }
+ }
+
public static boolean addL3EndpointForExternalGateway(TenantId tenantId, L3ContextId l3ContextId,
IpAddress ipAddress, NetworkDomainId networkContainment, ReadWriteTransaction rwTx) {
EndpointL3Key epL3Key = new EndpointL3Key(ipAddress, l3ContextId);
addNeutronExtGwGbpMapping(epL3Key, rwTx);
List<EndpointGroupId> epgIds = new ArrayList<>();
- // each EP has to be in EPG ANY, except dhcp and router
epgIds.add(MappingUtils.EPG_EXTERNAL_ID);
- epgIds.add(Router.EPG_ID);
EndpointL3 epL3 = createL3Endpoint(tenantId, epL3Key, epgIds, networkContainment);
InstanceIdentifier<EndpointL3> iid_l3 = IidFactory.l3EndpointIid(l3ContextId, ipAddress);
rwTx.put(LogicalDatastoreType.OPERATIONAL, iid_l3, epL3, true);
}
private static void addNeutronExtGwGbpMapping(EndpointL3Key epL3Key, ReadWriteTransaction rwTx) {
- ExternalGatewayAsL3Endpoint externalGatewayL3Endpoint = MappingFactory.createExternalGatewayByL3Endpoint(epL3Key);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.externalGatewayAsL3Endpoint(epL3Key.getL3Context(), epL3Key.getIpAddress()),
- externalGatewayL3Endpoint, true);
- }
-
- private static void addNeutronGbpMapping(NeutronPort port, EndpointKey epKey, ReadWriteTransaction rwTx) {
- UniqueId portId = new UniqueId(port.getID());
- if (isRouterInterfacePort(port)) {
- LOG.trace("Adding RouterInterfacePort-Endpoint mapping for port {} and endpoint {}", port.getID(), epKey);
- EndpointByRouterInterfacePort endpointByPort = MappingFactory.createEndpointByRouterInterfacePort(epKey,
- portId);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.endpointByRouterInterfacePortIid(portId),
- endpointByPort, true);
- RouterInterfacePortByEndpoint portByEndpoint = MappingFactory.createRouterInterfacePortByEndpoint(portId,
- epKey);
- rwTx.put(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.routerInterfacePortByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()),
- portByEndpoint, true);
- } else if (isRouterGatewayPort(port)) {
- LOG.trace("Adding RouterGatewayPort-Endpoint mapping for port {} and endpoint {}", port.getID(), epKey);
- EndpointByRouterGatewayPort endpointByPort = MappingFactory.createEndpointByRouterGatewayPort(epKey, portId);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.endpointByRouterGatewayPortIid(portId),
- endpointByPort, true);
- RouterGatewayPortByEndpoint portByEndpoint = MappingFactory.createRouterGatewayPortByEndpoint(portId, epKey);
- rwTx.put(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.routerGatewayPortByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()),
- portByEndpoint, true);
- } else if (isFloatingIpPort(port)) {
- LOG.trace("Adding FloatingIpPort-Endpoint mapping for port {} and endpoint {}", port.getID(), epKey);
- EndpointByFloatingIpPort endpointByPort = MappingFactory.createEndpointByFloatingIpPort(epKey, portId);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.endpointByFloatingIpPortIid(portId),
- endpointByPort, true);
- FloatingIpPortByEndpoint portByEndpoint = MappingFactory.createFloatingIpPortByEndpoint(portId, epKey);
- rwTx.put(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.floatingIpPortByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()),
- portByEndpoint, true);
- } else {
- LOG.trace("Adding Port-Endpoint mapping for port {} (device owner {}) and endpoint {}", port.getID(),
- port.getDeviceOwner(), epKey);
- EndpointByPort endpointByPort = MappingFactory.createEndpointByPort(epKey, portId);
- rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.endpointByPortIid(portId), endpointByPort, true);
- PortByEndpoint portByEndpoint = MappingFactory.createPortByEndpoint(portId, epKey);
- rwTx.put(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.portByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()), portByEndpoint, true);
- }
+ ExternalGatewayAsL3Endpoint externalGatewayL3Endpoint = MappingFactory.createExternalGatewayByL3Endpoint(epL3Key);
+ rwTx.put(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.externalGatewayAsL3Endpoint(epL3Key.getL3Context(), epL3Key.getIpAddress()),
+ externalGatewayL3Endpoint, true);
}
public static boolean addL3PrefixEndpoint(L3ContextId l3ContextId, IpPrefix ipPrefix, IpAddress ipAddress, TenantId tenantId,
}
if (isFloatingIpPort(port)) {
LOG.trace("Port is floating ip - {} device id - {}", port.getID(), port.getDeviceID());
- floatingIpPortByDeviceId.remove(port.getDeviceID());
+ return;
}
ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
TenantId tenantId = new TenantId(Utils.normalizeUuid(port.getTenantID()));
private static void deleteNeutronGbpMapping(NeutronPort port, EndpointKey epKey, ReadWriteTransaction rwTx) {
UniqueId portId = new UniqueId(port.getID());
- if (isRouterInterfacePort(port)) {
- LOG.trace("Adding RouterInterfacePort-Endpoint mapping for port {} and endpoint {}", port.getID(), epKey);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.endpointByRouterInterfacePortIid(portId), rwTx);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.routerInterfacePortByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()), rwTx);
- } else if (isRouterGatewayPort(port)) {
- LOG.trace("Adding RouterGatewayPort-Endpoint mapping for port {} and endpoint {}", port.getID(), epKey);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.endpointByRouterGatewayPortIid(portId), rwTx);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.routerGatewayPortByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()), rwTx);
- } else if (isFloatingIpPort(port)) {
- LOG.trace("Adding FloatingIpPort-Endpoint mapping for port {} and endpoint {}", port.getID(), epKey);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.endpointByFloatingIpPortIid(portId), rwTx);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
- NeutronGbpIidFactory.floatingIpPortByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()), rwTx);
- } else {
+ if (!isRouterInterfacePort(port) && !isRouterGatewayPort(port) && !isFloatingIpPort(port)) {
LOG.trace("Adding Port-Endpoint mapping for port {} (device owner {}) and endpoint {}", port.getID(),
port.getDeviceOwner(), epKey);
- DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL, NeutronGbpIidFactory.endpointByPortIid(portId), rwTx);
+ DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
+ NeutronGbpIidFactory.endpointByPortIid(portId), rwTx);
DataStoreHelper.removeIfExists(LogicalDatastoreType.OPERATIONAL,
NeutronGbpIidFactory.portByEndpointIid(epKey.getL2Context(), epKey.getMacAddress()), rwTx);
}
}
private static RegisterL3PrefixEndpointInput createRegisterL3PrefixEndpointInput(EndpointL3PrefixKey key, List<EndpointL3Key> endpointL3Keys, TenantId tenantId) {
- List<EndpointGroupId> epgIds = new ArrayList<>();
List<EndpointL3Gateways> l3Gateways = new ArrayList<EndpointL3Gateways>();
for (EndpointL3Key epL3Key : endpointL3Keys) {
EndpointL3Gateways l3Gateway = new EndpointL3GatewaysBuilder().setIpAddress(epL3Key.getIpAddress())
RegisterL3PrefixEndpointInputBuilder inputBuilder = new RegisterL3PrefixEndpointInputBuilder()
.setL3Context(key.getL3Context())
.setIpPrefix(key.getIpPrefix())
- .setEndpointGroups(epgIds)
+ .setEndpointGroup(MappingUtils.EPG_EXTERNAL_ID)
.setTenant(tenantId)
.setEndpointL3Gateways(l3Gateways)
.setTimestamp(System.currentTimeMillis());
List<NeutronSecurityGroup> securityGroups = port.getSecurityGroups();
if ((securityGroups == null || securityGroups.isEmpty())) {
- if (isFloatingIpPort(port)) {
- epgIds.add(MappingUtils.EPG_EXTERNAL_ID);
- } else if (!isDhcpPort(port)) {
+ if (!isDhcpPort(port)) {
LOG.warn(
"Port {} does not contain any security group. The port should belong to 'default' security group at least.",
- port.getPortUUID());
+ port.getID());
}
} else {
for (NeutronSecurityGroup secGrp : securityGroups) {
.setMacAddress(new MacAddress(port.getMacAddress()))
.setTenant(new TenantId(Utils.normalizeUuid(port.getTenantID())))
.setEndpointGroups(epgIds)
- .addAugmentation(OfOverlayContextInput.class,
- new OfOverlayContextInputBuilder()
- .setPortName(createTapPortName(port))
- .build())
.setTimestamp(System.currentTimeMillis());
List<Neutron_IPs> fixedIPs = port.getFixedIPs();
// TODO Li msunal this getting of just first IP has to be rewrite when OFOverlay renderer
return inputBuilder.build();
}
- private static Name createTapPortName(NeutronPort port) {
- return new Name("tap" + port.getID().substring(0, 11));
- }
-
- private static boolean isDhcpPort(NeutronPort port) {
+ public static boolean isDhcpPort(NeutronPort port) {
return DEVICE_OWNER_DHCP.equals(port.getDeviceOwner());
}
- private static boolean isRouterInterfacePort(NeutronPort port) {
+ public static boolean isRouterInterfacePort(NeutronPort port) {
return DEVICE_OWNER_ROUTER_IFACE.equals(port.getDeviceOwner());
}
- private static boolean isRouterGatewayPort(NeutronPort port) {
+ public static boolean isRouterGatewayPort(NeutronPort port) {
return DEVICE_OWNER_ROUTER_GATEWAY.equals(port.getDeviceOwner());
}
- private static boolean isFloatingIpPort(NeutronPort port) {
+ public static boolean isFloatingIpPort(NeutronPort port) {
return DEVICE_OWNER_FLOATING_IP.equals(port.getDeviceOwner());
}
return l3s;
}
- public static UniqueId getFloatingIpPortIdByDeviceId(String deviceId) {
- return floatingIpPortByDeviceId.get(deviceId);
- }
-
}
import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.Router;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.NeutronSecurityRuleAware;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils.ForwardingCtx;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.NeutronMapperIidFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3ContextBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final String DEFAULT_ROUTE = "0.0.0.0/0";
private final DataBroker dataProvider;
private final EndpointService epService;
- private final NeutronSecurityRuleAware secRuleAware;
- public NeutronRouterAware(DataBroker dataProvider, EndpointService epService, NeutronSecurityRuleAware secRuleAware) {
+ public NeutronRouterAware(DataBroker dataProvider, EndpointService epService) {
this.dataProvider = checkNotNull(dataProvider);
this.epService = checkNotNull(epService);
- this.secRuleAware = checkNotNull(secRuleAware);
}
@Override
@Override
public void neutronRouterDeleted(NeutronRouter router) {
LOG.trace("neutronRouterDeleted - {}", router);
- ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
- TenantId tenantId = new TenantId(Utils.normalizeUuid(router.getTenantID()));
- Optional<EndpointGroup> potentialEpg = DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION,
- IidFactory.endpointGroupIid(tenantId, Router.EPG_ID), rwTx);
- if (!potentialEpg.isPresent()) {
- LOG.warn("Illegal state - Endpoint group {} does not exist.", Router.EPG_ID.getValue());
- rwTx.cancel();
- return;
- }
- DataStoreHelper.submitToDs(rwTx);
}
@Override
NeutronSubnet neutronSubnet = subnetInterface.getSubnet(subnet.getId().getValue());
List<NeutronPort> portsInNeutronSubnet = neutronSubnet.getPortsInSubnet();
for (NeutronPort port : portsInNeutronSubnet) {
+ if (NeutronPortAware.isRouterGatewayPort(port) || NeutronPortAware.isRouterInterfacePort(port)) {
+ continue;
+ }
boolean isPortAdded = NeutronPortAware.addNeutronPort(port, rwTx, epService);
if (!isPortAdded) {
return false;
NeutronSubnet neutronSubnet = subnetInterface.getSubnet(subnetId.getValue());
List<NeutronPort> portsInNeutronSubnet = neutronSubnet.getPortsInSubnet();
for (NeutronPort port : portsInNeutronSubnet) {
+ if (NeutronPortAware.isRouterGatewayPort(port) || NeutronPortAware.isRouterInterfacePort(port)) {
+ continue;
+ }
boolean isPortAdded = NeutronPortAware.addNeutronPort(port, rwTx, epService);
if (!isPortAdded) {
rwTx.cancel();
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.neutron.gbp.util.NeutronGbpIidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils.ForwardingCtx;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.networks.by.l2.flood.domains.ExternalNetworkByL2FloodDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final static Logger LOG = LoggerFactory.getLogger(NeutronSubnetAware.class);
private final DataBroker dataProvider;
+ private final NeutronNetworkDao networkDao;
- public NeutronSubnetAware(DataBroker dataProvider) {
+ public NeutronSubnetAware(DataBroker dataProvider, NeutronNetworkDao networkDao) {
this.dataProvider = checkNotNull(dataProvider);
+ this.networkDao = checkNotNull(networkDao);
}
/**
DataStoreHelper.submitToDs(rwTx);
rwTx = dataProvider.newReadWriteTransaction();
- if (isExternalNetwork(subnet.getParent(), rwTx)) {
+ if (networkDao.isExternalNetwork(neutronSubnet.getNetworkUUID())) {
LOG.trace("neutronSubnetCreated - adding L3 Endpoint");
L2FloodDomainId l2FdId = new L2FloodDomainId(subnet.getParent().getValue());
ForwardingCtx fwCtx = MappingUtils.createForwardingContext(tenantId, l2FdId, rwTx);
IpAddress defaultGateway = Utils.createIpAddress(neutronSubnet.getGatewayIP());
- //Create L3Endpoint for defaultGateway and write to externalGateways to L3Endpoints in neutron-gbp datastore
+ //Create L3Endpoint for defaultGateway
NetworkDomainId containment = new NetworkDomainId(neutronSubnet.getID());
NeutronPortAware.addL3EndpointForExternalGateway(tenantId, fwCtx.getL3Context().getId(), defaultGateway, containment ,rwTx);
DataStoreHelper.submitToDs(rwTx);
return subnetBuilder.build();
}
-
- private boolean isExternalNetwork(ContextId context, ReadWriteTransaction rwTx) {
- L2FloodDomainId l2FdId = new L2FloodDomainId(context.getValue());
- LOG.trace("neutronSubnetCreated - Looking up L2FD: {}", l2FdId);
- InstanceIdentifier<ExternalNetworkByL2FloodDomain> iid = NeutronGbpIidFactory.externalNetworkByL2FloodDomain(l2FdId);
- Optional<ExternalNetworkByL2FloodDomain> external = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
- iid, rwTx);
- if (external.isPresent()) {
- return true;
- }
- return false;
- }
-
/**
* @see org.opendaylight.neutron.spi.INeutronSubnetAware#canUpdateSubnet(org.opendaylight.neutron.spi.NeutronSubnet,
* org.opendaylight.neutron.spi.NeutronSubnet)
type gbp-common:unique-id;
}
}
-
- grouping internal-port-floating-ip-port-association-fields {
- leaf floating-ip-port-id {
- description "A unique ID for the neutron port";
- type gbp-common:unique-id;
- mandatory true;
- }
- leaf floating-ip-port-ip-address {
- type inet:ip-address;
- mandatory true;
- }
- leaf internal-port-id {
- description "A unique ID for the neutron port";
- type gbp-common:unique-id;
- mandatory true;
- }
- leaf internal-port-ip-address {
- type inet:ip-address;
- mandatory true;
- }
- }
container mappings {
description "Mapping of neutron entities by groupbasedpolicy entities and vice versa.";
uses neutron-port-key;
}
}
- container router-gateway-ports-by-endpoints {
- description "Neutron router gateway ports by groupbasedpolicy endpoint";
- list router-gateway-port-by-endpoint {
- description "Neutron router gateway port key by groupbasedpolicy endpoint key";
- key "l2-context mac-address";
- uses gbp-endpoint:l2-key;
- uses neutron-port-key;
- }
- }
- container router-interface-ports-by-endpoints {
- description "Neutron router interface ports by groupbasedpolicy endpoint";
- list router-interface-port-by-endpoint {
- description "Neutron router interface port key by groupbasedpolicy endpoint key";
- key "l2-context mac-address";
- uses gbp-endpoint:l2-key;
- uses neutron-port-key;
- }
- }
- container floating-ip-ports-by-endpoints {
- description "Neutron floating IP ports by groupbasedpolicy endpoint";
- list floating-ip-port-by-endpoint {
- description "Neutron floating ip port key by groupbasedpolicy endpoint key";
- key "l2-context mac-address";
- uses gbp-endpoint:l2-key;
- uses neutron-port-key;
- }
- }
container external-gateways-as-l3-endpoints {
description "L3Endpoints that represent Neutron External Gateways for External Subnets.
uses gbp-endpoint:l3-key;
}
}
-
- container external-networks-by-l2-flood-domains {
- list external-network-by-l2-flood-domain {
- key l2-flood-domain-id;
- leaf l2-flood-domain-id {
- description "The L2 Flood Domain ID";
- type gbp-common:l2-flood-domain-id;
- }
- }
- }
}
container gbp-by-neutron-mappings {
uses gbp-endpoint:l2-key;
}
}
- container endpoints-by-router-gateway-ports {
- description "Groupbasedpolicy endpoints by neutron router gateway ports";
- list endpoint-by-router-gateway-port {
- description "Groupbasedpolicy endpoint key by neutron router gateway port key";
- key port-id;
- uses neutron-port-key;
- uses gbp-endpoint:l2-key;
- }
- }
- container endpoints-by-router-interface-ports {
- description "Groupbasedpolicy endpoints by neutron router interface ports";
- list endpoint-by-router-interface-port {
- description "Groupbasedpolicy endpoint key by neutron router interface port key";
- key port-id;
- uses neutron-port-key;
- uses gbp-endpoint:l2-key;
- }
- }
- container endpoints-by-floating-ip-ports {
- description "Groupbasedpolicy endpoints by neutron floating IP ports";
- list endpoint-by-floating-ip-port {
- description "Groupbasedpolicy endpoint key by neutron floating IP port key";
- key port-id;
- uses neutron-port-key;
- uses gbp-endpoint:l2-key;
- }
- }
}
- container floating-ip-association-mappings {
- description "Mapping of association between neutron port representing floating IP and internal neutron port";
- container internal-ports-by-floating-ip-ports {
- list internal-port-by-floating-ip-port {
- key floating-ip-port-id;
- uses internal-port-floating-ip-port-association-fields;
- }
- }
- container floating-ip-ports-by-internal-ports {
- list floating-ip-port-by-internal-port {
- key internal-port-id;
- uses internal-port-floating-ip-port-association-fields;
- }
- }
- }
}
}
package org.opendaylight.groupbasedpolicy.neutron.gbp.util;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import java.util.Iterator;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.FloatingIpAssociationMappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.NeutronByGbpMappings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.FloatingIpPortsByInternalPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.InternalPortsByFloatingIpPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.floating.ip.ports.by.internal.ports.FloatingIpPortByInternalPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.floating.ip.ports.by.internal.ports.FloatingIpPortByInternalPortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByFloatingIpPorts;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByRouterGatewayPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByRouterInterfacePorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router._interface.ports.EndpointByRouterInterfacePort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router._interface.ports.EndpointByRouterInterfacePortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router.gateway.ports.EndpointByRouterGatewayPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.router.gateway.ports.EndpointByRouterGatewayPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ExternalGatewaysAsL3Endpoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ExternalNetworksByL2FloodDomains;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.FloatingIpPortsByEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.PortsByEndpoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.RouterGatewayPortsByEndpoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.RouterInterfacePortsByEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3Endpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3EndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.networks.by.l2.flood.domains.ExternalNetworkByL2FloodDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.networks.by.l2.flood.domains.ExternalNetworkByL2FloodDomainKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.floating.ip.ports.by.endpoints.FloatingIpPortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.floating.ip.ports.by.endpoints.FloatingIpPortByEndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router._interface.ports.by.endpoints.RouterInterfacePortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router._interface.ports.by.endpoints.RouterInterfacePortByEndpointKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router.gateway.ports.by.endpoints.RouterGatewayPortByEndpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.router.gateway.ports.by.endpoints.RouterGatewayPortByEndpointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
assertEquals(EndpointByPort.class, id.getTargetType());
assertFalse(id.isWildcarded());
- assertEquals(portId, id.firstKeyOf(EndpointByPort.class, EndpointByPortKey.class).getPortId());
+ assertEquals(portId, id.firstKeyOf(EndpointByPort.class).getPortId());
}
@Test
assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
assertEquals(PortByEndpoint.class, id.getTargetType());
assertFalse(id.isWildcarded());
- assertEquals(l2BdId, id.firstKeyOf(PortByEndpoint.class, PortByEndpointKey.class).getL2Context());
- assertEquals(mac, id.firstKeyOf(PortByEndpoint.class, PortByEndpointKey.class).getMacAddress());
- }
-
- @Test
- public void endpointByRouterGatewayPortIidTest() {
- UniqueId portId = mock(UniqueId.class);
- InstanceIdentifier<EndpointByRouterGatewayPort> id = NeutronGbpIidFactory.endpointByRouterGatewayPortIid(portId);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, GbpByNeutronMappings.class, EndpointsByRouterGatewayPorts.class,
- EndpointByRouterGatewayPort.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(EndpointByRouterGatewayPort.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(portId, id.firstKeyOf(EndpointByRouterGatewayPort.class, EndpointByRouterGatewayPortKey.class)
- .getPortId());
- }
-
- @Test
- public void routerGatewayPortByEndpointIidTest() {
- L2BridgeDomainId l2BdId = mock(L2BridgeDomainId.class);
- MacAddress mac = mock(MacAddress.class);
- InstanceIdentifier<RouterGatewayPortByEndpoint> id = NeutronGbpIidFactory.routerGatewayPortByEndpointIid(
- l2BdId, mac);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class, RouterGatewayPortsByEndpoints.class,
- RouterGatewayPortByEndpoint.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(RouterGatewayPortByEndpoint.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(l2BdId, id.firstKeyOf(RouterGatewayPortByEndpoint.class, RouterGatewayPortByEndpointKey.class)
- .getL2Context());
- assertEquals(mac, id.firstKeyOf(RouterGatewayPortByEndpoint.class, RouterGatewayPortByEndpointKey.class)
- .getMacAddress());
- }
-
- @Test
- public void endpointByRouterInterfacePortIidTest() {
- UniqueId portId = mock(UniqueId.class);
- InstanceIdentifier<EndpointByRouterInterfacePort> id = NeutronGbpIidFactory.endpointByRouterInterfacePortIid(portId);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, GbpByNeutronMappings.class, EndpointsByRouterInterfacePorts.class,
- EndpointByRouterInterfacePort.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(EndpointByRouterInterfacePort.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(portId, id.firstKeyOf(EndpointByRouterInterfacePort.class, EndpointByRouterInterfacePortKey.class)
- .getPortId());
- }
-
- @Test
- public void routerInterfacePortByEndpointIidTest() {
- L2BridgeDomainId l2BdId = mock(L2BridgeDomainId.class);
- MacAddress mac = mock(MacAddress.class);
- InstanceIdentifier<RouterInterfacePortByEndpoint> id = NeutronGbpIidFactory.routerInterfacePortByEndpointIid(
- l2BdId, mac);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class, RouterInterfacePortsByEndpoints.class,
- RouterInterfacePortByEndpoint.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(RouterInterfacePortByEndpoint.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(l2BdId, id.firstKeyOf(RouterInterfacePortByEndpoint.class, RouterInterfacePortByEndpointKey.class)
- .getL2Context());
- assertEquals(mac, id.firstKeyOf(RouterInterfacePortByEndpoint.class, RouterInterfacePortByEndpointKey.class)
- .getMacAddress());
- }
-
- @Test
- public void endpointByFloatingIpPortIidTest() {
- UniqueId portId = mock(UniqueId.class);
- InstanceIdentifier<EndpointByFloatingIpPort> id = NeutronGbpIidFactory.endpointByFloatingIpPortIid(portId);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, GbpByNeutronMappings.class, EndpointsByFloatingIpPorts.class,
- EndpointByFloatingIpPort.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(EndpointByFloatingIpPort.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(portId, id.firstKeyOf(EndpointByFloatingIpPort.class, EndpointByFloatingIpPortKey.class)
- .getPortId());
- }
-
- @Test
- public void floatingIpPortByEndpointIidTest() {
- L2BridgeDomainId l2BdId = mock(L2BridgeDomainId.class);
- MacAddress mac = mock(MacAddress.class);
- InstanceIdentifier<FloatingIpPortByEndpoint> id = NeutronGbpIidFactory.floatingIpPortByEndpointIid(l2BdId, mac);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class, FloatingIpPortsByEndpoints.class,
- FloatingIpPortByEndpoint.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(FloatingIpPortByEndpoint.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(l2BdId, id.firstKeyOf(FloatingIpPortByEndpoint.class, FloatingIpPortByEndpointKey.class)
- .getL2Context());
- assertEquals(mac, id.firstKeyOf(FloatingIpPortByEndpoint.class, FloatingIpPortByEndpointKey.class)
- .getMacAddress());
- }
-
- @Test
- public void internalPortByFloatingIpPortIidTest() {
- UniqueId floatingIpPortId = mock(UniqueId.class);
- InstanceIdentifier<InternalPortByFloatingIpPort> id = NeutronGbpIidFactory.internalPortByFloatingIpPortIid(floatingIpPortId);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, FloatingIpAssociationMappings.class,
- InternalPortsByFloatingIpPorts.class, InternalPortByFloatingIpPort.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(InternalPortByFloatingIpPort.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(floatingIpPortId,
- id.firstKeyOf(InternalPortByFloatingIpPort.class, InternalPortByFloatingIpPortKey.class)
- .getFloatingIpPortId());
- }
-
- @Test
- public void floatingIpPortByInternalPortIidTest() {
- UniqueId floatingIpPortId = mock(UniqueId.class);
- InstanceIdentifier<FloatingIpPortByInternalPort> id = NeutronGbpIidFactory.floatingIpPortByInternalPortIid(floatingIpPortId);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, FloatingIpAssociationMappings.class,
- FloatingIpPortsByInternalPorts.class, FloatingIpPortByInternalPort.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(FloatingIpPortByInternalPort.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(floatingIpPortId,
- id.firstKeyOf(FloatingIpPortByInternalPort.class, FloatingIpPortByInternalPortKey.class)
- .getInternalPortId());
+ assertEquals(l2BdId, id.firstKeyOf(PortByEndpoint.class).getL2Context());
+ assertEquals(mac, id.firstKeyOf(PortByEndpoint.class).getMacAddress());
}
@Test
assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
assertEquals(ExternalGatewayAsL3Endpoint.class, id.getTargetType());
assertFalse(id.isWildcarded());
- assertEquals(l3Context, id.firstKeyOf(ExternalGatewayAsL3Endpoint.class, ExternalGatewayAsL3EndpointKey.class)
+ assertEquals(l3Context, id.firstKeyOf(ExternalGatewayAsL3Endpoint.class)
.getL3Context());
- assertEquals(ipAddress, id.firstKeyOf(ExternalGatewayAsL3Endpoint.class, ExternalGatewayAsL3EndpointKey.class)
+ assertEquals(ipAddress, id.firstKeyOf(ExternalGatewayAsL3Endpoint.class)
.getIpAddress());
}
- @Test
- public void externalNetworkByL2FloodDomainTest() {
- L2FloodDomainId l2FdId = mock(L2FloodDomainId.class);
- InstanceIdentifier<ExternalNetworkByL2FloodDomain> id = NeutronGbpIidFactory.externalNetworkByL2FloodDomain(l2FdId);
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, NeutronByGbpMappings.class, ExternalNetworksByL2FloodDomains.class,
- ExternalNetworkByL2FloodDomain.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(ExternalNetworkByL2FloodDomain.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(l2FdId,
- id.firstKeyOf(ExternalNetworkByL2FloodDomain.class, ExternalNetworkByL2FloodDomainKey.class)
- .getL2FloodDomainId());
- }
-
private static void assertPathArgumentTypes(Iterable<PathArgument> pathArguments, Class<?>[] expectedTypes) {
assertNotNull(pathArguments);
Iterator<PathArgument> it = pathArguments.iterator();
+++ /dev/null
-package org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-
-import java.util.Set;
-
-import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.test.GbpDataBrokerTest;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.test.PolicyAssert;
-import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Prefix;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstance;
-
-public class RouterTest extends GbpDataBrokerTest {
-
- private static final String IPV4_NAME = "IPv4";
- private static final String IPV6_NAME = "IPv6";
- private static final SubjectName ROUTER_SUBJECT_NAME = new SubjectName("ALLOW_IPv4_IPv6");
- private final String tenantId = "00000000-0000-0000-0000-000000000002";
-
- @Test
- public void instantiate() {
- Router service = new Router();
- assertNotNull(service);
- }
-
- @Test
- public void testWriteRouterClauseWithConsProvEicIpv4() throws Exception {
- DataBroker dataBroker = getDataBroker();
- ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
- String ipv4Prefix = "170.0.0.1/8";
- Router.writeRouterClauseWithConsProvEic(new TenantId(tenantId), new IpPrefix(new Ipv4Prefix(ipv4Prefix)), rwTx);
- rwTx.submit().get();
-
- //expected clause name
- String clauseNameIpV4 = ROUTER_SUBJECT_NAME.getValue() + MappingUtils.NAME_DOUBLE_DELIMETER + ipv4Prefix;
- clauseNameIpV4 = clauseNameIpV4.replace('/', '_');
-
- PolicyAssert.assertClauseExists(dataBroker, tenantId, Router.CONTRACT_ID.getValue(), clauseNameIpV4);
-
- }
-
- @Test
- public void testWriteRouterClauseWithConsProvEicIpv6() throws Exception {
- DataBroker dataBroker = getDataBroker();
- ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
- String ipv6Prefix = "2001:0db8:85a3:0000:0000:8a2e:0370:7334/128";
- Router.writeRouterClauseWithConsProvEic(new TenantId(tenantId), new IpPrefix(new Ipv6Prefix(ipv6Prefix)), rwTx);
- rwTx.submit().get();
-
- //expected clause name
- String clauseNameIpV6 = ROUTER_SUBJECT_NAME.getValue() + MappingUtils.NAME_DOUBLE_DELIMETER + ipv6Prefix;
- clauseNameIpV6 = clauseNameIpV6.replace('/', '_').replace(':', '.');
-
- PolicyAssert.assertClauseExists(dataBroker, tenantId, Router.CONTRACT_ID.getValue(), clauseNameIpV6);
- }
-
- @Test
- public void testWriteRouterEntitiesToTenant() throws Exception {
- //write everything
- DataBroker dataBroker = getDataBroker();
- ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
- Router.writeRouterEntitiesToTenant(new TenantId(tenantId), rwTx);
- rwTx.submit().get();
-
- //read classifier instances
- PolicyAssert.assertClassifierInstanceExists(dataBroker, tenantId, IPV4_NAME);
- PolicyAssert.assertClassifierInstanceExists(dataBroker, tenantId, IPV6_NAME);
-
- //read contract
- PolicyAssert.assertContractExists(dataBroker, tenantId, Router.CONTRACT_ID.getValue());
-
- //read group id
- PolicyAssert.assertEndpointGroupExists(dataBroker, tenantId, Router.EPG_ID.getValue());
- }
-
- @Test
- public void testGetAllClassifierInstances() {
- Set<ClassifierInstance> classifierInstances = Router.getAllClassifierInstances();
- assertNotNull(classifierInstances);
- assertFalse(classifierInstances.isEmpty());
- assertEquals(classifierInstances.size(), 2);
- }
-
-}
@Override
public java.lang.AutoCloseable createInstance() {
- final NeutronOvsdb neutronOvsdb = new NeutronOvsdb(getDataBrokerDependency(), getRpcRegistryDependency(), bundleContext);
+ final NeutronOvsdb neutronOvsdb = new NeutronOvsdb(getDataBrokerDependency(), getRpcRegistryDependency());
LOG.info("Neutron ovsdb started.");
- return new AutoCloseable() {
-
- @Override
- public void close() throws Exception {
- neutronOvsdb.close();
- }
- };
+ return neutronOvsdb;
}
public void setBundleContext(BundleContext bundleContext) {
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.Map.Entry;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.groupbasedpolicy.dto.EpKey;
-import org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.NeutronOvsdbIidFactory;
-import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
-import org.opendaylight.groupbasedpolicy.util.IidFactory;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3Address;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Builder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Key;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.google.common.base.Optional;
-
-public class NeutronGbpFloatingIpListener implements DataChangeListener, AutoCloseable {
-
- private static final Logger LOG = LoggerFactory.getLogger(NeutronGbpFloatingIpListener.class);
- private final ListenerRegistration<DataChangeListener> gbpFloatingIpListener;
- private final DataBroker dataBroker;
-
- public NeutronGbpFloatingIpListener(DataBroker dataBroker) {
- this.dataBroker = checkNotNull(dataBroker);
- gbpFloatingIpListener = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
- NeutronOvsdbIidFactory.neutronGbpInternalPortByFloatingIpIidWildcard(), this, DataChangeScope.BASE);
- LOG.trace("NeutronGbpFloatingIpListener started");
- }
-
- @Override
- public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
-
- /*
- */
- for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getCreatedData().entrySet()) {
- if (entry.getValue() instanceof InternalPortByFloatingIpPort) {
- InternalPortByFloatingIpPort internalPortByFloatingIp = (InternalPortByFloatingIpPort) entry.getValue();
- processInternalPortByFloatingIp(internalPortByFloatingIp);
- }
- }
-
- /*
- * Updates
- */
- for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getUpdatedData().entrySet()) {
- if (entry.getValue() instanceof InternalPortByFloatingIpPort) {
- InternalPortByFloatingIpPort internalPortByFloatingIp = (InternalPortByFloatingIpPort) entry.getValue();
- processInternalPortByFloatingIp(internalPortByFloatingIp);
- }
- }
-
- /*
- * Deletions
- */
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- /*
- * Remove ?
- */
- }
- }
-
- private void processInternalPortByFloatingIp(InternalPortByFloatingIpPort internalPortByFloatingIp) {
- IpAddress natAddress = internalPortByFloatingIp.getFloatingIpPortIpAddress();
- IpAddress ipAddress = internalPortByFloatingIp.getInternalPortIpAddress();
-
- ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
- Optional<EndpointByPort> optEndpointByPort = DataStoreHelper.readFromDs(
- LogicalDatastoreType.OPERATIONAL,
- NeutronOvsdbIidFactory.endpointByPortIid(internalPortByFloatingIp.getInternalPortId()), rTx);
- if (optEndpointByPort.isPresent()) {
- EpKey l2EpKey = new EpKey(optEndpointByPort.get().getL2Context(), optEndpointByPort.get().getMacAddress());
- updateEndpointNat(l2EpKey, ipAddress, natAddress);
- } else {
- LOG.error("processEpByFloatingIp: Couldn't find EP associated with {}.", internalPortByFloatingIp);
- }
- }
-
- private void updateEndpointNat(EpKey l2EpKey, IpAddress ipAddress, IpAddress natAddress) {
- Endpoint l2Ep;
- EndpointL3 l3Ep;
- EndpointL3Key l3EpKey = null;
-
- ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
-
- Optional<Endpoint> optL2Ep = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
- IidFactory.endpointIid((L2BridgeDomainId) l2EpKey.getL2Context(), l2EpKey.getMacAddress()), rwTx);
- if (optL2Ep.isPresent()) {
- l2Ep = optL2Ep.get();
- } else {
- LOG.error("updateEndpointNat: No Endpoint {} ", l2EpKey);
- return;
- }
-
- if (l2Ep.getL3Address() == null) {
- LOG.error("updateEndpointNat: L2Ep {} had no IP address to translate to.", l2Ep);
- return;
- }
-
- for (L3Address l3Address : l2Ep.getL3Address()) {
- if (l3Address.getIpAddress().equals(ipAddress)) {
- l3EpKey = new EndpointL3Key(l3Address.getIpAddress(), l3Address.getL3Context());
- break;
- }
- }
- if (l3EpKey == null) {
- return;
- }
- Optional<EndpointL3> optL3Ep = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
- IidFactory.l3EndpointIid(l3EpKey.getL3Context(), l3EpKey.getIpAddress()), rwTx);
- if (optL3Ep.isPresent()) {
- l3Ep = optL3Ep.get();
- NatAddress nat = new NatAddressBuilder().setNatAddress(natAddress).build();
-
- EndpointL3 updatedEpL3 = new EndpointL3Builder(l3Ep).addAugmentation(NatAddress.class, nat).build();
-
- rwTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.l3EndpointIid(l3EpKey.getL3Context(), l3EpKey.getIpAddress()), updatedEpL3,true);
- boolean writeResult = DataStoreHelper.submitToDs(rwTx);
- if(!writeResult) {
- LOG.trace("updateEndpointNat: Could not write {} to datastore.",updatedEpL3.getKey());
- }
- }
- }
-
- @Override
- public void close() throws Exception {
- gbpFloatingIpListener.close();
- }
-
-}
import static com.google.common.base.Preconditions.checkNotNull;
-import java.util.ArrayList;
-import java.util.List;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.ServiceRegistration;
public class NeutronOvsdb implements AutoCloseable {
- private final List<ServiceRegistration<?>> registrations = new ArrayList<ServiceRegistration<?>>();
private final TerminationPointDataChangeListener tpListener;
- private final NodeDataChangeListener nodeListener;
- private final NeutronGbpFloatingIpListener neutronGbpFloatingIpListener;
+// private final NodeDataChangeListener nodeListener;
+ private final PortByEndpointListener portByEndpointListener;
+ private final OvsdbNodeListener ovsdbNodeListener;
- public NeutronOvsdb(DataBroker dataProvider, RpcProviderRegistry rpcProvider, BundleContext context) {
+ public NeutronOvsdb(DataBroker dataProvider, RpcProviderRegistry rpcProvider) {
checkNotNull(dataProvider);
checkNotNull(rpcProvider);
- checkNotNull(context);
EndpointService epService = rpcProvider.getRpcService(EndpointService.class);
tpListener = new TerminationPointDataChangeListener(dataProvider, epService);
- nodeListener = new NodeDataChangeListener(dataProvider);
- neutronGbpFloatingIpListener = new NeutronGbpFloatingIpListener(dataProvider);
+// nodeListener = new NodeDataChangeListener(dataProvider);
+ ovsdbNodeListener = new OvsdbNodeListener(dataProvider);
+ portByEndpointListener = new PortByEndpointListener(dataProvider);
}
/**
*/
@Override
public void close() throws Exception {
- for (ServiceRegistration<?> registration : registrations) {
- registration.unregister();
- }
+ tpListener.close();
+// nodeListener.close();
+ ovsdbNodeListener.close();
+ portByEndpointListener.close();
}
}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper.addOfOverlayExternalPort;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper.getLongFromDpid;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.NeutronOvsdbIidFactory.ovsdbNodeAugmentationIid;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getNodeFromBridgeRef;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.ovsdb.southbound.SouthboundConstants;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.ExternalInterfaces;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.google.common.base.Strings;
-
-import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.removeIfExists;
-import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
-
-public class NodeDataChangeListener implements DataChangeListener, AutoCloseable {
-
- private static final Logger LOG = LoggerFactory.getLogger(NodeDataChangeListener.class);
- private static final String NEUTRON_PROVIDER_MAPPINGS_KEY = "provider_mappings";
- private static final String INVENTORY_PREFIX = "openflow:";
- private final ListenerRegistration<DataChangeListener> registration;
- private static DataBroker dataBroker;
-
- public NodeDataChangeListener(DataBroker dataBroker) {
- this.dataBroker = checkNotNull(dataBroker);
- registration = dataBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, ovsdbNodeAugmentationIid(SouthboundConstants.OVSDB_TOPOLOGY_ID), this,
- DataChangeScope.ONE);
- LOG.trace("NodeDataChangeListener started");
- }
-
- /*
- * When vSwitch is deleted, we loose data in operational DS to determine Iid of
- * corresponding ExternalInterfaces.
- */
- public static final Map<InstanceIdentifier<OvsdbNodeAugmentation>, InstanceIdentifier<ExternalInterfaces>> nodeIdByExtInterface = new HashMap<>();
-
- @Override
- @SuppressWarnings("unchecked")
- public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
-
- /*
- * TerminationPoint notifications with OVSDB augmentations
- * vSwitch ports. Iterate through the list of new ports.
- */
- for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getCreatedData().entrySet()) {
- if (entry.getValue() instanceof OvsdbNodeAugmentation) {
- OvsdbNodeAugmentation ovsdbNode = (OvsdbNodeAugmentation) entry.getValue();
- InstanceIdentifier<OvsdbNodeAugmentation> key = (InstanceIdentifier<OvsdbNodeAugmentation>) entry.getKey();
- InstanceIdentifier<ExternalInterfaces> extInterfacesIid = processNodeNotification(ovsdbNode);
- if (extInterfacesIid != null) {
- nodeIdByExtInterface.put(key, extInterfacesIid);
- }
- }
- }
-
- /*
- * Updates
- */
- for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getUpdatedData().entrySet()) {
- if (entry.getValue() instanceof OvsdbNodeAugmentation) {
- OvsdbNodeAugmentation ovsdbNode = (OvsdbNodeAugmentation) entry.getValue();
- if (Strings.isNullOrEmpty(getProviderMapping(ovsdbNode))) {
- removeExternalInterfaces((InstanceIdentifier<OvsdbNodeAugmentation>) entry.getKey());
- }
- }
- }
-
- /*
- * Deletions
- */
- for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
- if (iid.getTargetType().equals(OvsdbNodeAugmentation.class)) {
- if (nodeIdByExtInterface.get(iid) != null) {
- removeExternalInterfaces((InstanceIdentifier<OvsdbNodeAugmentation>) iid);
- }
- }
- }
- }
-
- @Override
- public void close() throws Exception {
- registration.close();
- }
-
- public static InstanceIdentifier<ExternalInterfaces> processNodeNotification(OvsdbNodeAugmentation ovsdbNode) {
- LOG.trace("Search for provider mapping on node {}", ovsdbNode);
- String providerPortName = getProviderMapping(ovsdbNode);
- if (providerPortName != null) {
- LOG.trace("Found provider mapping, creating Inventory NodeId");
- String nodeConnectorIdString = getInventoryNodeId(ovsdbNode, providerPortName);
- if (nodeConnectorIdString != null) {
- LOG.trace("Adding OfOverlay External port for {}", nodeConnectorIdString);
- String[] elements = nodeConnectorIdString.split(":");
- String nodeIdString = elements[0] + ":" + elements[1];
- NodeConnectorId ncid = getNodeConnectorId(nodeConnectorIdString);
- return addOfOverlayExternalPort(new NodeId(nodeIdString), ncid, dataBroker);
- }
- }
- return null;
- }
-
- private void removeExternalInterfaces(InstanceIdentifier<OvsdbNodeAugmentation> iidOvsdbNodeAug){
- InstanceIdentifier<ExternalInterfaces> iidExtInterface = nodeIdByExtInterface.get(iidOvsdbNodeAug);
- ReadWriteTransaction wTx = dataBroker.newReadWriteTransaction();
- removeIfExists(LogicalDatastoreType.CONFIGURATION, iidExtInterface, wTx);
- submitToDs(wTx);
- nodeIdByExtInterface.remove(iidOvsdbNodeAug);
- }
-
- private static NodeConnectorId getNodeConnectorId(String nodeConnectorIdString) {
- return new NodeConnectorId(nodeConnectorIdString);
- }
-
- public static String getProviderMapping(OvsdbNodeAugmentation ovsdbNode) {
- if (ovsdbNode.getOpenvswitchOtherConfigs() != null) {
- for (OpenvswitchOtherConfigs config : ovsdbNode.getOpenvswitchOtherConfigs()) {
- if (config.getOtherConfigKey() == null || config.getOtherConfigValue() == null) {
- continue;
- }
- if (config.getOtherConfigKey().equals(NEUTRON_PROVIDER_MAPPINGS_KEY)) {
- String otherConfig = config.getOtherConfigValue();
- if (otherConfig != null) {
- String[] elements = otherConfig.split(":");
- if (elements.length == 2) {
- return elements[1];
- }
- }
- }
- }
- }
- return null;
- }
-
- /**
- * Get the DPID and OpenFlow port of the bridge that owns the {@link TerminationPoint} in the
- * provider mapping
- *
- * @return the DPID and OpenFlow port of the bridge that owns the {@link TerminationPoint} in
- * the provider mapping
- */
- private static String getInventoryNodeId(OvsdbNodeAugmentation ovsdbNode, String externalPortName) {
- List<ManagedNodeEntry> ovsdbNodes = ovsdbNode.getManagedNodeEntry();
- if (ovsdbNodes == null) {
- LOG.trace("No ManagedNodeEntry was found on {}", ovsdbNode);
- return null;
- }
- for (ManagedNodeEntry managedNode : ovsdbNodes) {
- if (managedNode.getBridgeRef() != null) {
- /*
- * Get the Node, then see if it has any TerminationPoint
- * augmentations. If it does, check each TerminationPoint
- * augmentation to see if it is the matching provider_mapping
- */
- Node node = getNodeFromBridgeRef(managedNode.getBridgeRef(), dataBroker);
- if (node == null) {
- LOG.error("Couldn't get Topology Node for {}", managedNode.getBridgeRef());
- return null;
- }
- OvsdbBridgeAugmentation ovsdbBridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
- if (ovsdbBridge == null) {
- LOG.trace("OVSDB Node {} does not contain OvsdbBridgeAugmentation. {}", node.getKey(), node);
- continue;
- }
- for (TerminationPoint tp : node.getTerminationPoint()) {
- OvsdbTerminationPointAugmentation tpAug = tp.getAugmentation(OvsdbTerminationPointAugmentation.class);
- if ((tpAug == null) || (tpAug.getName() == null) || (tpAug.getOfport() == null)) {
- continue;
- }
- if (tpAug.getName().equals(externalPortName)) {
- return buildInventoryNcid(ovsdbBridge, tpAug);
- }
- }
- }
- }
- return null;
- }
-
- private static String buildInventoryNcid(OvsdbBridgeAugmentation ovsdbBridge,
- OvsdbTerminationPointAugmentation terminationPoint) {
- Long macLong = getLongFromDpid(ovsdbBridge.getDatapathId().getValue());
- return INVENTORY_PREFIX + String.valueOf(macLong) + ":" + String.valueOf(terminationPoint.getOfport());
- }
-}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.InventoryHelper;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.ovsdb.southbound.SouthboundConstants;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Strings;
+
+public class OvsdbNodeListener extends DataTreeChangeHandler<Node> {
+
+ private static final Logger LOG = LoggerFactory.getLogger(OvsdbNodeListener.class);
+ public static final String NEUTRON_PROVIDER_MAPPINGS_KEY = "provider_mappings";
+ private static final String OF_SEPARATOR = ":";
+ private static final String OF_INVENTORY_PREFIX = "openflow";
+
+ private final Map<OvsdbBridgeRef, String> providerPortNameByBridgeRef = new HashMap<>();
+ private final Map<InstanceIdentifier<Node>, NeutronBridgeWithExtPort> bridgeByNodeIid = new HashMap<>();
+
+ public OvsdbNodeListener(DataBroker dataProvider) {
+ super(dataProvider,
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
+ .child(Node.class)));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<Node> rootNode, InstanceIdentifier<Node> rootIdentifier) {
+ Node node = rootNode.getDataAfter();
+ OvsdbNodeAugmentation ovsdbNode = node.getAugmentation(OvsdbNodeAugmentation.class);
+ if (ovsdbNode != null) {
+ LOG.trace("OVSDB node created: {} \n {}", rootIdentifier, node);
+ DataObjectModification<OpenvswitchOtherConfigs> ovsOtherConfigModification =
+ getProviderMappingsModification(rootNode);
+ if (isProviderPortNameChanged(ovsOtherConfigModification) && ovsdbNode.getManagedNodeEntry() != null) {
+ String newProviderPortName = getProviderPortName(ovsOtherConfigModification.getDataAfter());
+ LOG.debug("provider_mappings created {} on node {}", newProviderPortName, node.getNodeId().getValue());
+ for (ManagedNodeEntry mngdNodeEntry : ovsdbNode.getManagedNodeEntry()) {
+ providerPortNameByBridgeRef.put(mngdNodeEntry.getBridgeRef(), newProviderPortName);
+ LOG.trace("Added Provider port name {} by OVSDB bridge ref {}", newProviderPortName,
+ mngdNodeEntry.getBridgeRef());
+ }
+ }
+ }
+
+ OvsdbBridgeAugmentation ovsdbBridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
+ if (ovsdbBridge != null) {
+ LOG.trace("OVSDB bridge created: {} \n {}", rootIdentifier, node);
+ Set<DataObjectModification<OvsdbTerminationPointAugmentation>> ovsdbTpModifications =
+ getOvsdbTpModifications(rootNode);
+ NodeId ofNodeId = buildOfNodeId(ovsdbBridge);
+ if (!ovsdbTpModifications.isEmpty() && ofNodeId != null) {
+ NeutronBridgeWithExtPort bridge = getBridge(rootIdentifier);
+ bridge.ofNodeId = ofNodeId;
+ LOG.trace("OF node {} representing OVSDB bridge {}", ofNodeId.getValue(), node.getNodeId().getValue());
+ }
+ for (DataObjectModification<OvsdbTerminationPointAugmentation> ovsdbTpModification : ovsdbTpModifications) {
+ OvsdbTerminationPointAugmentation newOvsdbTp = ovsdbTpModification.getDataAfter();
+ if (ovsdbBridge.getBridgeName().getValue().equals(newOvsdbTp.getName())) {
+ LOG.trace("Termination Point {} same as Bridge {}. Not processing", newOvsdbTp.getName(),
+ ovsdbBridge.getBridgeName().getValue());
+ continue;
+ }
+ String portName = newOvsdbTp.getName();
+ Long ofport = newOvsdbTp.getOfport();
+ if (isOfportOrNameChanged(ovsdbTpModification) && portName != null && ofport != null) {
+ NeutronBridgeWithExtPort bridge = getBridge(rootIdentifier);
+ bridge.ofportByName.put(ofport, portName);
+ LOG.trace("OVSDB termination point with ofport {} and port-name {} created.", ofport, portName);
+ // port name is same as provider port name so the termination point represents
+ // external port
+ if (portName.equals(providerPortNameByBridgeRef.get(new OvsdbBridgeRef(rootIdentifier)))) {
+ NodeConnectorId ofNcId = buildOfNodeConnectorId(newOvsdbTp, ofNodeId);
+ bridge.externalIfaces.add(ofNcId);
+ InventoryHelper.addOfOverlayExternalPort(bridge.ofNodeId, ofNcId, dataProvider);
+ LOG.debug("Added of-overlay external-interface {} to node {}", ofNcId.getValue(),
+ bridge.ofNodeId);
+ traceBridge(rootIdentifier);
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<Node> rootNode, InstanceIdentifier<Node> rootIdentifier) {
+ LOG.trace("Not implemented - OVSDB element deleted: {} \n {}", rootIdentifier, rootNode.getDataBefore());
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<Node> rootNode, InstanceIdentifier<Node> rootIdentifier) {
+ Node node = rootNode.getDataAfter();
+ OvsdbBridgeAugmentation ovsdbBridge = node.getAugmentation(OvsdbBridgeAugmentation.class);
+ if (ovsdbBridge != null) {
+ LOG.trace("OVSDB bridge updated: {} \n before {} \n after {}", rootIdentifier, rootNode.getDataBefore(),
+ rootNode.getDataAfter());
+ Set<DataObjectModification<OvsdbTerminationPointAugmentation>> ovsdbTpModifications =
+ getOvsdbTpModifications(rootNode);
+ NodeId ofNodeId = buildOfNodeId(ovsdbBridge);
+ if (!ovsdbTpModifications.isEmpty() && ofNodeId != null) {
+ NeutronBridgeWithExtPort bridge = getBridge(rootIdentifier);
+ if (bridge.ofNodeId != null && !bridge.ofNodeId.equals(ofNodeId)) {
+ LOG.debug("OVSDB bridge {} has changed datapath-id. \n Old: {} \n New: {}",
+ node.getNodeId().getValue(), bridge.ofNodeId.getValue(), ofNodeId.getValue());
+ bridge.ofNodeId = ofNodeId;
+ }
+ }
+ for (DataObjectModification<OvsdbTerminationPointAugmentation> ovsdbTpModification : ovsdbTpModifications) {
+ OvsdbTerminationPointAugmentation newOvsdbTp = ovsdbTpModification.getDataAfter();
+ if (ovsdbBridge.getBridgeName().getValue().equals(newOvsdbTp.getName())) {
+ LOG.trace("Termination Point {} same as Bridge {}. Not processing", newOvsdbTp.getName(),
+ ovsdbBridge.getBridgeName().getValue());
+ continue;
+ }
+ String portName = newOvsdbTp.getName();
+ Long ofport = newOvsdbTp.getOfport();
+ if (isOfportOrNameChanged(ovsdbTpModification) && portName != null && ofport != null) {
+ NeutronBridgeWithExtPort bridge = getBridge(rootIdentifier);
+ bridge.ofportByName.put(ofport, portName);
+ LOG.trace("OVSDB termination point with ofport {} and port-name {} created.", ofport, portName);
+ // port name is same as provider port name so the termination point represents
+ // external port
+ if (portName.equals(providerPortNameByBridgeRef.get(new OvsdbBridgeRef(rootIdentifier)))) {
+ NodeConnectorId ofNcId = buildOfNodeConnectorId(newOvsdbTp, ofNodeId);
+ bridge.externalIfaces.add(ofNcId);
+ InventoryHelper.addOfOverlayExternalPort(bridge.ofNodeId, ofNcId, dataProvider);
+ LOG.debug("Added of-overlay external-interface {} to node {}", ofNcId.getValue(),
+ bridge.ofNodeId);
+ traceBridge(rootIdentifier);
+ }
+ }
+ }
+ }
+ }
+
+ private NeutronBridgeWithExtPort getBridge(InstanceIdentifier<Node> nodeIid) {
+ NeutronBridgeWithExtPort bridge = bridgeByNodeIid.get(nodeIid);
+ if (bridge == null) {
+ bridge = new NeutronBridgeWithExtPort();
+ bridgeByNodeIid.put(nodeIid, bridge);
+ }
+ return bridge;
+ }
+
+ @SuppressWarnings("unchecked")
+ private static Set<DataObjectModification<OvsdbTerminationPointAugmentation>> getOvsdbTpModifications(
+ DataObjectModification<Node> rootNode) {
+ Set<DataObjectModification<OvsdbTerminationPointAugmentation>> modifications = new HashSet<>();
+ for (DataObjectModification<? extends DataObject> modifiedChild : rootNode.getModifiedChildren()) {
+ if (TerminationPoint.class.isAssignableFrom(modifiedChild.getDataType())) {
+ DataObjectModification<OvsdbTerminationPointAugmentation> modifiedAugmentation =
+ ((DataObjectModification<TerminationPoint>) modifiedChild)
+ .getModifiedAugmentation(OvsdbTerminationPointAugmentation.class);
+ if (modifiedAugmentation != null) {
+ modifications.add(modifiedAugmentation);
+ }
+ }
+ }
+ return modifications;
+ }
+
+ private static boolean isOfportOrNameChanged(
+ DataObjectModification<OvsdbTerminationPointAugmentation> ovsdbTpModification) {
+ if (ovsdbTpModification == null) {
+ return false;
+ }
+ OvsdbTerminationPointAugmentation oldTp = ovsdbTpModification.getDataBefore();
+ OvsdbTerminationPointAugmentation newTp = ovsdbTpModification.getDataAfter();
+ if (oldTp != null && newTp != null) {
+ if (oldTp.getOfport() != null && newTp.getOfport() != null && oldTp.getOfport() != newTp.getOfport()) {
+ return true;
+ }
+ if (!(Strings.nullToEmpty(oldTp.getName())).equals(Strings.nullToEmpty(newTp.getName()))) {
+ return true;
+ }
+ }
+ if (isOfportOrNameNotNull(oldTp)) {
+ return true;
+ }
+ if (isOfportOrNameNotNull(newTp)) {
+ return true;
+ }
+ return false;
+ }
+
+ private static boolean isOfportOrNameNotNull(OvsdbTerminationPointAugmentation tp) {
+ if (tp != null) {
+ if (tp.getOfport() != null) {
+ return true;
+ }
+ if (tp.getName() != null) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static DataObjectModification<OpenvswitchOtherConfigs> getProviderMappingsModification(
+ DataObjectModification<Node> rootNode) {
+ DataObjectModification<OvsdbNodeAugmentation> modifiedOvsdbNode =
+ rootNode.getModifiedAugmentation(OvsdbNodeAugmentation.class);
+ if (modifiedOvsdbNode == null) {
+ return null;
+ }
+ return modifiedOvsdbNode.getModifiedChildListItem(OpenvswitchOtherConfigs.class,
+ new OpenvswitchOtherConfigsKey(NEUTRON_PROVIDER_MAPPINGS_KEY));
+ }
+
+ private static boolean isProviderPortNameChanged(DataObjectModification<OpenvswitchOtherConfigs> ovsConfig) {
+ if (ovsConfig == null) {
+ return false;
+ }
+ OpenvswitchOtherConfigs oldConfig = ovsConfig.getDataBefore();
+ OpenvswitchOtherConfigs newConfig = ovsConfig.getDataAfter();
+ if (oldConfig != null && newConfig != null) {
+ if (!(Strings.nullToEmpty(oldConfig.getOtherConfigValue())
+ .equals(Strings.nullToEmpty(newConfig.getOtherConfigValue())))) {
+ return true;
+ }
+ } else if (oldConfig != null && !Strings.isNullOrEmpty(oldConfig.getOtherConfigValue())) {
+ return true;
+ } else if (newConfig != null && !Strings.isNullOrEmpty(newConfig.getOtherConfigValue())) {
+ return true;
+ }
+ return false;
+ }
+
+ private static @Nonnull String getProviderPortName(OpenvswitchOtherConfigs config) {
+ if (NEUTRON_PROVIDER_MAPPINGS_KEY.equals(config.getOtherConfigKey()) && config.getOtherConfigValue() != null) {
+ String otherConfig = config.getOtherConfigValue();
+ String[] elements = otherConfig.split(":");
+ if (elements.length == 2) {
+ return elements[1];
+ }
+ }
+ return "";
+ }
+
+ private static NodeId buildOfNodeId(OvsdbBridgeAugmentation ovsdbBridge) {
+ if (ovsdbBridge.getDatapathId() == null) {
+ return null;
+ }
+ Long macLong = InventoryHelper.getLongFromDpid(ovsdbBridge.getDatapathId().getValue());
+ return new NodeId(OF_INVENTORY_PREFIX + OF_SEPARATOR + String.valueOf(macLong));
+ }
+
+ private static NodeConnectorId buildOfNodeConnectorId(OvsdbTerminationPointAugmentation terminationPoint,
+ NodeId nodeId) {
+ if (terminationPoint.getOfport() == null) {
+ return null;
+ }
+ return new NodeConnectorId(nodeId.getValue() + OF_SEPARATOR + String.valueOf(terminationPoint.getOfport()));
+ }
+
+ private void traceBridge(InstanceIdentifier<Node> identifier) {
+ if (LOG.isTraceEnabled()) {
+ NeutronBridgeWithExtPort bridge = bridgeByNodeIid.get(identifier);
+ if (bridge == null) {
+ LOG.trace("Bridge does not exist: {}", identifier);
+ return;
+ }
+ String providerPortName = providerPortNameByBridgeRef.get(new OvsdbBridgeRef(identifier));
+ LOG.trace("State of bridge:\n ID: {} \n providerPortName: {} \n {}", identifier, providerPortName,
+ bridge);
+ }
+ }
+
+ private class NeutronBridgeWithExtPort {
+
+ NodeId ofNodeId;
+ Set<NodeConnectorId> externalIfaces = new HashSet<>();
+ Map<Long, String> ofportByName = new HashMap<>();
+
+ @Override
+ public String toString() {
+ return "NeutronBridgeWithExtPort:\n ofNodeId=" + ofNodeId + "\n externalIfaces=" + externalIfaces
+ + ",\n ofportByName=" + ofportByName;
+ }
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
+
+import java.util.List;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoint.fields.L3Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Key;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.NeutronByGbpMappings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.PortsByEndpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3ContextBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Optional;
+
+/**
+ * Listens on PortByEndpoint created events. port-name is augmented to endpoint and endpoint-l3 (IFF
+ * they exist in DS).
+ */
+public class PortByEndpointListener extends DataTreeChangeHandler<PortByEndpoint> {
+
+ private static final Logger LOG = LoggerFactory.getLogger(PortByEndpointListener.class);
+ private static final String TAP = "tap";
+
+ public PortByEndpointListener(DataBroker dataProvider) {
+ super(dataProvider,
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(Mappings.class)
+ .child(NeutronByGbpMappings.class)
+ .child(PortsByEndpoints.class)
+ .child(PortByEndpoint.class)
+ .build()));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<PortByEndpoint> rootNode,
+ InstanceIdentifier<PortByEndpoint> rootIdentifier) {
+ PortByEndpoint portByEp = rootNode.getDataAfter();
+ ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction();
+
+ final EndpointKey epKey = new EndpointKey(portByEp.getL2Context(), portByEp.getMacAddress());
+ InstanceIdentifier<Endpoint> epIid = IidFactory.endpointIid(epKey);
+ Optional<Endpoint> potentialEp = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, epIid, rwTx);
+ if (!potentialEp.isPresent()) {
+ LOG.warn("PortByEndpoint created notification received but endpoint {} does not exist in DS."
+ + " port-name was not added.", epKey);
+ rwTx.cancel();
+ return;
+ }
+ Endpoint ep = potentialEp.get();
+ Name portName = createTapPortName(portByEp.getPortId());
+ OfOverlayContext newOfOverlayCtx = new OfOverlayContextBuilder().setPortName(portName).build();
+ rwTx.merge(LogicalDatastoreType.OPERATIONAL, epIid.augmentation(OfOverlayContext.class), newOfOverlayCtx);
+
+ List<L3Address> l3Addresses = ep.getL3Address();
+ if (l3Addresses == null) {
+ LOG.warn("PortByEndpoint created notification received but endpoint {} has no L3 address."
+ + " port-name was not added.", epKey);
+ rwTx.cancel();
+ return;
+ }
+ L3Address l3Address = l3Addresses.get(0);
+
+ EndpointL3Key l3EpKey = new EndpointL3Key(l3Address.getIpAddress(), l3Address.getL3Context());
+ InstanceIdentifier<EndpointL3> l3EpIid = IidFactory.l3EndpointIid(l3EpKey);
+ Optional<EndpointL3> potentialL3Ep =
+ DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, l3EpIid, rwTx);
+ if (!potentialL3Ep.isPresent()) {
+ LOG.warn("PortByEndpoint created notification received but L3 endpoint {} does not exist in DS."
+ + " port-name was not added.", l3EpKey);
+ rwTx.cancel();
+ return;
+ }
+ OfOverlayL3Context newOfOverlayL3Ctx = new OfOverlayL3ContextBuilder().setPortName(portName).build();
+ rwTx.merge(LogicalDatastoreType.OPERATIONAL, l3EpIid.augmentation(OfOverlayL3Context.class), newOfOverlayL3Ctx);
+
+ DataStoreHelper.submitToDs(rwTx);
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<PortByEndpoint> rootNode,
+ InstanceIdentifier<PortByEndpoint> rootIdentifier) {
+ // NOOP
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<PortByEndpoint> rootNode,
+ InstanceIdentifier<PortByEndpoint> rootIdentifier) {
+ // NOOP
+ }
+
+ private static Name createTapPortName(UniqueId portId) {
+ return new Name(TAP + portId.getValue().substring(0, 11));
+ }
+
+}
package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
import static com.google.common.base.Preconditions.checkNotNull;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.NodeDataChangeListener.getProviderMapping;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.NodeDataChangeListener.processNodeNotification;
import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.EndpointHelper.lookupEndpoint;
import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.EndpointHelper.updateEndpointRemoveLocation;
import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.EndpointHelper.updateEndpointWithLocation;
}
- /*
- * Check if Neutron External port was announed in Node before TerminationPoint it refers to
- * was actually instantiated. This may or may not have external information in the future,
- * hence
- * not process as IF/ELSE externalID.
- */
- ReadOnlyTransaction transaction = dataBroker.newReadOnlyTransaction();
- Optional<Node> node = readFromDs(LogicalDatastoreType.OPERATIONAL, nodeIid, transaction);
- if (node.isPresent() && node.get().getAugmentation(OvsdbNodeAugmentation.class) != null) {
- OvsdbNodeAugmentation ovsdbNodeAug = node.get().getAugmentation(OvsdbNodeAugmentation.class);
- if (getProviderMapping(ovsdbNodeAug) != null) {
- processNodeNotification(ovsdbNodeAug);
-
- }
- } else {
- }
/*
* This may be a notification for a tunnel we just created.
* In that case, we need to update the Inventory Node's OfOverlay
import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
import static org.opendaylight.groupbasedpolicy.util.IidFactory.endpointIid;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import com.google.common.base.Optional;
public class EndpointHelper {
- private static final Logger LOG = LoggerFactory.getLogger(EndpointHelper.class);
/**
* Look up the {@link Endpoint} from the Endpoint Registry.
* @param nodeConnectorIdString the string representation of the inventory NodeConnectorId
* @param rwTx a reference to ReadWriteTransaction object
*/
- public static void updateEndpointWithLocation(Endpoint endpoint, String nodeIdString,
- String nodeConnectorIdString, ReadWriteTransaction rwTx) {
-
+ public static void updateEndpointWithLocation(Endpoint endpoint, String nodeIdString, String nodeConnectorIdString,
+ ReadWriteTransaction rwTx) {
NodeId invNodeId = new NodeId(nodeIdString);
NodeConnectorId ncId = new NodeConnectorId(nodeConnectorIdString);
-
- OfOverlayContext ofc = endpoint.getAugmentation(OfOverlayContext.class);
- OfOverlayContextBuilder ofcBuilder;
- if (ofc == null) {
- ofcBuilder = new OfOverlayContextBuilder();
- } else {
- ofcBuilder = new OfOverlayContextBuilder(ofc);
- }
- ofcBuilder.setNodeConnectorId(ncId).setNodeId(invNodeId);
- EndpointBuilder epBuilder = new EndpointBuilder(endpoint);
- epBuilder.addAugmentation(OfOverlayContext.class, ofcBuilder.build());
- Endpoint newEp = epBuilder.build();
- rwTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.endpointIid(newEp.getL2Context(), newEp.getMacAddress()), newEp);
+ OfOverlayContext newOfOverlayCtx =
+ new OfOverlayContextBuilder().setNodeId(invNodeId).setNodeConnectorId(ncId).build();
+ rwTx.merge(LogicalDatastoreType.OPERATIONAL,
+ IidFactory.endpointIid(endpoint.getKey()).augmentation(OfOverlayContext.class), newOfOverlayCtx);
DataStoreHelper.submitToDs(rwTx);
}
*/
package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util;
-import com.google.common.base.Optional;
+import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getOvsdbBridgeFromTerminationPoint;
+import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getOvsdbTerminationPoint;
+import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
+import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
+
+import java.util.ArrayList;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
+
import org.apache.commons.lang3.StringUtils;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.neutron.ovsdb.AbstractTunnelType;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfigBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getOvsdbBridgeFromTerminationPoint;
-import static org.opendaylight.groupbasedpolicy.neutron.ovsdb.util.OvsdbHelper.getOvsdbTerminationPoint;
-import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.readFromDs;
-import static org.opendaylight.groupbasedpolicy.util.DataStoreHelper.submitToDs;
+import com.google.common.base.Optional;
public class InventoryHelper {
ExternalInterfaces externalInterfaces = new ExternalInterfacesBuilder().setKey(new ExternalInterfacesKey(ncId))
.setNodeConnectorId(ncId)
.build();
- WriteTransaction transaction = dataBroker.newReadWriteTransaction();
+ WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
transaction.put(LogicalDatastoreType.CONFIGURATION, nodeExternalInterfacesIid, externalInterfaces, true);
- submitToDs(transaction);
+ DataStoreHelper.submitToDs(transaction);
LOG.trace("Added external interface node connector {} to node {}", ncId.getValue(), nodeId.getValue());
return nodeExternalInterfacesIid;
}
/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.FloatingIpAssociationMappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.NeutronByGbpMappings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.InternalPortsByFloatingIpPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByFloatingIpPorts;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ExternalGatewaysAsL3Endpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
public class NeutronOvsdbIidFactory {
public static InstanceIdentifier<OvsdbNodeAugmentation> ovsdbNodeAugmentationIid(TopologyId ovsdbTopologyId) {
- return InstanceIdentifier.create(NetworkTopology.class) .child(Topology.class, new TopologyKey(ovsdbTopologyId))
- .child(Node.class)
- .augmentation(OvsdbNodeAugmentation.class);
+ return InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(ovsdbTopologyId))
+ .child(Node.class)
+ .augmentation(OvsdbNodeAugmentation.class);
}
public static InstanceIdentifier<ExternalGatewayAsL3Endpoint> neutronGbpExternalGatewayIidWildcard() {
return InstanceIdentifier.builder(Mappings.class)
- .child(NeutronByGbpMappings.class)
- .child(ExternalGatewaysAsL3Endpoints.class)
- .child(ExternalGatewayAsL3Endpoint.class)
- .build();
- }
-
- public static InstanceIdentifier<EndpointByFloatingIpPort> neutronGbpFloatingIpIidWildcard() {
- return InstanceIdentifier.builder(Mappings.class)
- .child(GbpByNeutronMappings.class)
- .child(EndpointsByFloatingIpPorts.class)
- .child(EndpointByFloatingIpPort.class)
- .build();
+ .child(NeutronByGbpMappings.class)
+ .child(ExternalGatewaysAsL3Endpoints.class)
+ .child(ExternalGatewayAsL3Endpoint.class)
+ .build();
}
public static InstanceIdentifier<EndpointByPort> endpointByPortIid(UniqueId portId) {
return InstanceIdentifier.builder(Mappings.class)
- .child(GbpByNeutronMappings.class)
- .child(EndpointsByPorts.class)
- .child(EndpointByPort.class, new EndpointByPortKey(portId))
- .build();
- }
-
- public static InstanceIdentifier<InternalPortByFloatingIpPort> internalPortByFloatingIpIid(UniqueId floatingIpPortId) {
- return InstanceIdentifier.builder(Mappings.class)
- .child(FloatingIpAssociationMappings.class)
- .child(InternalPortsByFloatingIpPorts.class)
- .child(InternalPortByFloatingIpPort.class, new InternalPortByFloatingIpPortKey(floatingIpPortId))
- .build();
+ .child(GbpByNeutronMappings.class)
+ .child(EndpointsByPorts.class)
+ .child(EndpointByPort.class, new EndpointByPortKey(portId))
+ .build();
}
- public static InstanceIdentifier<InternalPortByFloatingIpPort> neutronGbpInternalPortByFloatingIpIidWildcard() {
- return InstanceIdentifier.builder(Mappings.class)
- .child(FloatingIpAssociationMappings.class)
- .child(InternalPortsByFloatingIpPorts.class)
- .child(InternalPortByFloatingIpPort.class)
- .build();
+ public static InstanceIdentifier<NeutronByGbpMappings> neutronGbpMappingsIidWildcard() {
+ return InstanceIdentifier.builder(Mappings.class).child(NeutronByGbpMappings.class).build();
}
-
- public static InstanceIdentifier<NeutronByGbpMappings> neutronGbpMappingsIidWildcard() {
- return InstanceIdentifier.builder(Mappings.class)
- .child(NeutronByGbpMappings.class)
- .build();
+ public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeIid(
+ NodeId nodeId) {
+ return InstanceIdentifier.builder(Nodes.class)
+ .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class,
+ new NodeKey(nodeId))
+ .build();
}
}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
-import org.osgi.framework.BundleContext;
-
-public class NeutronOvsdbTest {
-
- private NeutronOvsdb neutronOvsdb;
-
- private DataBroker dataProvider;
- private RpcProviderRegistry rpcProvider;
- private BundleContext context;
-
- @Before
- public void initialise() {
- dataProvider = mock(DataBroker.class);
- rpcProvider = mock(RpcProviderRegistry.class);
- context = mock(BundleContext.class);
-
- EndpointService epService = mock(EndpointService.class);
- when(rpcProvider.getRpcService(EndpointService.class)).thenReturn(epService);
-
- neutronOvsdb = new NeutronOvsdb(dataProvider, rpcProvider, context);
- }
-
- @Test
- public void closeTest() throws Exception {
- neutronOvsdb.close();
- }
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.groupbasedpolicy.neutron.ovsdb;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
-import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.ExternalInterfaces;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
-public class NodeDataChangeListenerTest {
-
- private NodeDataChangeListener listener;
-
- private DataBroker dataBroker;
- private ListenerRegistration<DataChangeListener> registration;
- private Map<InstanceIdentifier<?>, DataObject> dataMap;
- private Set<InstanceIdentifier<?>> dataSet;
- private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
- private InstanceIdentifier<OvsdbNodeAugmentation> identifier;
- private OvsdbNodeAugmentation dataObject;
- private ReadOnlyTransaction readOnlyTransaction;
- private ReadWriteTransaction readWriteTransaction;
-
- @SuppressWarnings({"unchecked", "rawtypes"})
- @Before
- public void initialise() throws Exception {
- dataBroker = mock(DataBroker.class);
- registration = mock(ListenerRegistration.class);
- when(
- dataBroker.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(registration);
-
- TopologyId topologyId = mock(TopologyId.class);
- identifier = InstanceIdentifier.create(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(topologyId))
- .child(Node.class)
- .augmentation(OvsdbNodeAugmentation.class);
-
- dataObject = mock(OvsdbNodeAugmentation.class);
- ManagedNodeEntry managedNode = mock(ManagedNodeEntry.class);
- when((dataObject).getManagedNodeEntry()).thenReturn(Arrays.asList(managedNode));
- OvsdbBridgeRef bridgeRef = mock(OvsdbBridgeRef.class);
- when(managedNode.getBridgeRef()).thenReturn(bridgeRef);
- when(bridgeRef.getValue()).thenReturn((InstanceIdentifier) identifier);
-
- dataMap = new HashMap<InstanceIdentifier<?>, DataObject>();
- dataMap.put(identifier, dataObject);
- dataSet = new HashSet<InstanceIdentifier<?>>(Arrays.asList(identifier));
-
- OpenvswitchOtherConfigs config = mock(OpenvswitchOtherConfigs.class);
- when((dataObject).getOpenvswitchOtherConfigs()).thenReturn(Arrays.asList(config));
- when(config.getOtherConfigKey()).thenReturn("provider_mappings");
- when(config.getOtherConfigValue()).thenReturn("otherConfig:Value");
-
- readOnlyTransaction = mock(ReadOnlyTransaction.class);
- when(dataBroker.newReadOnlyTransaction()).thenReturn(readOnlyTransaction);
- CheckedFuture<Optional<?>, ReadFailedException> readOnlyFuture = mock(CheckedFuture.class);
- when(readOnlyTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
- readOnlyFuture);
- Optional<Node> readOnlyOptional = mock(Optional.class);
- when(readOnlyFuture.checkedGet()).thenReturn((Optional) readOnlyOptional);
- when(readOnlyOptional.isPresent()).thenReturn(true);
- Node node = mock(Node.class);
- when(readOnlyOptional.get()).thenReturn(node);
-
- OvsdbBridgeAugmentation ovsdbBridge = mock(OvsdbBridgeAugmentation.class);
- when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(ovsdbBridge);
- TerminationPoint terminationPoint = mock(TerminationPoint.class);
- when(node.getTerminationPoint()).thenReturn(Arrays.asList(terminationPoint));
- OvsdbTerminationPointAugmentation tpAug = mock(OvsdbTerminationPointAugmentation.class);
- when(terminationPoint.getAugmentation(OvsdbTerminationPointAugmentation.class)).thenReturn(tpAug);
- when(tpAug.getName()).thenReturn("Value");
- when(tpAug.getOfport()).thenReturn(5L);
- DatapathId datapathId = mock(DatapathId.class);
- when(ovsdbBridge.getDatapathId()).thenReturn(datapathId);
- when(datapathId.getValue()).thenReturn("FF:FF:FF:FF:FF:FF:FF:FF");
-
- change = mock(AsyncDataChangeEvent.class);
-
- readWriteTransaction = mock(ReadWriteTransaction.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
- CheckedFuture<Void, TransactionCommitFailedException> readWriteFuture = mock(CheckedFuture.class);
- when(readWriteTransaction.submit()).thenReturn(readWriteFuture);
- // ExternalInterfaces
- CheckedFuture<Optional<Node>, ReadFailedException> deleteFuture = mock(CheckedFuture.class);
- when(readWriteTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
- deleteFuture);
- Optional<Node> deleteOptional = mock(Optional.class);
- when(deleteFuture.checkedGet()).thenReturn(deleteOptional);
- when(deleteOptional.isPresent()).thenReturn(true);
-
- listener = new NodeDataChangeListener(dataBroker);
- }
-
- @Test
- public void constructorTest() throws Exception {
- listener.close();
- verify(registration).close();
- }
-
- @Test
- public void onDataChangeTestCreations() {
- when(change.getCreatedData()).thenReturn(dataMap);
- listener.onDataChanged(change);
- Assert.assertTrue(NodeDataChangeListener.nodeIdByExtInterface.containsKey(identifier));
- }
-
- @Test
- public void onDataChangeTestUpdates() {
- InstanceIdentifier<ExternalInterfaces> eiIdentifier = InstanceIdentifier.create(ExternalInterfaces.class);;
- NodeDataChangeListener.nodeIdByExtInterface.put(identifier, eiIdentifier);
- when(change.getUpdatedData()).thenReturn(dataMap);
- when((dataObject).getOpenvswitchOtherConfigs()).thenReturn(null);
- listener.onDataChanged(change);
- Assert.assertFalse(NodeDataChangeListener.nodeIdByExtInterface.containsKey(identifier));
- }
-
- @Test
- public void onDataChangeTestRemove() {
- InstanceIdentifier<ExternalInterfaces> eiIdentifier = InstanceIdentifier.create(ExternalInterfaces.class);;
- NodeDataChangeListener.nodeIdByExtInterface.put(identifier, eiIdentifier);
- when(change.getRemovedPaths()).thenReturn(dataSet);
- listener.onDataChanged(change);
- Assert.assertFalse(NodeDataChangeListener.nodeIdByExtInterface.containsKey(identifier));
- }
-
-}
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig;
Optional<Endpoint> endpointOptional = mock(Optional.class);
when(endpointFuture.checkedGet()).thenReturn(endpointOptional);
when(endpointOptional.isPresent()).thenReturn(true);
- Endpoint endpoint = mock(Endpoint.class);
- when(endpointOptional.get()).thenReturn(endpoint);
OfOverlayContext ofc = mock(OfOverlayContext.class);
- when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(ofc);
+ Endpoint endpoint = new EndpointBuilder().setL2Context(new L2BridgeDomainId("foo"))
+ .setMacAddress(new MacAddress("01:23:45:67:89:AB"))
+ .setTenant(new TenantId("fooTenant"))
+ .addAugmentation(OfOverlayContext.class, ofc)
+ .build();
+ when(endpointOptional.get()).thenReturn(endpoint);
// OfOverlayNodeConfig
ofOverlayNodeConfigFuture = mock(CheckedFuture.class);
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@Before
public void initialise() throws Exception {
epKey = mock(EndpointKey.class);
- endpoint = mock(Endpoint.class);
+ OfOverlayContext ofc = mock(OfOverlayContext.class);
+ endpoint = new EndpointBuilder().setL2Context(new L2BridgeDomainId("foo"))
+ .setMacAddress(new MacAddress("01:23:45:67:89:AB"))
+ .setTenant(new TenantId("fooTenant"))
+ .addAugmentation(OfOverlayContext.class, ofc)
+ .build();
readTransaction = mock(ReadOnlyTransaction.class);
writeTransaction = mock(ReadWriteTransaction.class);
readOptional = mock(Optional.class);
when(readFuture.checkedGet()).thenReturn(readOptional);
- OfOverlayContext ofc = mock(OfOverlayContext.class);
- when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(ofc);
-
submitFuture = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(submitFuture);
}
NodeId nodeId = mock(NodeId.class);
NodeConnectorId ncId = mock(NodeConnectorId.class);
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- when(dataBroker.newReadWriteTransaction()).thenReturn(transaction);
+ when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
when(transaction.submit()).thenReturn(submitFuture);
package org.opendaylight.groupbasedpolicy.neutron.ovsdb.util;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
import java.util.Iterator;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.FloatingIpAssociationMappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.NeutronByGbpMappings;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.InternalPortsByFloatingIpPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.floating.ip.association.mappings.internal.ports.by.floating.ip.ports.InternalPortByFloatingIpPortKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByFloatingIpPorts;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.EndpointsByPorts;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.floating.ip.ports.EndpointByFloatingIpPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPort;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.endpoints.by.ports.EndpointByPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ExternalGatewaysAsL3Endpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
public class NeutronOvsdbIidFactoryTest {
@Test
assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
assertEquals(OvsdbNodeAugmentation.class, id.getTargetType());
assertTrue(id.isWildcarded());
- assertEquals(ovsdbTopologyId, id.firstKeyOf(Topology.class, TopologyKey.class).getTopologyId().getValue());
+ assertEquals(ovsdbTopologyId, id.firstKeyOf(Topology.class).getTopologyId().getValue());
}
@Test
assertTrue(id.isWildcarded());
}
- @Test
- public void neutronGbpFloatingIpIidWildcardTest() {
- InstanceIdentifier<EndpointByFloatingIpPort> id = NeutronOvsdbIidFactory.neutronGbpFloatingIpIidWildcard();
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, GbpByNeutronMappings.class,
- EndpointsByFloatingIpPorts.class, EndpointByFloatingIpPort.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(EndpointByFloatingIpPort.class, id.getTargetType());
- assertTrue(id.isWildcarded());
- }
-
@Test
public void endpointByPortIidTest() {
final String portId = "e0bb2cf8-8855-434e-839b-d2e59e045218";
assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
assertEquals(EndpointByPort.class, id.getTargetType());
assertFalse(id.isWildcarded());
- assertEquals(portId, id.firstKeyOf(EndpointByPort.class, EndpointByPortKey.class).getPortId().getValue());
- }
-
- @Test
- public void internalPortByFloatingIpIidTest() {
- final String floatingIpPortId = "02b9c2ed-8626-472b-8f58-808539cd62a7";
- InstanceIdentifier<InternalPortByFloatingIpPort> id = NeutronOvsdbIidFactory.internalPortByFloatingIpIid(new UniqueId(floatingIpPortId));
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, FloatingIpAssociationMappings.class,
- InternalPortsByFloatingIpPorts.class, InternalPortByFloatingIpPort.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(InternalPortByFloatingIpPort.class, id.getTargetType());
- assertFalse(id.isWildcarded());
- assertEquals(floatingIpPortId, id.firstKeyOf(InternalPortByFloatingIpPort.class, InternalPortByFloatingIpPortKey.class).getFloatingIpPortId().getValue());
- }
-
- @Test
- public void neutronGbpInternalPortByFloatingIpIidWildcardTest() {
- InstanceIdentifier<InternalPortByFloatingIpPort> id = NeutronOvsdbIidFactory.neutronGbpInternalPortByFloatingIpIidWildcard();
- assertNotNull(id);
- Class<?>[] expectedTypes = {Mappings.class, FloatingIpAssociationMappings.class,
- InternalPortsByFloatingIpPorts.class, InternalPortByFloatingIpPort.class};
- assertPathArgumentTypes(id.getPathArguments(), expectedTypes);
- assertEquals(InternalPortByFloatingIpPort.class, id.getTargetType());
- assertTrue(id.isWildcarded());
+ assertEquals(portId, id.firstKeyOf(EndpointByPort.class).getPortId().getValue());
}
@Test
private static final Logger LOG = LoggerFactory.getLogger(EndpointManager.class);
private final EndpointManagerListener endpointListener;
+ private final OfOverlayContextListener ofOverlayContextListener;
+ private final OfOverlayL3ContextListener ofOverlayL3ContextListener;
private final ConcurrentMap<EpKey, Endpoint> endpoints = new ConcurrentHashMap<>();
private final ConcurrentMap<EpKey, Endpoint> externalEndpointsWithoutLocation = new ConcurrentHashMap<>();
private final ConcurrentMap<NodeId, ConcurrentMap<EgKey, Set<EpKey>>> endpointsByGroupByNode =
}
if (dataProvider != null) {
endpointListener = new EndpointManagerListener(this.dataProvider, this);
+ ofOverlayContextListener = new OfOverlayContextListener(dataProvider, switchManager);
+ ofOverlayL3ContextListener = new OfOverlayL3ContextListener(dataProvider, switchManager);
} else {
endpointListener = null;
+ ofOverlayContextListener = null;
+ ofOverlayL3ContextListener = null;
}
LOG.debug("Initialized OFOverlay endpoint manager");
}
// auto closeable
@Override
public void close() throws Exception {
- if (endpointListener != null)
+ if (endpointListener != null) {
endpointListener.close();
+ }
if (notificationListenerRegistration != null) {
notificationListenerRegistration.close();
}
+ if (ofOverlayContextListener != null) {
+ ofOverlayContextListener.close();
+ }
+ if (ofOverlayL3ContextListener != null) {
+ ofOverlayL3ContextListener.close();
+ }
}
private Set<EpKey> getEpNGSet(NodeId location, EgKey eg) {
return egKeys;
}
- @SuppressWarnings("unused")
- private Endpoint addEndpointFromL3Endpoint(EndpointL3 l3Ep, ReadWriteTransaction rwTx) {
- // Make an indexed tenant and resolveL2BridgeDomain from L3EP containment if not L3
- // (instanceof)
- OfOverlayL3Context ofL3Ctx = l3Ep.getAugmentation(OfOverlayL3Context.class);
- OfOverlayContext ofCtx = new OfOverlayContextBuilder(ofL3Ctx).build();
- if (l3Ep.getNetworkContainment() instanceof L3Context) {
- LOG.error("Cannot generate Endpoint from EndpointL3, network containment is L3Context.");
- rwTx.cancel();
- return null;
- }
-
- IndexedTenant indexedTenant;
- Optional<Tenant> tenant =
- readFromDs(LogicalDatastoreType.CONFIGURATION, IidFactory.tenantIid(l3Ep.getTenant()), rwTx);
- if (tenant.isPresent()) {
- indexedTenant = new IndexedTenant(tenant.get());
- } else {
- LOG.error("Could not find tenant {} for EndpointL3 {}", l3Ep.getTenant(), l3Ep);
- rwTx.cancel();
- return null;
- }
- List<L3Address> l3Address = new ArrayList<>();
- l3Address.add(new L3AddressBuilder().setIpAddress(l3Ep.getIpAddress())
- .setL3Context(l3Ep.getL3Context())
- .setKey(new L3AddressKey(l3Ep.getIpAddress(), l3Ep.getL3Context()))
- .build());
- L2BridgeDomain l2Bd = indexedTenant.resolveL2BridgeDomain(l3Ep.getNetworkContainment());
- Endpoint ep = new EndpointBuilder().setKey(new EndpointKey(l2Bd.getId(), l3Ep.getMacAddress()))
- .setMacAddress(l3Ep.getMacAddress())
- .setL2Context(l2Bd.getId())
- .setEndpointGroups(l3Ep.getEndpointGroups())
- .setTenant(l3Ep.getTenant())
- .setL3Address(l3Address)
- .setCondition(l3Ep.getCondition())
- .setNetworkContainment(l3Ep.getNetworkContainment())
- .addAugmentation(OfOverlayContext.class, ofCtx)
- .build();
- rwTx.put(LogicalDatastoreType.OPERATIONAL, IidFactory.endpointIid(ep.getL2Context(), ep.getMacAddress()), ep);
- return ep;
- }
-
private Set<EndpointGroupId> getEndpointGroupsFromEndpoint(Endpoint ep) {
if (ep == null)
return new HashSet<>();
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Determines node-id and node-connector-id as location for an endpoint based on port-name.
+ */
+public class OfOverlayContextListener extends DataTreeChangeHandler<OfOverlayContext> {
+
+ private static final Logger LOG = LoggerFactory.getLogger(OfOverlayContextListener.class);
+ private final SwitchManager swManager;
+
+ public OfOverlayContextListener(DataBroker dataProvider, SwitchManager swManager) {
+ super(dataProvider, new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier
+ .builder(Endpoints.class).child(Endpoint.class).augmentation(OfOverlayContext.class).build()));
+ this.swManager = checkNotNull(swManager);
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<OfOverlayContext> rootNode,
+ InstanceIdentifier<OfOverlayContext> rootIdentifier) {
+ OfOverlayContext ofOverlayCtx = rootNode.getDataAfter();
+ LOG.trace("on write: \n OfOverlayContext: {} \n rootIdentifier: {}", ofOverlayCtx, rootIdentifier);
+ if (ofOverlayCtx.getNodeConnectorId() != null && ofOverlayCtx.getNodeId() != null) {
+ return; // Location is already on EP
+ }
+ Name portName = ofOverlayCtx.getPortName();
+ updateLocationBasedOnPortName(portName, rootIdentifier);
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<OfOverlayContext> rootNode,
+ InstanceIdentifier<OfOverlayContext> rootIdentifier) {
+ // NOOP
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<OfOverlayContext> rootNode,
+ InstanceIdentifier<OfOverlayContext> rootIdentifier) {
+ Name newPortName = rootNode.getDataAfter().getPortName();
+ Name oldPortName = rootNode.getDataBefore().getPortName();
+ LOG.trace("on update: \n old OfOverlayContext: {} \n new OfOverlayContext: {} \n rootIdentifier: {}",
+ rootNode.getDataBefore(), rootNode.getDataAfter(), rootIdentifier);
+ if (oldPortName == null && newPortName == null) {
+ LOG.debug("Cannot update location for EP {} because port-name is missing.",
+ rootIdentifier.firstKeyOf(Endpoint.class));
+ return;
+ }
+ if (oldPortName != null && newPortName != null && oldPortName.equals(newPortName)) {
+ LOG.debug("No need to update location for EP {} because port-name {} was not changed.",
+ rootIdentifier.firstKeyOf(Endpoint.class), oldPortName.getValue());
+ return;
+ }
+ updateLocationBasedOnPortName(newPortName, rootIdentifier);
+ }
+
+ private void updateLocationBasedOnPortName(Name portName, InstanceIdentifier<OfOverlayContext> rootIdentifier) {
+ if (portName == null) {
+ LOG.debug("Cannot determine EP location for EP because port-name is missing.",
+ rootIdentifier.firstKeyOf(Endpoint.class));
+ return;
+ }
+ InstanceIdentifier<NodeConnector> ncIid = swManager.getNodeConnectorIidForPortName(portName);
+ if (ncIid == null) {
+ LOG.debug("Cannot determine EP location for EP {} because node-connector with port-name {}"
+ + " does not exist on any node.", rootIdentifier.firstKeyOf(Endpoint.class), portName);
+ return;
+ }
+ NodeId nodeId = ncIid.firstKeyOf(Node.class).getId();
+ NodeConnectorId ncId = ncIid.firstKeyOf(NodeConnector.class).getId();
+ WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ OfOverlayContext newOfOverlayCtx =
+ new OfOverlayContextBuilder().setNodeId(nodeId).setNodeConnectorId(ncId).build();
+ wTx.merge(LogicalDatastoreType.OPERATIONAL, rootIdentifier, newOfOverlayCtx);
+ DataStoreHelper.submitToDs(wTx);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3ContextBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Determines node-id and node-connector-id as location for an L3 endpoint based on port-name.
+ */
+public class OfOverlayL3ContextListener extends DataTreeChangeHandler<OfOverlayL3Context> {
+
+ private static final Logger LOG = LoggerFactory.getLogger(OfOverlayL3ContextListener.class);
+ private final SwitchManager swManager;
+
+ public OfOverlayL3ContextListener(DataBroker dataProvider, SwitchManager swManager) {
+ super(dataProvider, new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier
+ .builder(Endpoints.class).child(EndpointL3.class).augmentation(OfOverlayL3Context.class).build()));
+ this.swManager = checkNotNull(swManager);
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<OfOverlayL3Context> rootNode,
+ InstanceIdentifier<OfOverlayL3Context> rootIdentifier) {
+ OfOverlayL3Context ofOverlayL3Ctx = rootNode.getDataAfter();
+ LOG.trace("on write: \n OfOverlayL3Context: {} \n rootIdentifier: {}", ofOverlayL3Ctx, rootIdentifier);
+ if (ofOverlayL3Ctx.getNodeConnectorId() != null && ofOverlayL3Ctx.getNodeId() != null) {
+ return; // Location is already on L3EP
+ }
+ Name portName = ofOverlayL3Ctx.getPortName();
+ updateLocationBasedOnPortName(portName, rootIdentifier);
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<OfOverlayL3Context> rootNode,
+ InstanceIdentifier<OfOverlayL3Context> rootIdentifier) {
+ // NOOP
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<OfOverlayL3Context> rootNode,
+ InstanceIdentifier<OfOverlayL3Context> rootIdentifier) {
+ Name newPortName = rootNode.getDataAfter().getPortName();
+ Name oldPortName = rootNode.getDataBefore().getPortName();
+ LOG.trace("on update: \n old OfOverlayL3Context: {} \n new OfOverlayL3Context: {} \n rootIdentifier: {}",
+ rootNode.getDataBefore(), rootNode.getDataAfter(), rootIdentifier);
+ if (oldPortName == null && newPortName == null) {
+ LOG.debug("Cannot update location for L3EP {} because port-name is missing.",
+ rootIdentifier.firstKeyOf(EndpointL3.class));
+ return;
+ }
+ if (oldPortName != null && newPortName != null && oldPortName.equals(newPortName)) {
+ LOG.debug("No need to update location for L3EP {} because port-name {} was not changed.",
+ rootIdentifier.firstKeyOf(EndpointL3.class), oldPortName.getValue());
+ return;
+ }
+ updateLocationBasedOnPortName(newPortName, rootIdentifier);
+ }
+
+ private void updateLocationBasedOnPortName(Name portName, InstanceIdentifier<OfOverlayL3Context> rootIdentifier) {
+ if (portName == null) {
+ LOG.debug("Cannot determine L3EP location for L3EP because port-name is missing.",
+ rootIdentifier.firstKeyOf(EndpointL3.class));
+ return;
+ }
+ InstanceIdentifier<NodeConnector> ncIid = swManager.getNodeConnectorIidForPortName(portName);
+ if (ncIid == null) {
+ LOG.debug("Cannot determine L3EP location for L3EP {} because node-connector with port-name {}"
+ + " does not exist on any node.", rootIdentifier.firstKeyOf(EndpointL3.class), portName);
+ return;
+ }
+ NodeId nodeId = ncIid.firstKeyOf(Node.class).getId();
+ NodeConnectorId ncId = ncIid.firstKeyOf(NodeConnector.class).getId();
+ WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ OfOverlayL3Context newOfOverlayCtx =
+ new OfOverlayL3ContextBuilder().setNodeId(nodeId).setNodeConnectorId(ncId).build();
+ wTx.merge(LogicalDatastoreType.OPERATIONAL, rootIdentifier, newOfOverlayCtx);
+ DataStoreHelper.submitToDs(wTx);
+ }
+
+}
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig.EncapsulationFormat;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayNodeConfig;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.nodes.node.ExternalInterfaces;
state.updateStatus();
}
+ public synchronized InstanceIdentifier<NodeConnector> getNodeConnectorIidForPortName(Name portName) {
+ for (SwitchState sw : switches.values()) {
+ if (sw.fcncByNcIid == null) {
+ continue;
+ }
+ for (Entry<InstanceIdentifier<NodeConnector>, FlowCapableNodeConnector> fcncByNcIidEntry : sw.fcncByNcIid
+ .entrySet()) {
+ FlowCapableNodeConnector fcnc = fcncByNcIidEntry.getValue();
+ if (portName.getValue().equals(fcnc.getName())) {
+ return fcncByNcIidEntry.getKey();
+ }
+ }
+ }
+ return null;
+ }
+
/**
* Get the collection of switches that are in the "ready" state. Note
* that the collection is immutable.
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
policyValidatorRegistry = mock(PolicyValidatorRegistry.class);
tableOffset = 5;
configReg = mock(ListenerRegistration.class);
- when(
- dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(configReg);
+ when(dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(configReg);
+ when(dataProvider.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
+ any(DataTreeChangeListener.class))).thenReturn(configReg);
WriteTransaction writeTransaction = mock(WriteTransaction.class);
when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
@Test
public void constructorTest() throws Exception {
renderer.close();
- verify(configReg, times(5)).close();
+ verify(configReg, times(10)).close();
}
@Test
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
when(writeTransaction.submit()).thenReturn(checkedFutureWrite);
BindingAwareBroker.RpcRegistration<EndpointService> rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
listenerReg = mock(ListenerRegistration.class);
- when(
- dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
- any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerReg);
+ when(dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerReg);
+ when(dataProvider.registerDataTreeChangeListener(any(DataTreeIdentifier.class),
+ any(DataTreeChangeListener.class))).thenReturn(listenerReg);
+
when(rpcRegistry.addRpcImplementation(any(Class.class), any(RpcService.class))).thenReturn(rpcRegistration);
manager = spy(new EndpointManager(dataProvider, rpcRegistry, notificationService, executor, switchManager));
Assert.assertFalse(collection.isEmpty());
}
- @SuppressWarnings({"unchecked"})
- @Test
- public void addEndpointFromL3EndpointTest() throws Exception {
- EndpointL3 l3Ep = mock(EndpointL3.class);
- ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
- OfOverlayL3Context ofL3Ctx = mock(OfOverlayL3Context.class);
- when(l3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofL3Ctx);
-
- CheckedFuture<Optional<Tenant>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
- when(rwTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
- Optional<Tenant> optional = mock(Optional.class);
- when(checkedFuture.checkedGet()).thenReturn(optional);
- Tenant tenant = mock(Tenant.class);
- ForwardingContext fwCtx = mock(ForwardingContext.class);
- when(tenant.getForwardingContext()).thenReturn(fwCtx);
- when(optional.isPresent()).thenReturn(true);
- when(optional.get()).thenReturn(tenant);
-
- L2BridgeDomain l2BridgeDomain = mock(L2BridgeDomain.class);
- when(fwCtx.getL2BridgeDomain()).thenReturn(Collections.singletonList(l2BridgeDomain));
- L2BridgeDomainId l2BridgeDomainId = mock(L2BridgeDomainId.class);
- when(l2BridgeDomain.getId()).thenReturn(l2BridgeDomainId);
- String l2bdValue = UUID.randomUUID().toString();
- when(l2BridgeDomainId.getValue()).thenReturn(l2bdValue);
-
- NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
- when(l3Ep.getNetworkContainment()).thenReturn(networkDomainId);
- when(networkDomainId.getValue()).thenReturn(l2bdValue);
-
- Method method = EndpointManager.class.getDeclaredMethod("addEndpointFromL3Endpoint", EndpointL3.class,
- ReadWriteTransaction.class);
- method.setAccessible(true);
- method.invoke(manager, l3Ep, rwTx);
- verify(rwTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Endpoint.class));
- }
-
- @SuppressWarnings({"unchecked"})
- @Test
- public void addEndpointFromL3EndpointTestTenantPresentFalse() throws Exception {
- EndpointL3 l3Ep = mock(EndpointL3.class);
- ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
- OfOverlayL3Context ofL3Ctx = mock(OfOverlayL3Context.class);
- when(l3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofL3Ctx);
-
- CheckedFuture<Optional<Tenant>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
- when(rwTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
- Optional<Tenant> optional = mock(Optional.class);
- when(checkedFuture.checkedGet()).thenReturn(optional);
- when(optional.isPresent()).thenReturn(false);
-
- Method method = EndpointManager.class.getDeclaredMethod("addEndpointFromL3Endpoint", EndpointL3.class,
- ReadWriteTransaction.class);
- method.setAccessible(true);
- method.invoke(manager, l3Ep, rwTx);
- verify(rwTx).cancel();
- }
-
@Test
public void closeTest() throws Exception {
manager.close();
- verify(listenerReg).close();
- manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
- manager.close();
- verify(listenerReg, times(1)).close();
+ verify(listenerReg, times(3)).close();
}
//**************
Code Review / groupbasedpolicy.git / commitdiff