src/uk/ac/ntu/n0521366/wsyd/libs/net/ServiceAddressMap.java

   1 /*
   2  * The MIT License
   3  *
   4  * Copyright 2015 TJ <hacker@iamtj>.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 package uk.ac.ntu.n0521366.wsyd.libs.net;
  25
  26 import java.net.InetSocketAddress;
  27 import java.text.MessageFormat;
  28 import java.util.ArrayList;
  29 import java.util.concurrent.ConcurrentHashMap;
  30 import java.util.logging.Level;
  31 import java.util.logging.Logger;
  32
  33 /**
  34  * Maps service names on hosts to  an InetAddress:Port pair.
  35  *
  36  * @author TJ <hacker@iamtj>
  37  */
  38 public class ServiceAddressMap {
  39     /**
  40      * Multi-thread safe map keyed on the service name.
  41      */
  42     protected ConcurrentHashMap<String, LastSeenHost> _serviceToAddressMap = new ConcurrentHashMap<>();
  43
  44     /**
  45      * Encapsulates a unique network host and the last time it was seen.
  46      */
  47     public static class LastSeenHost {
  48         /**
  49          * State of a record:
  50          *
  51          * STATIC = was manually entered and should not be removed
  52          * DYNAMIC = was discovered via multicast announcement or new connection and can be removed
  53          */
  54         public static enum STATE {STATIC, DYNAMIC}
  55
  56         public final STATE state;
  57         public final long timeInMillis;
  58         public final InetSocketAddress address;
  59
  60         /**
  61          * Constructs a new instance of a host.
  62          *
  63          * @param address The current address:port
  64          * @param timeInMillis time last seen
  65          * @param state whether record was added through dynamic discovery
  66          */
  67         public LastSeenHost(InetSocketAddress address, long timeInMillis, STATE state) {
  68             this.address = address;
  69             this.timeInMillis = timeInMillis;
  70             this.state = state;
  71         }
  72
  73         /**
  74          * Construct a new instance of a dynamically announced host.
  75          *
  76          * @param host
  77          */
  78         public LastSeenHost(InetSocketAddress host) {
  79             this(host, System.currentTimeMillis(), STATE.DYNAMIC);
  80         }
  81
  82         /**
  83          * Construct a new instance of with user-defined STATE.
  84          *
  85          * @param host the host address
  86          * @param state DYNAMIC or STATIC
  87          */
  88         public LastSeenHost(InetSocketAddress host, STATE state) {
  89             this(host, System.currentTimeMillis(), state);
  90         }
  91         /**
  92          * Formatted string representation of InetAddress and timestamp.
  93          * @return the representation
  94          */
  95         @Override
  96         public String toString() {
  97             return MessageFormat.format("{0}:{1,number,integer}@{2}", this.address.getHostString(), this.address.getPort(), this.timeInMillis);
  98         }
  99     };
 100
 101     /**
 102      * The Logger to use.
 103      */
 104     private static Logger LOGGER = null;
 105
 106     /**
 107      * Facility name for logger
 108      */
 109     private String _facility = null;
 110
 111     /**
 112      * Construct a map with a Logger.
 113      *
 114      * @param facility The log facility to tag messages with
 115      * @param logger  The Logger
 116      */
 117     public ServiceAddressMap(String facility, Logger logger) {
 118         this._facility = facility;
 119         LOGGER = logger;
 120     }
 121
 122     /**
 123      * Log some message.
 124      * @param level
 125      * @param message
 126      */
 127     private void log(Level level, String message) {
 128         if (LOGGER == null)
 129             return;
 130         LOGGER.logp(level, _facility, null, message);
 131
 132     }
 133     /**
 134      * Remove stale service records.
 135      *
 136      * @param ageInMillis milliseconds since last seen to be considered stale
 137      * @return quantity of records removed
 138      */
 139     public ArrayList<String> cleanServiceAddressMap(long ageInMillis) {
 140         ArrayList<String> result = new ArrayList<>();
 141         long expireTime = System.currentTimeMillis() - ageInMillis;
 142         java.util.Enumeration<String> keys = this._serviceToAddressMap.keys();
 143         while (keys.hasMoreElements()) {
 144             String key = keys.nextElement();
 145             LastSeenHost host = _serviceToAddressMap.get(key);
 146             if (host != null && host.state == LastSeenHost.STATE.DYNAMIC) {
 147                 if (host.timeInMillis < expireTime) {
 148                     if (_serviceToAddressMap.remove(key, host)) {
 149                         result.add(key);
 150                         log(Level.INFO, MessageFormat.format("Removed \"{0}\" from service map", key));
 151                     }
 152                 }
 153             }
 154         }
 155         return result;
 156     }
 157
 158     /**
 159      * Ensure service is in the map of known hosts.
 160      * @param service the service name to check
 161      * @return true is the target service is known
 162      */
 163     protected boolean isServiceValid(String service) {
 164         return this._serviceToAddressMap.containsKey(service);
 165     }
 166
 167     /**
 168      * Get the current InetSocketAddress of a target.
 169      *
 170      * @param target name of the service
 171      * @return IP address and port of the service
 172      */
 173     public InetSocketAddress getServiceAddress(String target) {
 174         InetSocketAddress result = null;
 175
 176         if (target != null && target.length() > 0) {
 177             LastSeenHost host = this._serviceToAddressMap.get(target);
 178             if (host != null)
 179                 result = host.address;
 180         }
 181
 182         return result;
 183     }
 184
 185     /**
 186      * Add an entry to the known services list.
 187      * @param service Service name at this unique host IP address/port combination
 188      * @param host new host record
 189      * @return Host record previously associated with this service, or null if key didn't exist
 190      */
 191     public LastSeenHost put(String service, LastSeenHost host) {
 192         return this._serviceToAddressMap.put(service, host);
 193     }
 194
 195     /**
 196      * Get the host record associated with a service.
 197      * @param service Service name required
 198      * @return Host record associated with this service, or null if service isn't known
 199      */
 200     public LastSeenHost get(String service) {
 201         return this._serviceToAddressMap.get(service);
 202     }
 203
 204     /**
 205      *
 206      * @param service
 207      * @return
 208      */
 209     public boolean containsService(String service) {
 210         return this._serviceToAddressMap.containsKey(service);
 211     }
 212
 213     /**
 214      * Return a Set backed by the Map so it can be iterated over.
 215      * @return Set containing the Map key,value entries
 216      */
 217     public java.util.Set<java.util.Map.Entry<String, LastSeenHost>> getEntrySet() {
 218     return _serviceToAddressMap.entrySet();
 219
 220     }
 221 }