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