mdsalutil/mdsalutil-api/src/main/java/org/opendaylight/vpnservice/utils/clustering/EntityOwnerUtils.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. 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.vpnservice.utils.clustering;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.collect.Lists;
  12 import com.google.common.util.concurrent.Futures;
  13 import com.google.common.util.concurrent.ListenableFuture;
  14 import com.google.common.util.concurrent.SettableFuture;
  15 import org.opendaylight.controller.md.sal.common.api.clustering.*;
  16 import org.opendaylight.vpnservice.datastoreutils.DataStoreJobCoordinator;
  17 import org.opendaylight.vpnservice.utils.SystemPropertyReader;
  18 import org.opendaylight.vpnservice.utils.cache.CacheUtil;
  19 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22
  23 import java.util.ArrayList;
  24 import java.util.List;
  25 import java.util.concurrent.Callable;
  26 import java.util.concurrent.ConcurrentMap;
  27
  28 public class EntityOwnerUtils {
  29     public static final String ENTITY_OWNER_CACHE = "entity.owner.cache";
  30     private static final Logger LOG = LoggerFactory.getLogger(EntityOwnerUtils.class);
  31
  32     static {
  33         createEntityOwnerCache();
  34     }
  35     private static void createEntityOwnerCache() {
  36         if (CacheUtil.getCache(ENTITY_OWNER_CACHE) == null) {
  37             CacheUtil.createCache(ENTITY_OWNER_CACHE);
  38         }
  39     }
  40
  41     private static String getEntity(String entityType, String entityName) {
  42         return entityType;
  43     }
  44
  45     private static void updateEntityOwner(String entityType, String entityName, Boolean isOwner) {
  46         ConcurrentMap<String, Boolean> entityOwnerCache =
  47                 (ConcurrentMap<String, Boolean>) CacheUtil.getCache(ENTITY_OWNER_CACHE);
  48         String entity = getEntity(entityType, entityName);
  49         if (entityOwnerCache != null) {
  50             LOG.trace("updating entity owner "+isOwner+ " "+entity );
  51             entityOwnerCache.put(entity, isOwner);
  52         }
  53     }
  54
  55     public static boolean amIEntityOwner(String entityType, String entityName) {
  56         ConcurrentMap<String, Boolean> entityOwnerCache =
  57                 (ConcurrentMap<String, Boolean>) CacheUtil.getCache(ENTITY_OWNER_CACHE);
  58         String entity = getEntity(entityType, entityName);
  59         boolean ret = false;
  60         if (entityOwnerCache != null) {
  61             if (entityOwnerCache.get(entity) != null) {
  62                 ret = entityOwnerCache.get(entity);
  63             }
  64         } else {
  65             LOG.error("entity owner cache null");
  66         }
  67         LOG.trace("get entity owner result {} for type {}" ,ret ,entity);
  68         return ret;
  69     }
  70
  71     /**
  72      * Registers the entityName for ownership for given entityType
  73      * adds a local listener which takes care of updating the cached entity status
  74      * @param entityOwnershipService
  75      * @param entityType
  76      * @param entityName
  77      * @param listener also adds this listener for ownership events if provided
  78      * @throws CandidateAlreadyRegisteredException
  79      */
  80     public static void registerEntityCandidateForOwnerShip  (
  81             EntityOwnershipService entityOwnershipService,
  82             String entityType, String entityName, EntityOwnershipListener listener)
  83             throws CandidateAlreadyRegisteredException {
  84         LOG.info("registering for entity ownership for type "+entityType);
  85         Entity candidateEntity = new Entity(entityType, entityName);
  86         EntityOwnershipCandidateRegistration candidateRegistration = entityOwnershipService.registerCandidate(
  87                 candidateEntity);
  88         EntityOwnershipListenerRegistration listenerRegistration = entityOwnershipService.registerListener(entityType,
  89                 entityOwnershipListener);
  90         if (listener != null) {
  91             entityOwnershipService.registerListener(entityType, listener);
  92         }
  93         LOG.info("registered for entity ownership for type "+entityType);
  94         //TODO track registrations for closing
  95     }
  96
  97     private static Listener entityOwnershipListener = new Listener();
  98     static class Listener implements EntityOwnershipListener {
  99
 100         @Override
 101         public void ownershipChanged(EntityOwnershipChange ownershipChange) {
 102             String entityType = ownershipChange.getEntity().getType();
 103             String entityName = ownershipChange.getEntity().getId().toString();
 104             LOG.info("entity ownership changed for "+entityType);
 105             if (ownershipChange.hasOwner() && ownershipChange.isOwner()) {
 106                 LOG.info("entity ownership change became owner for type "+entityType);
 107                 updateEntityOwner(entityType, entityName, Boolean.TRUE);
 108             } else {
 109                 LOG.info("entity ownership lost ownership for type "+entityType);
 110                 updateEntityOwner(entityType, entityName, Boolean.FALSE);
 111             }
 112         }
 113     }
 114 }