git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2022 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.unifi.internal.api.cache;
  14
  15 import java.util.Collection;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Objects;
  20 import java.util.concurrent.ConcurrentHashMap;
  21 import java.util.function.Function;
  22 import java.util.stream.Stream;
  23
  24 import org.eclipse.jdt.annotation.NonNullByDefault;
  25 import org.eclipse.jdt.annotation.Nullable;
  26 import org.openhab.binding.unifi.internal.api.dto.UnfiPortOverrideJsonElement;
  27 import org.openhab.binding.unifi.internal.api.dto.UniFiClient;
  28 import org.openhab.binding.unifi.internal.api.dto.UniFiDevice;
  29 import org.openhab.binding.unifi.internal.api.dto.UniFiPortTuple;
  30 import org.openhab.binding.unifi.internal.api.dto.UniFiSite;
  31 import org.openhab.binding.unifi.internal.api.dto.UniFiWlan;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 /**
  36  * Class to manager cache for the controller keeping track of all specific cache objects.
  37  *
  38  * @author Matthew Bowman - Initial contribution
  39  * @author Hilbrand Bouwkamp - Moved cache to this dedicated class.
  40  */
  41 @NonNullByDefault
  42 public class UniFiControllerCache {
  43
  44     private final Logger logger = LoggerFactory.getLogger(UniFiControllerCache.class);
  45
  46     private final UniFiSiteCache sitesCache = new UniFiSiteCache();
  47     private final UniFiWlanCache wlansCache = new UniFiWlanCache();
  48     private final UniFiDeviceCache devicesCache = new UniFiDeviceCache();
  49     private final UniFiClientCache clientsCache = new UniFiClientCache();
  50     private final UniFiClientCache insightsCache = new UniFiClientCache();
  51     private final Map<String, Map<Integer, UniFiPortTuple>> devicesToPortTables = new ConcurrentHashMap<>();
  52
  53     public void clear() {
  54         sitesCache.clear();
  55         wlansCache.clear();
  56         devicesCache.clear();
  57         clientsCache.clear();
  58         insightsCache.clear();
  59     }
  60
  61     // Sites Cache
  62
  63     public List<UniFiSite> setSites(final UniFiSite @Nullable [] sites) {
  64         sitesCache.putAll(sites);
  65         return List.of(sites);
  66     }
  67
  68     public @Nullable UniFiSite getSite(final @Nullable String id) {
  69         return sitesCache.get(id);
  70     }
  71
  72     public Collection<UniFiSite> getSites() {
  73         return sitesCache.values();
  74     }
  75
  76     // Wlans Cache
  77
  78     public void putWlans(final UniFiWlan @Nullable [] wlans) {
  79         wlansCache.putAll(wlans);
  80     }
  81
  82     public @Nullable UniFiWlan getWlan(@Nullable final String id) {
  83         return wlansCache.get(id);
  84     }
  85
  86     public Collection<UniFiWlan> getWlans() {
  87         return wlansCache.values();
  88     }
  89
  90     // Devices Cache
  91
  92     public void putDevices(final UniFiDevice @Nullable [] devices) {
  93         devicesCache.putAll(devices);
  94         if (devices != null) {
  95             Stream.of(devices).filter(Objects::nonNull).forEach(d -> {
  96                 Stream.ofNullable(d.getPortTable()).filter(ptl -> ptl.length > 0 && ptl[0].isPortPoe()).forEach(pt -> {
  97                     final Map<Integer, UniFiPortTuple> tupleTable = devicesToPortTables.computeIfAbsent(d.getMac(),
  98                             p -> new HashMap<>());
  99
 100                     Stream.of(pt).forEach(p -> {
 101                         final UniFiPortTuple tuple = tupleTable.computeIfAbsent(p.getPortIdx(),
 102                                 t -> new UniFiPortTuple());
 103
 104                         tuple.setDevice(d);
 105                         tuple.setTable(p);
 106                     });
 107                 });
 108                 Stream.ofNullable(d.getPortOverrides()).filter(ptl -> ptl.length > 0).forEach(po -> {
 109                     final Map<Integer, UniFiPortTuple> tupleTable = devicesToPortTables.get(d.getMac());
 110
 111                     if (tupleTable != null) {
 112                         Stream.of(po).filter(pof -> !pof.getAsJsonObject().entrySet().isEmpty())
 113                                 .map(UnfiPortOverrideJsonElement::new)
 114                                 .forEach(p -> tupleTable.get(p.getPortIdx()).setJsonElement(p));
 115                     }
 116                 });
 117             });
 118         }
 119     }
 120
 121     public @Nullable UniFiDevice getDevice(@Nullable final String id) {
 122         return devicesCache.get(id);
 123     }
 124
 125     public Map<Integer, UniFiPortTuple> getSwitchPorts(@Nullable final String deviceId) {
 126         return deviceId == null ? Map.of() : devicesToPortTables.getOrDefault(deviceId, Map.of());
 127     }
 128
 129     public Collection<Map<Integer, UniFiPortTuple>> getSwitchPorts() {
 130         return devicesToPortTables.values();
 131     }
 132
 133     // Clients Cache
 134
 135     public void putClients(final UniFiClient @Nullable [] clients) {
 136         clientsCache.putAll(clients);
 137     }
 138
 139     public Collection<UniFiClient> getClients() {
 140         return clientsCache.values();
 141     }
 142
 143     public long countClients(final UniFiSite site, final Function<UniFiClient, Boolean> filter) {
 144         return getClients().stream().filter(c -> site.isSite(c.getSite())).filter(filter::apply).count();
 145     }
 146
 147     public @Nullable UniFiClient getClient(@Nullable final String cid) {
 148         UniFiClient client = null;
 149         if (cid != null && !cid.isBlank()) {
 150             synchronized (this) {
 151                 // mgb: first check active clients and fallback to insights if not found
 152                 client = clientsCache.get(cid);
 153                 if (client == null) {
 154                     final String id = clientsCache.getId(cid);
 155
 156                     client = insightsCache.get(id == null ? cid : id);
 157                 }
 158             }
 159             if (client == null) {
 160                 logger.debug("Could not find a matching client for cid = {}", cid);
 161             }
 162         }
 163         return client;
 164     }
 165
 166     public synchronized Stream<UniFiClient> getClientStreamForSite(final UniFiSite site) {
 167         return clientsCache.values().stream().filter(client -> client.getSite().equals(site));
 168     }
 169
 170     // Insights Cache
 171
 172     public void putInsights(final UniFiClient @Nullable [] insights) {
 173         insightsCache.putAll(insights);
 174     }
 175 }