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

   1 /*
   2  * Copyright (c) 2016 Brocade Communications Systems, Inc. and others.  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 package org.opendaylight.neutron.transcriber;
   9
  10 import com.google.common.collect.ImmutableBiMap;
  11 import java.util.ArrayList;
  12 import java.util.HashMap;
  13 import java.util.List;
  14
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.neutron.northbound.api.BadRequestException;
  17 import org.opendaylight.neutron.spi.INeutronSFCFlowClassifierCRUD;
  18 import org.opendaylight.neutron.spi.NeutronSFCFlowClassifier;
  19 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  20 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.EthertypeBase;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.EthertypeV4;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.EthertypeV6;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolBase;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolIcmp;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTcp;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolUdp;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.flow.classifier.match.attributes.L7Parameter;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.flow.classifier.match.attributes.L7ParameterBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.flow.classifier.match.attributes.L7ParameterKey;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.SfcFlowClassifiers;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.sfc.flow.classifiers.SfcFlowClassifier;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.sfc.flow.classifier.rev160511.sfc.flow.classifiers.attributes.sfc.flow.classifiers.SfcFlowClassifierBuilder;
  35 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 /**
  40  * Created by Anil Vishnoi (avishnoi@Brocade.com) on 6/24/16.
  41  */
  42 public class NeutronSFCFlowClassifierInterface
  43         extends AbstractNeutronInterface<SfcFlowClassifier, SfcFlowClassifiers, NeutronSFCFlowClassifier>
  44         implements INeutronSFCFlowClassifierCRUD {
  45
  46     private static final Logger LOGGER = LoggerFactory.getLogger(NeutronSFCFlowClassifierInterface.class);
  47
  48     private static final ImmutableBiMap<Class<? extends EthertypeBase>,String> ETHERTYPE_MAP
  49             = new ImmutableBiMap.Builder<Class<? extends EthertypeBase>,String>()
  50             .put(EthertypeV4.class,"IPv4")
  51             .put(EthertypeV6.class,"IPv6")
  52             .build();
  53
  54     private static final ImmutableBiMap<Class<? extends ProtocolBase>,
  55             String> PROTOCOL_MAP = new ImmutableBiMap.Builder<Class<? extends ProtocolBase>, String>()
  56                     .put(ProtocolTcp.class, "tcp").put(ProtocolUdp.class, "udp").put(ProtocolIcmp.class, "icmp")
  57                     .build();
  58
  59     NeutronSFCFlowClassifierInterface(DataBroker db) {
  60         super(db);
  61     }
  62
  63     @Override
  64     protected List<SfcFlowClassifier> getDataObjectList(SfcFlowClassifiers dataObjects) {
  65         return dataObjects.getSfcFlowClassifier();
  66     }
  67
  68     @Override
  69     protected InstanceIdentifier<SfcFlowClassifier> createInstanceIdentifier(SfcFlowClassifier classifier) {
  70         return InstanceIdentifier.create(Neutron.class).child(SfcFlowClassifiers.class)
  71                 .child(SfcFlowClassifier.class, classifier.getKey());
  72     }
  73
  74     @Override
  75     protected InstanceIdentifier<SfcFlowClassifiers> createInstanceIdentifier() {
  76         return InstanceIdentifier.create(Neutron.class).child(SfcFlowClassifiers.class);
  77     }
  78
  79     @Override
  80     protected SfcFlowClassifier toMd(NeutronSFCFlowClassifier neutronClassifier) {
  81
  82         LOGGER.trace("toMd: REST SFC Flow Classifier data : {}", neutronClassifier);
  83
  84         SfcFlowClassifierBuilder result = new SfcFlowClassifierBuilder();
  85         if(neutronClassifier.getID() != null) {
  86             result.setUuid(new Uuid(neutronClassifier.getID()));
  87         }
  88         if(neutronClassifier.getName() != null) {
  89             result.setName(neutronClassifier.getName());
  90         }
  91         if(neutronClassifier.getTenantID() != null) {
  92             result.setTenantId(toUuid(neutronClassifier.getTenantID()));
  93         }
  94         if(neutronClassifier.getEthertype() != null) {
  95             final ImmutableBiMap<String, Class<? extends EthertypeBase>> mapper =
  96                     ETHERTYPE_MAP.inverse();
  97
  98             result.setEthertype(mapper.get(neutronClassifier.getEthertype()));
  99         }
 100         if (neutronClassifier.getProtocol() != null) {
 101             final ImmutableBiMap<String, Class<? extends ProtocolBase>> mapper = PROTOCOL_MAP.inverse();
 102             Class<? extends ProtocolBase> protocol = mapper.get(neutronClassifier.getProtocol());
 103             if (protocol != null) {
 104                 result.setProtocol(protocol);
 105             } else {
 106                 throw new BadRequestException("Protocol {" + neutronClassifier.getProtocol() + "} is not supported");
 107             }
 108         }
 109         if(neutronClassifier.getSourcePortRangeMin() != null) {
 110             result.setSourcePortRangeMin(neutronClassifier.getSourcePortRangeMin());
 111         }
 112         if(neutronClassifier.getSourcePortRangeMax() != null) {
 113             result.setSourcePortRangeMax(neutronClassifier.getSourcePortRangeMax());
 114         }
 115         if(neutronClassifier.getDestinationPortRangeMin() != null) {
 116             result.setDestinationPortRangeMin(neutronClassifier.getDestinationPortRangeMin());
 117         }
 118         if(neutronClassifier.getDestinationPortRangeMax() != null) {
 119             result.setDestinationPortRangeMax(neutronClassifier.getDestinationPortRangeMax());
 120         }
 121         if(neutronClassifier.getSourceIpPrefix() != null) {
 122             result.setSourceIpPrefix(new IpPrefix(neutronClassifier.getSourceIpPrefix().toCharArray()));
 123         }
 124         if(neutronClassifier.getDestinationIpPrefix() != null) {
 125             result.setDestinationIpPrefix(new IpPrefix(neutronClassifier.getDestinationIpPrefix().toCharArray()));
 126         }
 127         if(neutronClassifier.getLogicalSourcePortUUID() !=null ) {
 128             result.setLogicalSourcePort(new Uuid(neutronClassifier.getLogicalSourcePortUUID()));
 129         }
 130         if(neutronClassifier.getLogicalDestinationPortUUID() != null) {
 131             result.setLogicalDestinationPort(new Uuid(neutronClassifier.getLogicalDestinationPortUUID()));
 132         }
 133         if(neutronClassifier.getL7Parameters()!= null) {
 134             List<L7Parameter> l7Params = new ArrayList<>();
 135             for(String paramKey : neutronClassifier.getL7Parameters().keySet()) {
 136                 L7ParameterBuilder param = new L7ParameterBuilder();
 137                 param.setKey(new L7ParameterKey(paramKey));
 138                 param.setMatchParameter(paramKey);
 139                 param.setMatchParameterValue(neutronClassifier.getL7Parameters().get(paramKey));
 140                 l7Params.add(param.build());
 141             }
 142             result.setL7Parameter(l7Params);
 143         }
 144         LOGGER.trace("toMd: Yang SFC Flow Classifier data : {}", result);
 145         return result.build();
 146     }
 147
 148     @Override
 149     protected SfcFlowClassifier toMd(String uuid) {
 150         final SfcFlowClassifierBuilder sfcFlowClassifierBuilder = new SfcFlowClassifierBuilder();
 151         sfcFlowClassifierBuilder.setUuid(toUuid(uuid));
 152         return sfcFlowClassifierBuilder.build();
 153     }
 154
 155     @Override
 156     protected NeutronSFCFlowClassifier fromMd(SfcFlowClassifier mdClassifier) {
 157         LOGGER.trace("fromMd: Yang SFC flow classifier data : {}", mdClassifier);
 158         NeutronSFCFlowClassifier result = new NeutronSFCFlowClassifier();
 159         result.setID(mdClassifier.getUuid().getValue());
 160         result.setName(mdClassifier.getName());
 161         result.setTenantID(mdClassifier.getTenantId());
 162         if(mdClassifier.getEthertype() != null) {
 163             result.setEthertype(ETHERTYPE_MAP.get(mdClassifier.getEthertype()));
 164         }
 165         if(mdClassifier.getProtocol() != null) {
 166             result.setProtocol(PROTOCOL_MAP.get(mdClassifier.getProtocol()));
 167         }
 168         if(mdClassifier.getSourcePortRangeMin() != null) {
 169             result.setSourcePortRangeMin(mdClassifier.getSourcePortRangeMin());
 170         }
 171         if(mdClassifier.getSourcePortRangeMax() != null) {
 172             result.setSourcePortRangeMax(mdClassifier.getSourcePortRangeMax());
 173         }
 174         if(mdClassifier.getDestinationPortRangeMin() != null) {
 175             result.setDestinationPortRangeMin(mdClassifier.getDestinationPortRangeMin());
 176         }
 177         if(mdClassifier.getDestinationPortRangeMax() != null) {
 178             result.setDestinationPortRangeMax(mdClassifier.getDestinationPortRangeMax());
 179         }
 180         if(mdClassifier.getSourceIpPrefix() != null) {
 181             result.setSourceIpPrefix(String.valueOf(mdClassifier.getSourceIpPrefix().getValue()));
 182         }
 183         if(mdClassifier.getDestinationIpPrefix() != null) {
 184             result.setDestinationIpPrefix(String.valueOf(mdClassifier.getDestinationIpPrefix().getValue()));
 185         }
 186         if(mdClassifier.getLogicalSourcePort() !=null ) {
 187             result.setLogicalSourcePortUUID(mdClassifier.getLogicalSourcePort().getValue());
 188         }
 189         if(mdClassifier.getLogicalDestinationPort() != null) {
 190             result.setLogicalDestinationPortUUID(mdClassifier.getLogicalDestinationPort().getValue());
 191         }
 192         if(mdClassifier.getL7Parameter()!= null) {
 193             HashMap<String, String> l7Param = new HashMap<>();
 194             for(L7Parameter param : mdClassifier.getL7Parameter()) {
 195                 l7Param.put(param.getMatchParameter(),param.getMatchParameterValue());
 196             }
 197             result.setL7Parameters(l7Param);
 198         }
 199         LOGGER.trace("fromMd: REST SFC Flow Classifier data : {}", result);
 200         return result;
 201     }
 202 }