From 4616f0300655582153362a21910bd1f0b14937ae Mon Sep 17 00:00:00 2001 From: Marek Gradzki Date: Fri, 10 Mar 2017 12:50:53 +0100 Subject: HC2VPP-55: policer&policer assignment CRUD support Change-Id: I627d2a56ab2a282744ea0172b4a0c72240b0032f Signed-off-by: Marek Gradzki --- .../policer/read/InterfacePolicerCustomizer.java | 122 ++++++++++++ .../read/InterfacePolicerReaderFactory.java | 59 ++++++ .../fd/hc2vpp/policer/read/PolicerCustomizer.java | 218 +++++++++++++++++++++ .../hc2vpp/policer/read/PolicerReaderFactory.java | 50 +++++ 4 files changed, 449 insertions(+) create mode 100644 vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/InterfacePolicerCustomizer.java create mode 100644 vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/InterfacePolicerReaderFactory.java create mode 100644 vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/PolicerCustomizer.java create mode 100644 vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/PolicerReaderFactory.java (limited to 'vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read') diff --git a/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/InterfacePolicerCustomizer.java b/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/InterfacePolicerCustomizer.java new file mode 100644 index 000000000..c681758f1 --- /dev/null +++ b/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/InterfacePolicerCustomizer.java @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.policer.read; + +import static com.google.common.base.Preconditions.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.hc2vpp.vpp.classifier.context.VppClassifierContextManager; +import io.fd.honeycomb.translate.ModificationCache; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager; +import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor; +import io.fd.vpp.jvpp.core.dto.PolicerClassifyDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.PolicerClassifyDump; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import java.util.Optional; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.policer.rev170315.PolicerInterfaceStateAugmentationBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.policer.rev170315._interface.policer.attributes.Policer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.policer.rev170315._interface.policer.attributes.PolicerBuilder; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +final class InterfacePolicerCustomizer extends FutureJVppCustomizer + implements ReaderCustomizer, + JvppReplyConsumer, ByteDataTranslator { + + private static final byte TABLE_IP4 = 0; + private static final byte TABLE_IP6 = 1; + private static final byte TABLE_L2 = 2; + + private final DumpCacheManager dumpManager; + private final NamingContext interfaceContext; + private final VppClassifierContextManager classifyTableContext; + + InterfacePolicerCustomizer(@Nonnull final FutureJVppCore futureJVppCore, + @Nonnull final NamingContext interfaceContext, + @Nonnull final VppClassifierContextManager classifyTableContext) { + super(futureJVppCore); + this.interfaceContext = checkNotNull(interfaceContext, "interfaceContext should not be null"); + this.classifyTableContext = checkNotNull(classifyTableContext, "classifyTableContext should not be null"); + dumpManager = new DumpCacheManager.DumpCacheManagerBuilder() + .withExecutor(executor()) + .acceptOnly(PolicerClassifyDetailsReplyDump.class) + .build(); + } + + private EntityDumpExecutor executor() { + return (id, type) -> { + PolicerClassifyDump request = new PolicerClassifyDump(); + request.type = type; + return getReplyForRead(getFutureJVpp().policerClassifyDump(request).toCompletableFuture(), id); + }; + } + + @Nonnull + @Override + public PolicerBuilder getBuilder(@Nonnull final InstanceIdentifier instanceIdentifier) { + return new PolicerBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier id, + @Nonnull final PolicerBuilder builder, + @Nonnull final ReadContext ctx) + throws ReadFailedException { + final String ifcName = id.firstKeyOf(Interface.class).getName(); + final int ifcIndex = interfaceContext.getIndex(ifcName, ctx.getMappingContext()); + // FIXME: only first dump will result in jvpp call, so either we improve + // DumpCacheManager(HONEYCOMB-348) or we need to do it directly (probably without caching): + final Optional ip4 = readTableIndex(id, ifcIndex, TABLE_IP4, ctx.getModificationCache()); + if (ip4.isPresent()) { + builder.setIp4Table(classifyTableContext.getTableName(ip4.get(), ctx.getMappingContext())); + } + final Optional ip6 = readTableIndex(id, ifcIndex, TABLE_IP6, ctx.getModificationCache()); + if (ip6.isPresent()) { + builder.setIp6Table(classifyTableContext.getTableName(ip6.get(), ctx.getMappingContext())); + } + final Optional l2 = readTableIndex(id, ifcIndex, TABLE_L2, ctx.getModificationCache()); + if (l2.isPresent()) { + builder.setL2Table(classifyTableContext.getTableName(l2.get(), ctx.getMappingContext())); + } + } + + private Optional readTableIndex(@Nonnull final InstanceIdentifier id, final int ifcIndex, + final byte type, + final ModificationCache cache) throws ReadFailedException { + final com.google.common.base.Optional dump = + dumpManager.getDump(id, cache, type); + if (!dump.isPresent() || dump.get().policerClassifyDetails.isEmpty()) { + return Optional.empty(); + } + return dump.get().policerClassifyDetails.stream().filter(detail -> detail.swIfIndex == ifcIndex).findFirst() + .map(details -> details.tableIndex); + } + + @Override + public void merge(@Nonnull final Builder builder, @Nonnull final Policer policer) { + ((PolicerInterfaceStateAugmentationBuilder) builder).setPolicer(policer); + } +} diff --git a/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/InterfacePolicerReaderFactory.java b/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/InterfacePolicerReaderFactory.java new file mode 100644 index 000000000..da027310a --- /dev/null +++ b/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/InterfacePolicerReaderFactory.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.policer.read; + +import com.google.inject.Inject; +import com.google.inject.name.Named; +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.hc2vpp.vpp.classifier.context.VppClassifierContextManager; +import io.fd.honeycomb.translate.impl.read.GenericReader; +import io.fd.honeycomb.translate.read.ReaderFactory; +import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.policer.rev170315.PolicerInterfaceStateAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.policer.rev170315.PolicerInterfaceStateAugmentationBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.policer.rev170315._interface.policer.attributes.Policer; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfacePolicerReaderFactory implements ReaderFactory { + private static final InstanceIdentifier IFC_ID = + InstanceIdentifier.create(InterfacesState.class).child(Interface.class); + private static final InstanceIdentifier POLICER_IFC_ID = + IFC_ID.augmentation(PolicerInterfaceStateAugmentation.class); + + private static final InstanceIdentifier POLICER_IID = POLICER_IFC_ID.child(Policer.class); + + @Inject + private FutureJVppCore vppApi; + @Inject + @Named("interface-context") + private NamingContext ifcContext; + @Inject + @Named("classify-table-context") + private VppClassifierContextManager classifyTableContext; + + @Override + public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) { + InstanceIdentifier IID = InstanceIdentifier.create(Policer.class); + registry.addStructuralReader(POLICER_IFC_ID, PolicerInterfaceStateAugmentationBuilder.class); + registry.add( + new GenericReader<>(POLICER_IID, new InterfacePolicerCustomizer(vppApi, ifcContext, classifyTableContext))); + } +} diff --git a/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/PolicerCustomizer.java b/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/PolicerCustomizer.java new file mode 100644 index 000000000..9d4c40f50 --- /dev/null +++ b/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/PolicerCustomizer.java @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.policer.read; + +import static io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor.NO_PARAMS; + +import com.google.common.base.Optional; +import com.google.common.primitives.Longs; +import com.google.common.primitives.UnsignedInts; +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer; +import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager; +import io.fd.vpp.jvpp.core.dto.PolicerDetails; +import io.fd.vpp.jvpp.core.dto.PolicerDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.PolicerDump; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import java.math.BigInteger; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Dscp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.DscpType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.MeterActionDrop; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.MeterActionMarkDscp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.MeterActionTransmit; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.MeterActionType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.MeterType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.PolicerRateType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.PolicerRoundType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.Policers; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.PolicersStateBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.VppDscpType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ConformAction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ConformActionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ExceedAction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ExceedActionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ViolateAction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ViolateActionBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policers.state.Policer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policers.state.PolicerBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policers.state.PolicerKey; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +final class PolicerCustomizer extends FutureJVppCustomizer + implements InitializingListReaderCustomizer, + JvppReplyConsumer, ByteDataTranslator { + + private final DumpCacheManager dumpManager; + + PolicerCustomizer(@Nonnull final FutureJVppCore futureJVppCore) { + super(futureJVppCore); + dumpManager = new DumpCacheManager.DumpCacheManagerBuilder() + .withExecutor( + (id, param) -> getReplyForRead(getFutureJVpp().policerDump(new PolicerDump()).toCompletableFuture(), + id)) + .acceptOnly(PolicerDetailsReplyDump.class) + .build(); + } + + @Nonnull + @Override + public List getAllIds(@Nonnull final InstanceIdentifier id, + @Nonnull final ReadContext ctx) throws ReadFailedException { + final Optional dump = dumpManager.getDump(id, ctx.getModificationCache(), NO_PARAMS); + + if (!dump.isPresent() || dump.get().policerDetails.isEmpty()) { + return Collections.emptyList(); + } + return dump.get().policerDetails.stream().map(detail -> new PolicerKey(toString(detail.name))) + .collect(Collectors.toList()); + } + + @Override + public void merge(@Nonnull final Builder builder, @Nonnull final List list) { + ((PolicersStateBuilder) builder).setPolicer(list); + } + + @Nonnull + @Override + public PolicerBuilder getBuilder(@Nonnull final InstanceIdentifier id) { + return new PolicerBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier id, + @Nonnull final PolicerBuilder builder, + @Nonnull final ReadContext ctx) throws ReadFailedException { + final Optional dump = dumpManager.getDump(id, ctx.getModificationCache(), NO_PARAMS); + + if (!dump.isPresent() || dump.get().policerDetails.isEmpty()) { + return; + } + final PolicerKey key = id.firstKeyOf(Policer.class); + final java.util.Optional result = + dump.get().policerDetails.stream().filter(detail -> key.equals(new PolicerKey(toString(detail.name)))).findFirst(); + if (!result.isPresent()) { + return; + } + final PolicerDetails details = result.get(); + builder.setName(toString(details.name)); + builder.setCir(UnsignedInts.toLong(details.cir)); + builder.setEir(UnsignedInts.toLong(details.eir)); + // TODO(HC2VPP-117): policer init fails if cb is configured (looks like byte ordering issue on VPP side) + builder.setCb(toUnsignedBigInteger(details.cb)); + builder.setEb(toUnsignedBigInteger(details.eb)); + builder.setRateType(PolicerRateType.forValue(details.rateType)); + builder.setRoundType(PolicerRoundType.forValue(details.roundType)); + builder.setType(MeterType.forValue(details.type)); + builder.setColorAware(byteToBoolean(details.colorAware)); + builder.setConformAction(parseConformAction(details)); + builder.setExceedAction(parseExceedAction(details)); + builder.setViolateAction(parseViolateAction(details)); + + // operational only data: + builder.setSingleRate(byteToBoolean(details.singleRate)); + builder.setScale(UnsignedInts.toLong(details.scale)); + builder.setCirTokensPerPeriod(UnsignedInts.toLong(details.cirTokensPerPeriod)); + builder.setPirTokensPerPeriod(UnsignedInts.toLong(details.pirTokensPerPeriod)); + builder.setCurrentLimit(UnsignedInts.toLong(details.currentLimit)); + builder.setCurrentBucket(UnsignedInts.toLong(details.currentBucket)); + builder.setExtendedLimit(UnsignedInts.toLong(details.extendedLimit)); + builder.setExtendedBucket(UnsignedInts.toLong(details.extendedBucket)); + builder.setLastUpdateTime(toUnsignedBigInteger(details.lastUpdateTime)); + } + + private BigInteger toUnsignedBigInteger(final long value) { + return new BigInteger(1, Longs.toByteArray(value)); + } + + private Class parseMeterActionType(final byte actionType) { + switch (actionType) { + case 0: + return MeterActionDrop.class; + case 1: + return MeterActionTransmit.class; + case 2: + return MeterActionMarkDscp.class; + default: + throw new IllegalArgumentException("Unsupported meter action type " + actionType); + } + } + + private DscpType parseDscp(final byte dscp, final byte conformActionType) { + if (dscp == -1 || conformActionType != 2) { + return null; + } + VppDscpType vppDcspType = VppDscpType.forValue(dscp); + if (vppDcspType != null) { + return new DscpType(vppDcspType); + } + return new DscpType(new Dscp((short) dscp)); + } + + private ConformAction parseConformAction(final PolicerDetails details) { + ConformActionBuilder action = new ConformActionBuilder(); + action.setMeterActionType(parseMeterActionType(details.conformActionType)); + action.setDscp(parseDscp(details.conformDscp, details.conformActionType)); + return action.build(); + } + + + private ExceedAction parseExceedAction(final PolicerDetails details) { + ExceedActionBuilder action = new ExceedActionBuilder(); + action.setMeterActionType(parseMeterActionType(details.exceedActionType)); + action.setDscp(parseDscp(details.exceedDscp, details.conformActionType)); + return action.build(); + } + + private ViolateAction parseViolateAction(final PolicerDetails details) { + ViolateActionBuilder action = new ViolateActionBuilder(); + action.setMeterActionType(parseMeterActionType(details.violateActionType)); + action.setDscp(parseDscp(details.violateDscp, details.conformActionType)); + return action.build(); + } + + @Nonnull + @Override + public Initialized init(@Nonnull final InstanceIdentifier id, + @Nonnull final Policer policer, + @Nonnull final ReadContext readContext) { + return Initialized.create(getCfgId(id), + new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policers.PolicerBuilder( + policer) + .setName(policer.getName()) + .build()); + } + + private static InstanceIdentifier getCfgId( + final InstanceIdentifier id) { + final PolicerKey key = id.firstKeyOf(Policer.class); + return InstanceIdentifier.create(Policers.class).child( + org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policers.Policer.class, + new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policers.PolicerKey( + key.getName())); + } +} diff --git a/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/PolicerReaderFactory.java b/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/PolicerReaderFactory.java new file mode 100644 index 000000000..3636d0f95 --- /dev/null +++ b/vpp-classifier/impl/src/main/java/io/fd/hc2vpp/policer/read/PolicerReaderFactory.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.policer.read; + +import com.google.common.collect.Sets; +import com.google.inject.Inject; +import io.fd.honeycomb.translate.impl.read.GenericInitListReader; +import io.fd.honeycomb.translate.read.ReaderFactory; +import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.PolicersState; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.PolicersStateBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ConformAction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ExceedAction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policer.base.attributes.ViolateAction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.policer.rev170315.policers.state.Policer; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class PolicerReaderFactory implements ReaderFactory { + private static final InstanceIdentifier ROOT_IID = InstanceIdentifier.create(PolicersState.class); + private static final InstanceIdentifier POLICER_IID = ROOT_IID.child(Policer.class); + + @Inject + private FutureJVppCore vppApi; + + @Override + public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) { + InstanceIdentifier IID = InstanceIdentifier.create(Policer.class); + registry.addStructuralReader(ROOT_IID, PolicersStateBuilder.class); + registry.subtreeAdd( + Sets.newHashSet(IID.child(ConformAction.class), IID.child(ExceedAction.class), + IID.child(ViolateAction.class)), + new GenericInitListReader<>(POLICER_IID, new PolicerCustomizer(vppApi))); + } +} -- cgit 1.2.3-korg