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         final STATE state;
  57         final long timeInMillis;
  58         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         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         LastSeenHost(InetSocketAddress host) {
  79             this(host, System.currentTimeMillis(), STATE.DYNAMIC);
  80         }
  81
  82         /**
  83          * Formatted string representation of InetAddress and timestamp.
  84          * @return the representation
  85          */
  86         @Override
  87         public String toString() {
  88             return MessageFormat.format("{0}:{1,number,integer}@{2}", this.address.getHostString(), this.address.getPort(), this.timeInMillis);
  89         }
  90     };
  91
  92     /**
  93      * The Logger to use.
  94      */
  95     private static Logger LOGGER = null;
  96
  97     /**
  98      * Facility name for logger
  99      */
 100     private String _facility = null;
 101
 102     /**
 103      * Construct a map with a Logger.
 104      *
 105      * @param facility The log facility to tag messages with
 106      * @param logger  The Logger
 107      */
 108     public ServiceAddressMap(String facility, Logger logger) {
 109         this._facility = facility;
 110         LOGGER = logger;
 111     }
 112
 113     /**
 114      * Log some message.
 115      * @param level
 116      * @param message
 117      */
 118     private void log(Level level, String message) {
 119         if (LOGGER == null)
 120             return;
 121         LOGGER.logp(level, _facility, null, message);
 122
 123     }
 124     /**
 125      * Remove stale service records.
 126      *
 127      * @param ageInMillis milliseconds since last seen to be considered stale
 128      * @return quantity of records removed
 129      */
 130     public ArrayList<String> cleanServiceAddressMap(long ageInMillis) {
 131         ArrayList<String> result = new ArrayList<>();
 132         long expireTime = System.currentTimeMillis() - ageInMillis;
 133         java.util.Enumeration<String> keys = this._serviceToAddressMap.keys();
 134         while (keys.hasMoreElements()) {
 135             String key = keys.nextElement();
 136
 137             // XXX: special handling for "all" target - never remove it
 138             LastSeenHost host = _serviceToAddressMap.get(key);
 139             if (host != null && host.state == LastSeenHost.STATE.DYNAMIC) {
 140                 if (host.timeInMillis < expireTime) {
 141                     if (_serviceToAddressMap.remove(key, host)) {
 142                         result.add(key);
 143                         log(Level.INFO, MessageFormat.format("Removed \"{0}\" from service map", key));
 144                     }
 145                 }
 146             }
 147         }
 148         return result;
 149     }
 150
 151     /**
 152      * Ensure service is in the map of known hosts.
 153      * @param service the service name to check
 154      * @return true is the target service is known
 155      */
 156     protected boolean isServiceValid(String service) {
 157         return this._serviceToAddressMap.containsKey(service);
 158     }
 159
 160     /**
 161      * Get the current InetSocketAddress of a target.
 162      *
 163      * @param target name of the service
 164      * @return IP address and port of the service
 165      */
 166     public InetSocketAddress getServiceAddress(String target) {
 167         InetSocketAddress result = null;
 168
 169         if (target != null && target.length() > 0) {
 170             LastSeenHost host = this._serviceToAddressMap.get(target);
 171             if (host != null)
 172                 result = host.address;
 173         }
 174
 175         return result;
 176     }
 177
 178     public void put(String service, LastSeenHost host) {
 179         this._serviceToAddressMap.put(service, host);
 180     }
 181
 182     public LastSeenHost get(String service) {
 183         return this._serviceToAddressMap.get(service);
 184     }
 185 }