cadi/aaf/src/main/java/org/onap/aaf/cadi/aaf/v2_0/AbsAAFLocator.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.cadi.aaf.v2_0;
  23
  24 import java.net.URI;
  25 import java.net.URISyntaxException;
  26 import java.security.SecureRandom;
  27 import java.util.ArrayList;
  28 import java.util.Iterator;
  29 import java.util.LinkedList;
  30 import java.util.List;
  31 import java.util.NoSuchElementException;
  32
  33 import org.onap.aaf.cadi.Access;
  34 import org.onap.aaf.cadi.Access.Level;
  35 import org.onap.aaf.cadi.aaf.Defaults;
  36 import org.onap.aaf.cadi.Locator;
  37 import org.onap.aaf.cadi.LocatorException;
  38 import org.onap.aaf.cadi.config.Config;
  39 import org.onap.aaf.cadi.locator.PropertyLocator;
  40 import org.onap.aaf.cadi.routing.GreatCircle;
  41 import org.onap.aaf.misc.env.Trans;
  42 import org.onap.aaf.misc.env.util.Split;
  43
  44 import locate.v1_0.Endpoint;
  45
  46 public abstract class AbsAAFLocator<TRANS extends Trans> implements Locator<URI> {
  47     protected static final SecureRandom sr = new SecureRandom();
  48     private static LocatorCreator locatorCreator;
  49     protected final Access access;
  50
  51     protected final double latitude;
  52     protected final double longitude;
  53     protected List<EP> epList;
  54     protected final String name, version;
  55     private String pathInfo = null;
  56     private String query = null;
  57     private String fragment = null;
  58     private boolean additional = false;
  59     protected String myhostname;
  60     protected int myport;
  61     protected final String aaf_locator_host;
  62     protected final URI aaf_locator_uri;
  63     private long earliest;
  64     private final long refreshWait;
  65
  66
  67     public AbsAAFLocator(Access access, String name, final long refreshMin) throws LocatorException {
  68         aaf_locator_host = access.getProperty(Config.AAF_LOCATE_URL, null);
  69         if (aaf_locator_host==null) {
  70             aaf_locator_uri = null;
  71         } else {
  72             try {
  73                 aaf_locator_uri = new URI(aaf_locator_host);
  74             } catch (URISyntaxException e) {
  75                 throw new LocatorException(e);
  76             }
  77         }
  78
  79         epList = new LinkedList<>();
  80         refreshWait = refreshMin;
  81
  82         this.access = access;
  83         String lat = access.getProperty(Config.CADI_LATITUDE,null);
  84         String lng = access.getProperty(Config.CADI_LONGITUDE,null);
  85         if (lat==null || lng==null) {
  86             throw new LocatorException(Config.CADI_LATITUDE + " and " + Config.CADI_LONGITUDE + " properties are required.");
  87         } else {
  88             latitude = Double.parseDouble(lat);
  89             longitude = Double.parseDouble(lng);
  90         }
  91         if (name.startsWith(Defaults.AAF_NS)) {
  92             String root_ns = access.getProperty(Config.AAF_ROOT_NS, null);
  93             if (root_ns!=null) {
  94                 name=name.replace(Defaults.AAF_NS, root_ns);
  95             }
  96         }
  97         if (name.startsWith("http")) { // simple URL
  98             this.name = name;
  99             this.version = Config.AAF_DEFAULT_VERSION;
 100         } else {
 101             String[] split = Split.split(':', name);
 102             this.name = split[0];
 103             this.version = (split.length > 1) ? split[1] : Config.AAF_DEFAULT_VERSION;
 104         }
 105
 106     }
 107
 108     /**
 109      * This is the way to setup specialized AAFLocators ahead of time.
 110      * @param preload
 111      */
 112     public static void setCreator(LocatorCreator lc) {
 113         locatorCreator = lc;
 114     }
 115
 116     public static Locator<URI> create(String key) throws LocatorException {
 117         String name = null;
 118         String version = Config.AAF_DEFAULT_VERSION;
 119         String pathInfo = null;
 120         int prev = key.indexOf("/locate");
 121         if (prev>0) {
 122             prev = key.indexOf('/',prev+6);
 123             if (prev>0) {
 124                 int next = key.indexOf('/',++prev);
 125                 if (next>0) {
 126                     name = key.substring(prev, next);
 127                     pathInfo=key.substring(next);
 128                 } else {
 129                     name = key.substring(prev);
 130                 }
 131                 String[] split = Split.split(':', name);
 132                 switch(split.length) {
 133                     case 3:
 134                     case 2:
 135                         version = split[1];
 136                         name = split[0];
 137                         break;
 138                     default:
 139                         break;
 140                 }
 141             }
 142         }
 143
 144         if (key.startsWith("http")) {
 145             if (name!=null) {
 146                 if (locatorCreator != null) {
 147                     AbsAAFLocator<?> aal = locatorCreator.create(name, version);
 148                     if (pathInfo!=null) {
 149                         aal.setPathInfo(pathInfo);
 150                     }
 151                     return aal;
 152                 }
 153             } else {
 154                 return new PropertyLocator(key);
 155             }
 156         }
 157         return null;
 158     }
 159
 160     public static Locator<URI> create(final String name, final String version) throws LocatorException {
 161         return locatorCreator.create(name, version);
 162     }
 163
 164     public interface LocatorCreator {
 165         public AbsAAFLocator<?> create(String key, String version) throws LocatorException;
 166         public void setSelf(String hostname, int port);
 167     }
 168
 169     protected static String nameFromLocatorURI(URI locatorURI) {
 170         String[] path = Split.split('/', locatorURI.getPath());
 171         if (path.length>2 && "locate".equals(path[1])) {
 172             return path[2];
 173         } else {
 174             return locatorURI.toString();
 175         }
 176     }
 177
 178     /**
 179      * Setting "self" excludes this service from the list.  Critical for contacting peers.
 180      */
 181     public void setSelf(final String hostname, final int port) {
 182         myhostname=hostname;
 183         myport=port;
 184     }
 185
 186
 187     public static void setCreatorSelf(final String hostname, final int port) {
 188         if (locatorCreator!=null) {
 189             locatorCreator.setSelf(hostname,port);
 190         }
 191     }
 192
 193     protected final synchronized void replace(List<EP> list) {
 194         epList = list;
 195     }
 196
 197     /**
 198      * Call _refresh as needed during calls, but actual refresh will not occur if there
 199      * are existing entities or if it has been called in the last 10 (settable) seconds.
 200      * Timed Refreshes happen by Scheduled Thread
 201      */
 202     private final boolean _refresh() {
 203         boolean rv = false;
 204         long now=System.currentTimeMillis();
 205         if (noEntries()) {
 206             if (earliest<now) {
 207                 synchronized(epList) {
 208                     rv = refresh();
 209                     earliest = now + refreshWait; // call only up to 10 seconds.
 210                 }
 211             } else {
 212                 access.log(Level.ERROR, "Must wait at least " + refreshWait/1000 + " seconds for Locator Refresh");
 213             }
 214         }
 215         return rv;
 216     }
 217
 218     private boolean noEntries() {
 219         return epList.isEmpty();
 220     }
 221
 222     @Override
 223     public URI get(Item item) throws LocatorException {
 224         if (item==null) {
 225             return null;
 226         } else if (item instanceof AAFLItem) {
 227             return getURI(((AAFLItem)item).uri);
 228         } else {
 229             throw new LocatorException(item.getClass().getName() + " does not belong to AAFLocator");
 230         }
 231     }
 232
 233     @Override
 234     public boolean hasItems() {
 235         boolean isEmpty = epList.isEmpty();
 236         if (!isEmpty) {
 237             for (Iterator<EP> iter = epList.iterator(); iter.hasNext(); ) {
 238                 EP ep = iter.next();
 239                 if (ep.valid) {
 240                     return true;
 241                 }
 242             }
 243             isEmpty = true;
 244         }
 245         if (_refresh()) { // is refreshed... check again
 246             isEmpty = epList.isEmpty();
 247         }
 248         return !isEmpty;
 249     }
 250
 251     @Override
 252     public void invalidate(Item item) throws LocatorException {
 253         if (item!=null) {
 254             if (item instanceof AAFLItem) {
 255                 AAFLItem ali =(AAFLItem)item;
 256                 EP ep = ali.ep;
 257                 synchronized(epList) {
 258                     epList.remove(ep);
 259                 }
 260                 ep.invalid();
 261                 ali.iter = getIterator(); // for next guy... fresh iterator
 262             } else {
 263                 throw new LocatorException(item.getClass().getName() + " does not belong to AAFLocator");
 264             }
 265         }
 266     }
 267
 268     @Override
 269     public Item best() throws LocatorException {
 270         if (!hasItems()) {
 271             throw new LocatorException("No Entries found for '" + aaf_locator_uri.toString() + "/locate/" + name + ':' + version + '\'');
 272         }
 273         List<EP> lep = new ArrayList<>();
 274         EP first = null;
 275         // Note: Deque is sorted on the way by closest distance
 276         Iterator<EP> iter = getIterator();
 277         EP ep;
 278         while (iter.hasNext()) {
 279             ep = iter.next();
 280             if (ep.valid) {
 281                 if (first==null) {
 282                     first = ep;
 283                     lep.add(first);
 284                 } else {
 285                     if (Math.abs(ep.distance-first.distance)<.1) { // allow for nearby/precision issues.
 286                         lep.add(ep);
 287                     } else {
 288                         break;
 289                     }
 290                 }
 291             }
 292         }
 293         switch(lep.size()) {
 294             case 0:
 295                 return null;
 296             case 1:
 297                 return new AAFLItem(iter,first);
 298             default:
 299                 int rand = sr.nextInt(); // Sonar chokes without.
 300                 int i = Math.abs(rand)%lep.size();
 301                 if (i<0) {
 302                     return null;
 303                 } else {
 304                     return new AAFLItem(iter,lep.get(i));
 305                 }
 306
 307         }
 308     }
 309
 310     private Iterator<EP> getIterator() {
 311         Object[] epa = epList.toArray();
 312         if (epa.length==0) {
 313             _refresh();
 314             epa = epList.toArray();
 315         }
 316         return new EPIterator(epa, epList);
 317     }
 318
 319     public class EPIterator implements Iterator<EP> {
 320         private final Object[] epa;
 321         private final List<EP> epList;
 322         private int idx;
 323
 324         public EPIterator(Object[] epa, List<EP> epList) {
 325             this.epa = epa;
 326             this.epList = epList;
 327             idx = epa.length>0?0:-1;
 328         }
 329
 330         @Override
 331         public boolean hasNext() {
 332             if (idx<0) {
 333                 return false;
 334             } else {
 335                 Object obj;
 336                 while (idx<epa.length) {
 337                     if ((obj=epa[idx])==null || !((EP)obj).valid) {
 338                         ++idx;
 339                         continue;
 340                     }
 341                     break;
 342                 }
 343                 return idx<epa.length;
 344             }
 345         }
 346
 347         @Override
 348         public EP next() {
 349             if (!hasNext() ) {
 350                 throw new NoSuchElementException();
 351             }
 352             return (EP)epa[idx++];
 353         }
 354
 355         @Override
 356         public void remove() {
 357             if (idx>=0 && idx<epa.length) {
 358                 synchronized(epList) {
 359                     epList.remove(epa[idx]);
 360                 }
 361             }
 362         }
 363     }
 364
 365     @Override
 366     public Item first()  {
 367         Iterator<EP> iter = getIterator();
 368         EP ep = AAFLItem.next(iter);
 369         if (ep==null) {
 370             return null;
 371         }
 372         return new AAFLItem(iter,ep);
 373     }
 374
 375     @Override
 376     public Item next(Item prev) throws LocatorException {
 377         if (prev==null) {
 378             StringBuilder sb = new StringBuilder("Locator Item passed in next(item) is null.");
 379             int lines = 0;
 380             for (StackTraceElement st : Thread.currentThread().getStackTrace()) {
 381                 sb.append("\n\t");
 382                 sb.append(st.toString());
 383                 if (++lines > 5) {
 384                     sb.append("\n\t...");
 385                     break;
 386                 }
 387             }
 388             access.log(Level.ERROR, sb);
 389         } else {
 390             if (prev instanceof AAFLItem) {
 391                 AAFLItem ali = (AAFLItem)prev;
 392                 EP ep = AAFLItem.next(ali.iter);
 393                 if (ep!=null) {
 394                     return new AAFLItem(ali.iter,ep);
 395                 }
 396             } else {
 397                 throw new LocatorException(prev.getClass().getName() + " does not belong to AAFLocator");
 398             }
 399         }
 400         return null;
 401     }
 402
 403     protected static class AAFLItem implements Item {
 404             private Iterator<EP> iter;
 405             private URI uri;
 406             private EP ep;
 407
 408             public AAFLItem(Iterator<EP> iter, EP ep) {
 409                 this.iter = iter;
 410                 this.ep = ep;
 411                 uri = ep.uri;
 412             }
 413
 414             private static EP next(Iterator<EP> iter) {
 415                 EP ep=null;
 416                 while (iter.hasNext() && (ep==null || !ep.valid)) {
 417                     ep = iter.next();
 418                 }
 419                 return ep;
 420             }
 421
 422             public String toString() {
 423                 return ep==null?"Locator Item Invalid":ep.toString();
 424             }
 425         }
 426
 427     protected static class EP implements Comparable<EP> {
 428         private URI uri;
 429         private final double distance;
 430         private boolean valid;
 431
 432         public EP(final Endpoint ep, double latitude, double longitude) throws URISyntaxException {
 433             uri = new URI(ep.getProtocol(),null,ep.getHostname(),ep.getPort(),null,null,null);
 434             distance = GreatCircle.calc(latitude, longitude, ep.getLatitude(), ep.getLongitude());
 435             valid = true;
 436         }
 437
 438         public void invalid() {
 439             valid = false;
 440         }
 441
 442         @Override
 443         public int compareTo(EP o) {
 444             if (distance<o.distance) {
 445                 return -1;
 446             } else if (distance>o.distance) {
 447                 return 1;
 448             } else {
 449                 return 0;
 450             }
 451         }
 452
 453         @Override
 454         public String toString() {
 455             return distance + ": " + uri + (valid?" valid":" invalidate");
 456         }
 457     }
 458
 459     /* (non-Javadoc)
 460      * @see org.onap.aaf.cadi.Locator#destroy()
 461      */
 462     @Override
 463     public void destroy() {
 464         // Nothing to do
 465     }
 466
 467     @Override
 468     public String toString() {
 469         return "AAFLocator for " + name + " on " + getURI();
 470     }
 471
 472     public AbsAAFLocator<TRANS> setPathInfo(String pathInfo) {
 473         this.pathInfo = pathInfo;
 474         additional=true;
 475         return this;
 476     }
 477
 478     public AbsAAFLocator<TRANS> setQuery(String query) {
 479         this.query = query;
 480         additional=true;
 481         return this;
 482     }
 483
 484     public AbsAAFLocator<TRANS>  setFragment(String fragment) {
 485         this.fragment = fragment;
 486         additional=true;
 487         return this;
 488     }
 489
 490     // Core URI, for reporting purposes
 491     protected abstract URI getURI();
 492
 493     protected URI getURI(URI rv) throws LocatorException {
 494         if (additional) {
 495             try {
 496                 return new URI(rv.getScheme(),rv.getUserInfo(),rv.getHost(),rv.getPort(),pathInfo,query,fragment);
 497             } catch (URISyntaxException e) {
 498                 throw new LocatorException("Error copying URL", e);
 499             }
 500         }
 501         return rv;
 502     }
 503
 504
 505 }