sxp-integration/sxp-ep-provider/src/main/java/org/opendaylight/groupbasedpolicy/sxp/ep/provider/impl/dao/EPPolicyTemplateDaoFacadeImpl.java

   1 /*
   2  * Copyright (c) 2016 Cisco 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
   9 package org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.dao;
  10
  11 import com.google.common.base.Function;
  12 import com.google.common.base.Optional;
  13 import com.google.common.util.concurrent.AsyncFunction;
  14 import com.google.common.util.concurrent.Futures;
  15 import com.google.common.util.concurrent.ListenableFuture;
  16 import java.util.Collection;
  17 import java.util.Collections;
  18 import javax.annotation.Nonnull;
  19 import javax.annotation.Nullable;
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateDaoFacade;
  24 import org.opendaylight.groupbasedpolicy.sxp.ep.provider.api.EPPolicyTemplateProvider;
  25 import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SgtGeneratorImpl;
  26 import org.opendaylight.groupbasedpolicy.sxp.ep.provider.impl.SimpleCachedDao;
  27 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.SxpEpMapper;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.TemplateGenerated;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgt;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgtBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.config.groupbasedpolicy.sxp.integration.sxp.ep.provider.model.rev160302.sxp.ep.mapper.EndpointPolicyTemplateBySgtKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.sxp.database.rev160308.Sgt;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 /**
  44  * Purpose: add template provider fallback to {@link EPPolicyTemplateDaoImpl}
  45  */
  46 public class EPPolicyTemplateDaoFacadeImpl implements EPPolicyTemplateDaoFacade {
  47
  48     private static final Logger LOG = LoggerFactory.getLogger(EPPolicyTemplateDaoFacadeImpl.class);
  49
  50     private final EPPolicyTemplateDaoImpl epPolicyTemplateDao;
  51     private final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao;
  52     private final SgtGeneratorImpl sgtGenerator;
  53     private final DataBroker dataBroker;
  54
  55     private EPPolicyTemplateProvider templateProvider;
  56
  57     public EPPolicyTemplateDaoFacadeImpl(final DataBroker dataBroker, final EPPolicyTemplateDaoImpl epPolicyTemplateDao,
  58                                          final SimpleCachedDao<Sgt, EndpointPolicyTemplateBySgt> epPolicyTemplateCachedDao,
  59                                          final SgtGeneratorImpl sgtGenerator) {
  60         this.dataBroker = dataBroker;
  61         this.epPolicyTemplateDao = epPolicyTemplateDao;
  62         this.epPolicyTemplateCachedDao = epPolicyTemplateCachedDao;
  63         this.sgtGenerator = sgtGenerator;
  64     }
  65
  66     @Override
  67     public void setTemplateProvider(final EPPolicyTemplateProvider templateProvider) {
  68         this.templateProvider = templateProvider;
  69     }
  70
  71
  72     @Override
  73     public ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> read(@Nonnull final Sgt key) {
  74         // read from delegate
  75         final ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> templateFu = epPolicyTemplateDao.read(key);
  76
  77         // involve fallback if template is absent
  78         return Futures.transform(templateFu, new AsyncFunction<Optional<EndpointPolicyTemplateBySgt>, Optional<EndpointPolicyTemplateBySgt>>() {
  79             @Override
  80             public ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> apply(
  81                     @Nonnull final Optional<EndpointPolicyTemplateBySgt> templateOpt) throws Exception {
  82
  83                 return templateOpt.transform(template -> Futures.immediateFuture(templateOpt))
  84                         // failed to read template -> invoke fallback if available
  85                         .or(() -> java.util.Optional.ofNullable(templateProvider)
  86                                 .flatMap(provider -> templateProvider.provideTemplate(key))
  87                                 .map(template -> storeTemplateAndEpg(template))
  88                                 .orElse(Futures.immediateFuture(Optional.absent()))
  89                         );
  90             }
  91         });
  92     }
  93
  94     private ListenableFuture<Optional<EndpointPolicyTemplateBySgt>> storeTemplateAndEpg(final EndpointPolicyTemplateBySgt template) {
  95         // store EPG (presume that it does not exist)
  96         final Sgt sgtValue = template.getSgt();
  97         LOG.trace("storing EPGs for generated epPolicyTemplate: {} [{}]",
  98                 sgtValue.getValue(), template.getEndpointGroups().size());
  99         final WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
 100
 101         boolean createParent = true;
 102         for (EndpointGroupId epgId : template.getEndpointGroups()) {
 103             final InstanceIdentifier<EndpointGroup> epgPath = IidFactory.endpointGroupIid(template.getTenant(), epgId);
 104             final EndpointGroup epg = new EndpointGroupBuilder()
 105                     .setId(epgId)
 106                     .setDescription(new Description("imported from ISE for sgt=" + sgtValue.getValue()))
 107                     .setName(new Name(String.format("%s_ISE_SGT_%d", epgId.getValue(), sgtValue.getValue())))
 108                     .build();
 109             wTx.put(LogicalDatastoreType.CONFIGURATION, epgPath, epg, createParent);
 110             createParent = false;
 111         }
 112
 113         // store ep-policy-template
 114         LOG.trace("storing generated epPolicyTemplate: {}", sgtValue.getValue());
 115         final InstanceIdentifier<EndpointPolicyTemplateBySgt> epPolicyTemplatePath = InstanceIdentifier
 116                 .create(SxpEpMapper.class)
 117                 .child(EndpointPolicyTemplateBySgt.class, new EndpointPolicyTemplateBySgtKey(sgtValue));
 118         wTx.put(LogicalDatastoreType.CONFIGURATION, epPolicyTemplatePath, template, true);
 119
 120         return Futures.transform(wTx.submit(), createStoreOutcomeHandlerToOptional(template));
 121     }
 122
 123     private Function<Void, Optional<EndpointPolicyTemplateBySgt>> createStoreOutcomeHandlerToOptional(final EndpointPolicyTemplateBySgt template) {
 124         return new Function<Void, Optional<EndpointPolicyTemplateBySgt>>() {
 125             @Nullable
 126             @Override
 127             public Optional<EndpointPolicyTemplateBySgt> apply(@Nullable final Void aVoid) {
 128                 return Optional.of(template);
 129             }
 130         };
 131     }
 132
 133     private Function<Void, Collection<EndpointPolicyTemplateBySgt>> createStoreOutcomeHandlerToCollection(final EndpointPolicyTemplateBySgt template) {
 134         return new Function<Void, Collection<EndpointPolicyTemplateBySgt>>() {
 135             @Nullable
 136             @Override
 137             public Collection<EndpointPolicyTemplateBySgt> apply(@Nullable final Void aVoid) {
 138                 return Collections.singletonList(template);
 139             }
 140         };
 141     }
 142
 143     @Override
 144     public ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> readBy(@Nonnull final EpPolicyTemplateValueKey templateLookupKey) {
 145         //TODO: expose to ios-xe renderer,
 146         final Collection<EndpointPolicyTemplateBySgt> templatesFromDao = epPolicyTemplateDao.readBy(templateLookupKey);
 147         final ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> result;
 148         if (!templatesFromDao.isEmpty()) {
 149             result = Futures.immediateFuture(templatesFromDao);
 150         } else {
 151             // generate
 152             result = sgtGenerator.generateNextSgt(epPolicyTemplateCachedDao)
 153                     // build ep-policy-template
 154                     .map(sgt -> buildEpPolicyTemplate(templateLookupKey, sgt))
 155                     // store the template
 156                     .map(this::storeTemplate)
 157                     .orElse(Futures.immediateFuture(Collections.emptyList()));
 158         }
 159         return result;
 160     }
 161
 162     private ListenableFuture<Collection<EndpointPolicyTemplateBySgt>> storeTemplate(final EndpointPolicyTemplateBySgt template) {
 163         final WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
 164         // store ep-policy-template
 165         final Sgt sgt = template.getSgt();
 166         LOG.trace("storing generated epPolicyTemplate: {}", sgt.getValue());
 167         final InstanceIdentifier<EndpointPolicyTemplateBySgt> epPolicyTemplatePath = InstanceIdentifier
 168                 .create(SxpEpMapper.class)
 169                 .child(EndpointPolicyTemplateBySgt.class, new EndpointPolicyTemplateBySgtKey(sgt));
 170         wTx.put(LogicalDatastoreType.CONFIGURATION, epPolicyTemplatePath, template, true);
 171
 172         return Futures.transform(wTx.submit(), createStoreOutcomeHandlerToCollection(template));
 173     }
 174
 175     private EndpointPolicyTemplateBySgt buildEpPolicyTemplate(final EpPolicyTemplateValueKey templateLookupKey, final Sgt sgt) {
 176         return new EndpointPolicyTemplateBySgtBuilder()
 177                 .setOrigin(TemplateGenerated.class)
 178                 .setTenant(templateLookupKey.getTenantId())
 179                 .setSgt(sgt)
 180                 .setEndpointGroups(templateLookupKey.getEpgId())
 181                 .setConditions(templateLookupKey.getConditionName())
 182                 .build();
 183     }
 184 }