transcriber/src/main/java/org/opendaylight/neutron/transcriber/NeutronMeteringLabelRuleInterface.java

   1 /*
   2  * Copyright IBM Corporation, 2015.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.neutron.transcriber;
  10
  11 import java.lang.reflect.Method;
  12 import java.util.ArrayList;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Map.Entry;
  16 import java.util.Set;
  17 import java.util.concurrent.ConcurrentHashMap;
  18 import java.util.concurrent.ConcurrentMap;
  19
  20 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  21 import org.opendaylight.neutron.spi.INeutronMeteringLabelRuleCRUD;
  22 import org.opendaylight.neutron.spi.NeutronMeteringLabelRule;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.metering.rev141002.MeteringRuleAttrs;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.metering.rev141002.metering.rules.attributes.MeteringRules;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.metering.rev141002.metering.rules.attributes.metering.rules.MeteringRule;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.metering.rev141002.metering.rules.attributes.metering.rules.MeteringRuleBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.Neutron;
  29 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 public class NeutronMeteringLabelRuleInterface extends AbstractNeutronInterface<MeteringRule, NeutronMeteringLabelRule>
  34         implements INeutronMeteringLabelRuleCRUD {
  35     private static final Logger logger = LoggerFactory.getLogger(NeutronMeteringLabelRuleInterface.class);
  36     private ConcurrentMap<String, NeutronMeteringLabelRule> meteringLabelRuleDB = new ConcurrentHashMap<String, NeutronMeteringLabelRule>();
  37
  38     NeutronMeteringLabelRuleInterface(ProviderContext providerContext) {
  39         super(providerContext);
  40     }
  41
  42     // this method uses reflection to update an object from it's delta.
  43
  44     private boolean overwrite(Object target, Object delta) {
  45         Method[] methods = target.getClass().getMethods();
  46
  47         for (Method toMethod : methods) {
  48             if (toMethod.getDeclaringClass().equals(target.getClass()) && toMethod.getName().startsWith("set")) {
  49
  50                 String toName = toMethod.getName();
  51                 String fromName = toName.replace("set", "get");
  52
  53                 try {
  54                     Method fromMethod = delta.getClass().getMethod(fromName);
  55                     Object value = fromMethod.invoke(delta, (Object[]) null);
  56                     if (value != null) {
  57                         toMethod.invoke(target, value);
  58                     }
  59                 } catch (Exception e) {
  60                     e.printStackTrace();
  61                     return false;
  62                 }
  63             }
  64         }
  65         return true;
  66     }
  67
  68     // IfNBMeteringLabelRuleCRUD methods
  69
  70     @Override
  71     public boolean neutronMeteringLabelRuleExists(String uuid) {
  72         return meteringLabelRuleDB.containsKey(uuid);
  73     }
  74
  75     @Override
  76     public NeutronMeteringLabelRule getNeutronMeteringLabelRule(String uuid) {
  77         if (!neutronMeteringLabelRuleExists(uuid)) {
  78             return null;
  79         }
  80         return meteringLabelRuleDB.get(uuid);
  81     }
  82
  83     @Override
  84     public List<NeutronMeteringLabelRule> getAllNeutronMeteringLabelRules() {
  85         Set<NeutronMeteringLabelRule> allMeteringLabelRules = new HashSet<NeutronMeteringLabelRule>();
  86         for (Entry<String, NeutronMeteringLabelRule> entry : meteringLabelRuleDB.entrySet()) {
  87             NeutronMeteringLabelRule meteringLabelRule = entry.getValue();
  88             allMeteringLabelRules.add(meteringLabelRule);
  89         }
  90         logger.debug("Exiting getAllMeteringLabelRules, Found {} OpenStackMeteringLabelRules",
  91                 allMeteringLabelRules.size());
  92         List<NeutronMeteringLabelRule> ans = new ArrayList<NeutronMeteringLabelRule>();
  93         ans.addAll(allMeteringLabelRules);
  94         return ans;
  95     }
  96
  97     @Override
  98     public boolean addNeutronMeteringLabelRule(NeutronMeteringLabelRule input) {
  99         if (neutronMeteringLabelRuleExists(input.getMeteringLabelRuleUUID())) {
 100             return false;
 101         }
 102         meteringLabelRuleDB.putIfAbsent(input.getMeteringLabelRuleUUID(), input);
 103         // TODO: add code to find INeutronMeteringLabelRuleAware services and
 104         // call newtorkCreated on them
 105         return true;
 106     }
 107
 108     @Override
 109     public boolean removeNeutronMeteringLabelRule(String uuid) {
 110         if (!neutronMeteringLabelRuleExists(uuid)) {
 111             return false;
 112         }
 113         meteringLabelRuleDB.remove(uuid);
 114         // TODO: add code to find INeutronMeteringLabelRuleAware services and
 115         // call newtorkDeleted on them
 116         return true;
 117     }
 118
 119     @Override
 120     public boolean updateNeutronMeteringLabelRule(String uuid, NeutronMeteringLabelRule delta) {
 121         if (!neutronMeteringLabelRuleExists(uuid)) {
 122             return false;
 123         }
 124         NeutronMeteringLabelRule target = meteringLabelRuleDB.get(uuid);
 125         return overwrite(target, delta);
 126     }
 127
 128     @Override
 129     public boolean neutronMeteringLabelRuleInUse(String netUUID) {
 130         if (!neutronMeteringLabelRuleExists(netUUID)) {
 131             return true;
 132         }
 133         return false;
 134     }
 135
 136     @Override
 137     protected InstanceIdentifier<MeteringRule> createInstanceIdentifier(MeteringRule item) {
 138         return InstanceIdentifier.create(Neutron.class).child(MeteringRules.class).child(MeteringRule.class);
 139
 140     }
 141
 142     @Override
 143     protected MeteringRule toMd(NeutronMeteringLabelRule meteringLableRule) {
 144         MeteringRuleBuilder meteringRuleBuilder = new MeteringRuleBuilder();
 145         if (meteringLableRule.getMeteringLabelRuleLabelID() != null) {
 146             meteringRuleBuilder.setId((toUuid(meteringLableRule.getMeteringLabelRuleLabelID())));
 147         }
 148         if (meteringLableRule.getMeteringLabelRuleUUID() != null) {
 149             meteringRuleBuilder.setMeteringLabelId(toUuid(meteringLableRule.getMeteringLabelRuleUUID()));
 150         }
 151         if (meteringLableRule.getMeteringLabelRuleDirection() != null) {
 152             meteringRuleBuilder.setDirection((MeteringRuleAttrs.Direction.valueOf(meteringLableRule
 153                     .getMeteringLabelRuleDirection())));
 154         }
 155         if (meteringLableRule.getMeteringLabelRuleRemoteIPPrefix() != null) {
 156             IpAddress ipAddress = new IpAddress(meteringLableRule.getMeteringLabelRuleRemoteIPPrefix().toCharArray());
 157             meteringRuleBuilder.setRemoteIpPrefix(ipAddress);
 158         }
 159         meteringRuleBuilder.setExcluded(meteringLableRule.getMeteringLabelRuleExcluded());
 160         return meteringRuleBuilder.build();
 161     }
 162
 163     @Override
 164     protected MeteringRule toMd(String uuid) {
 165         MeteringRuleBuilder meteringRuleBuilder = new MeteringRuleBuilder();
 166         meteringRuleBuilder.setId((toUuid(uuid)));
 167         return meteringRuleBuilder.build();
 168     }
 169 }