Examples with Meter org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter used on opensource projects

Example 26 with Meter

use of org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter in project openflowplugin by opendaylight.

the class MeterListenerTest method staleMeterCreationTest.

@Test
public void staleMeterCreationTest() throws Exception {
    addFlowCapableNode(NODE_KEY);
    StaleMeterKey meterKey = new StaleMeterKey(new MeterId((long) 2000));
    InstanceIdentifier<StaleMeter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY).augmentation(FlowCapableNode.class).child(StaleMeter.class, meterKey);
    StaleMeter meter = new StaleMeterBuilder().setKey(meterKey).setMeterName("stale_meter_one").build();
    WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
    writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
    assertCommit(writeTx.submit());
}

Example 27 with Meter

use of org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter in project openflowplugin by opendaylight.

the class FlowNodeReconciliationImpl method reconciliationPreProcess.

private void reconciliationPreProcess(final InstanceIdentifier<FlowCapableNode> nodeIdent) {
    List<InstanceIdentifier<StaleFlow>> staleFlowsToBeBulkDeleted = Lists.newArrayList();
    List<InstanceIdentifier<StaleGroup>> staleGroupsToBeBulkDeleted = Lists.newArrayList();
    List<InstanceIdentifier<StaleMeter>> staleMetersToBeBulkDeleted = Lists.newArrayList();
    ReadOnlyTransaction trans = provider.getReadTranaction();
    Optional<FlowCapableNode> flowNode = Optional.absent();
    try {
        flowNode = trans.read(LogicalDatastoreType.CONFIGURATION, nodeIdent).get();
    } catch (ExecutionException | InterruptedException e) {
        LOG.warn("Reconciliation Pre-Processing Fail with read Config/DS for Node {} !", nodeIdent, e);
    }
    if (flowNode.isPresent()) {
        LOG.debug("Proceeding with deletion of stale-marked Flows on switch {} using Openflow interface", nodeIdent.toString());
        /* Stale-Flows - Stale-marked Flows have to be removed first for safety */
        List<Table> tables = flowNode.get().getTable() != null ? flowNode.get().getTable() : Collections.<Table>emptyList();
        for (Table table : tables) {
            final KeyedInstanceIdentifier<Table, TableKey> tableIdent = nodeIdent.child(Table.class, table.getKey());
            List<StaleFlow> staleFlows = table.getStaleFlow() != null ? table.getStaleFlow() : Collections.<StaleFlow>emptyList();
            for (StaleFlow staleFlow : staleFlows) {
                FlowBuilder flowBuilder = new FlowBuilder(staleFlow);
                Flow toBeDeletedFlow = flowBuilder.setId(staleFlow.getId()).build();
                final KeyedInstanceIdentifier<Flow, FlowKey> flowIdent = tableIdent.child(Flow.class, toBeDeletedFlow.getKey());
                this.provider.getFlowCommiter().remove(flowIdent, toBeDeletedFlow, nodeIdent);
                staleFlowsToBeBulkDeleted.add(getStaleFlowInstanceIdentifier(staleFlow, nodeIdent));
            }
        }
        LOG.debug("Proceeding with deletion of stale-marked Groups for switch {} using Openflow interface", nodeIdent.toString());
        // TODO: Should we collate the futures of RPC-calls to be sure that groups are
        // Flows are fully deleted
        // before attempting to delete groups - just in case there are references
        /* Stale-marked Groups - Can be deleted after flows */
        List<StaleGroup> staleGroups = flowNode.get().getStaleGroup() != null ? flowNode.get().getStaleGroup() : Collections.<StaleGroup>emptyList();
        for (StaleGroup staleGroup : staleGroups) {
            GroupBuilder groupBuilder = new GroupBuilder(staleGroup);
            Group toBeDeletedGroup = groupBuilder.setGroupId(staleGroup.getGroupId()).build();
            final KeyedInstanceIdentifier<Group, GroupKey> groupIdent = nodeIdent.child(Group.class, toBeDeletedGroup.getKey());
            this.provider.getGroupCommiter().remove(groupIdent, toBeDeletedGroup, nodeIdent);
            staleGroupsToBeBulkDeleted.add(getStaleGroupInstanceIdentifier(staleGroup, nodeIdent));
        }
        LOG.debug("Proceeding with deletion of stale-marked Meters for switch {} using Openflow interface", nodeIdent.toString());
        /* Stale-marked Meters - can be deleted anytime - so least priority */
        List<StaleMeter> staleMeters = flowNode.get().getStaleMeter() != null ? flowNode.get().getStaleMeter() : Collections.<StaleMeter>emptyList();
        for (StaleMeter staleMeter : staleMeters) {
            MeterBuilder meterBuilder = new MeterBuilder(staleMeter);
            Meter toBeDeletedMeter = meterBuilder.setMeterId(staleMeter.getMeterId()).build();
            final KeyedInstanceIdentifier<Meter, MeterKey> meterIdent = nodeIdent.child(Meter.class, toBeDeletedMeter.getKey());
            this.provider.getMeterCommiter().remove(meterIdent, toBeDeletedMeter, nodeIdent);
            staleMetersToBeBulkDeleted.add(getStaleMeterInstanceIdentifier(staleMeter, nodeIdent));
        }
    }
    /* clean transaction */
    trans.close();
    LOG.debug("Deleting all stale-marked flows/groups/meters of for switch {} in Configuration DS", nodeIdent.toString());
    // Now, do the bulk deletions
    deleteDSStaleFlows(staleFlowsToBeBulkDeleted);
    deleteDSStaleGroups(staleGroupsToBeBulkDeleted);
    deleteDSStaleMeters(staleMetersToBeBulkDeleted);
}

Example 28 with Meter

use of org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter in project openflowplugin by opendaylight.

the class MeterForwarder method remove.

@Override
public Future<RpcResult<RemoveMeterOutput>> remove(final InstanceIdentifier<Meter> identifier, final Meter removeDataObj, final InstanceIdentifier<FlowCapableNode> nodeIdent) {
    LOG.trace("Received the Meter REMOVE request [Tbl id, node Id {} {}", identifier, nodeIdent);
    final RemoveMeterInputBuilder builder = new RemoveMeterInputBuilder(removeDataObj);
    builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class)));
    builder.setMeterRef(new MeterRef(identifier));
    return salMeterService.removeMeter(builder.build());
}

Example 29 with Meter

use of org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter in project openflowplugin by opendaylight.

the class MeterForwarder method add.

@Override
public Future<RpcResult<AddMeterOutput>> add(final InstanceIdentifier<Meter> identifier, final Meter addDataObj, final InstanceIdentifier<FlowCapableNode> nodeIdent) {
    LOG.trace("Received the Meter ADD request [Tbl id, node Id {} {} {}", identifier, nodeIdent, addDataObj);
    final AddMeterInputBuilder builder = new AddMeterInputBuilder(addDataObj);
    builder.setNode(new NodeRef(nodeIdent.firstIdentifierOf(Node.class)));
    builder.setMeterRef(new MeterRef(identifier));
    return salMeterService.addMeter(builder.build());
}

Example 30 with Meter

use of org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter in project openflowplugin by opendaylight.

the class SyncPlanPushStrategyFlatBatchImpl method assembleAddOrUpdateMeters.

@VisibleForTesting
static int assembleAddOrUpdateMeters(final List<Batch> batchBag, int batchOrder, final ItemSyncBox<Meter> meterItemSyncBox) {
    // process meter add+update
    int order = batchOrder;
    if (meterItemSyncBox != null) {
        if (!meterItemSyncBox.getItemsToPush().isEmpty()) {
            final List<FlatBatchAddMeter> flatBatchAddMeterBag = new ArrayList<>(meterItemSyncBox.getItemsToUpdate().size());
            int itemOrder = 0;
            for (Meter meter : meterItemSyncBox.getItemsToPush()) {
                flatBatchAddMeterBag.add(new FlatBatchAddMeterBuilder(meter).setBatchOrder(itemOrder++).build());
            }
            final Batch batch = new BatchBuilder().setBatchChoice(new FlatBatchAddMeterCaseBuilder().setFlatBatchAddMeter(flatBatchAddMeterBag).build()).setBatchOrder(order).build();
            order += itemOrder;
            batchBag.add(batch);
        }
        if (!meterItemSyncBox.getItemsToUpdate().isEmpty()) {
            final List<FlatBatchUpdateMeter> flatBatchUpdateMeterBag = new ArrayList<>(meterItemSyncBox.getItemsToUpdate().size());
            int itemOrder = 0;
            for (ItemSyncBox.ItemUpdateTuple<Meter> meterUpdate : meterItemSyncBox.getItemsToUpdate()) {
                flatBatchUpdateMeterBag.add(new FlatBatchUpdateMeterBuilder().setBatchOrder(itemOrder++).setOriginalBatchedMeter(new OriginalBatchedMeterBuilder(meterUpdate.getOriginal()).build()).setUpdatedBatchedMeter(new UpdatedBatchedMeterBuilder(meterUpdate.getUpdated()).build()).build());
            }
            final Batch batch = new BatchBuilder().setBatchChoice(new FlatBatchUpdateMeterCaseBuilder().setFlatBatchUpdateMeter(flatBatchUpdateMeterBag).build()).setBatchOrder(order).build();
            order += itemOrder;
            batchBag.add(batch);
        }
    }
    return order;
}