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

   1 /*
   2  * Copyright (C) 2014 Red Hat, Inc.
   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
  10 package org.opendaylight.neutron.transcriber;
  11
  12 import java.lang.reflect.Method;
  13 import java.util.ArrayList;
  14 import java.util.HashSet;
  15 import java.util.List;
  16 import java.util.Map.Entry;
  17 import java.util.Set;
  18 import java.util.concurrent.ConcurrentHashMap;
  19 import java.util.concurrent.ConcurrentMap;
  20
  21 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
  22 import org.opendaylight.neutron.spi.INeutronSecurityGroupCRUD;
  23 import org.opendaylight.neutron.spi.NeutronSecurityGroup;
  24 import org.opendaylight.neutron.spi.NeutronSecurityRule;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150325.Neutron;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev141002.security.groups.attributes.SecurityGroups;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev141002.security.groups.attributes.security.groups.SecurityGroup;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev141002.security.groups.attributes.security.groups.SecurityGroupBuilder;
  30 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34
  35 public class NeutronSecurityGroupInterface extends AbstractNeutronInterface<SecurityGroup,NeutronSecurityGroup> implements INeutronSecurityGroupCRUD {
  36     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronSecurityGroupInterface.class);
  37     private ConcurrentMap<String, NeutronSecurityGroup> securityGroupDB  = new ConcurrentHashMap<String, NeutronSecurityGroup>();
  38
  39
  40     NeutronSecurityGroupInterface(ProviderContext providerContext) {
  41         super(providerContext);
  42     }
  43
  44     // this method uses reflection to update an object from it's delta.
  45
  46     private boolean overwrite(Object target, Object delta) {
  47         Method[] methods = target.getClass().getMethods();
  48
  49         for(Method toMethod: methods){
  50             if(toMethod.getDeclaringClass().equals(target.getClass())
  51                 && toMethod.getName().startsWith("set")){
  52
  53                 String toName = toMethod.getName();
  54                 String fromName = toName.replace("set", "get");
  55
  56                 try {
  57                     Method fromMethod = delta.getClass().getMethod(fromName);
  58                     Object value = fromMethod.invoke(delta, (Object[])null);
  59                     if(value != null){
  60                         toMethod.invoke(target, value);
  61                     }
  62                 } catch (Exception e) {
  63                     LOGGER.error(e.getMessage());
  64                     return false;
  65                 }
  66             }
  67         }
  68         return true;
  69     }
  70
  71     @Override
  72     public boolean neutronSecurityGroupExists(String uuid) {
  73         return securityGroupDB.containsKey(uuid);
  74     }
  75
  76     @Override
  77     public NeutronSecurityGroup getNeutronSecurityGroup(String uuid) {
  78         if (!neutronSecurityGroupExists(uuid)) {
  79             LOGGER.debug("No Security Groups Have Been Defined");
  80             return null;
  81         }
  82         return securityGroupDB.get(uuid);
  83     }
  84
  85     @Override
  86     public List<NeutronSecurityGroup> getAllNeutronSecurityGroups() {
  87         Set<NeutronSecurityGroup> allSecurityGroups = new HashSet<NeutronSecurityGroup>();
  88         for (Entry<String, NeutronSecurityGroup> entry : securityGroupDB.entrySet()) {
  89             NeutronSecurityGroup securityGroup = entry.getValue();
  90             allSecurityGroups.add(securityGroup);
  91         }
  92         LOGGER.debug("Exiting getSecurityGroups, Found {} OpenStackSecurityGroup", allSecurityGroups.size());
  93         List<NeutronSecurityGroup> ans = new ArrayList<NeutronSecurityGroup>();
  94         ans.addAll(allSecurityGroups);
  95         return ans;
  96     }
  97
  98     @Override
  99     public boolean addNeutronSecurityGroup(NeutronSecurityGroup input) {
 100         if (neutronSecurityGroupExists(input.getSecurityGroupUUID())) {
 101             return false;
 102         }
 103         securityGroupDB.putIfAbsent(input.getSecurityGroupUUID(), input);
 104         addMd(input);
 105         return true;
 106     }
 107
 108     @Override
 109     public boolean removeNeutronSecurityGroup(String uuid) {
 110         if (!neutronSecurityGroupExists(uuid)) {
 111             return false;
 112         }
 113         securityGroupDB.remove(uuid);
 114         removeMd(toMd(uuid));
 115         return true;
 116     }
 117
 118     @Override
 119     public boolean updateNeutronSecurityGroup(String uuid, NeutronSecurityGroup delta) {
 120         if (!neutronSecurityGroupExists(uuid)) {
 121             return false;
 122         }
 123         NeutronSecurityGroup target = securityGroupDB.get(uuid);
 124         boolean rc = overwrite(target, delta);
 125         if (rc) {
 126             updateMd(securityGroupDB.get(uuid));
 127         }
 128         return rc;
 129     }
 130
 131     @Override
 132     public boolean neutronSecurityGroupInUse(String securityGroupUUID) {
 133         return !neutronSecurityGroupExists(securityGroupUUID);
 134     }
 135
 136     @Override
 137     protected SecurityGroup toMd(NeutronSecurityGroup securityGroup) {
 138         SecurityGroupBuilder securityGroupBuilder = new SecurityGroupBuilder();
 139         if (securityGroup.getSecurityGroupName() != null) {
 140             securityGroupBuilder.setName(securityGroup.getSecurityGroupName());
 141         }
 142         if (securityGroup.getSecurityGroupDescription() != null) {
 143             securityGroupBuilder.setDescription(securityGroup.getSecurityGroupDescription());
 144         }
 145         if (securityGroup.getSecurityGroupTenantID() != null) {
 146             securityGroupBuilder.setTenantId(toUuid(securityGroup.getSecurityGroupTenantID()));
 147         }
 148         if (securityGroup.getSecurityRules() != null) {
 149             List<Uuid> neutronSecurityRule = new ArrayList<>();
 150             for (NeutronSecurityRule securityRule : securityGroup.getSecurityRules()) {
 151                 if (securityRule.getSecurityRuleUUID() != null) {
 152                     neutronSecurityRule.add(toUuid(securityRule.getSecurityRuleUUID()));
 153                 }
 154             }
 155             securityGroupBuilder.setSecurityRules(neutronSecurityRule);
 156         }
 157         if (securityGroup.getSecurityGroupUUID() != null) {
 158             securityGroupBuilder.setUuid(toUuid(securityGroup.getSecurityGroupUUID()));
 159         } else {
 160             LOGGER.warn("Attempting to write neutron securityGroup without UUID");
 161         }
 162
 163         return securityGroupBuilder.build();
 164     }
 165
 166     @Override
 167     protected InstanceIdentifier<SecurityGroup> createInstanceIdentifier(SecurityGroup securityGroup) {
 168         return InstanceIdentifier.create(Neutron.class).child(SecurityGroups.class).child(SecurityGroup.class);
 169     }
 170
 171     @Override
 172     protected SecurityGroup toMd(String uuid) {
 173         SecurityGroupBuilder securityGroupBuilder = new SecurityGroupBuilder();
 174         securityGroupBuilder.setUuid(toUuid(uuid));
 175         return securityGroupBuilder.build();
 176     }
 177 }