cadi/client/src/main/java/org/onap/aaf/cadi/locator/PropertyLocator.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.locator;
  23
  24 import java.io.IOException;
  25 import java.net.InetAddress;
  26 import java.net.InetSocketAddress;
  27 import java.net.Socket;
  28 import java.net.URI;
  29 import java.net.URISyntaxException;
  30 import java.net.UnknownHostException;
  31 import java.security.SecureRandom;
  32 import java.util.ArrayList;
  33 import java.util.List;
  34 import java.util.Timer;
  35 import java.util.TimerTask;
  36
  37 import org.onap.aaf.cadi.Locator;
  38 import org.onap.aaf.cadi.LocatorException;
  39 import org.onap.aaf.misc.env.util.Split;
  40
  41 public class PropertyLocator implements Locator<URI> {
  42         private final URI [] orig;
  43         private PLItem[] current;
  44         private int end;
  45         private final SecureRandom random;
  46         private URI[] resolved;
  47         private long lastRefreshed;
  48         private long minRefresh;
  49         private long backgroundRefresh;
  50
  51         public PropertyLocator(String locList) throws LocatorException {
  52                 this(locList,10000L, 1000*60*20L); // defaults, do not refresh more than once in 10 seconds, Refresh Locator every 20 mins.
  53         }
  54         /**
  55          * comma delimited root url list
  56          *
  57          * @param locList
  58          * @throws LocatorException
  59          */
  60         public PropertyLocator(String locList, long minRefreshMillis, long backgroundRefreshMillis) throws LocatorException {
  61                 minRefresh = minRefreshMillis;
  62                 backgroundRefresh = backgroundRefreshMillis;
  63                 lastRefreshed=0L;
  64                 if(locList==null) {
  65                         throw new LocatorException("No Location List given for PropertyLocator");
  66                 }
  67                 String[] locarray = Split.split(',',locList);
  68                 List<URI> uriList = new ArrayList<>();
  69
  70                 random = new SecureRandom();
  71
  72                 for(int i=0;i<locarray.length;++i) {
  73                         try {
  74                                 int range = locarray[i].indexOf(":[");
  75                                 if(range<0) {
  76                                         uriList.add(new URI(locarray[i]));
  77                                 } else {
  78                                         String mach_colon = locarray[i].substring(0, range+1);
  79                                         int dash = locarray[i].indexOf('-',range+2);
  80                                         int brac = locarray[i].indexOf(']',dash+1);
  81                                         int slash = locarray[i].indexOf('/',brac);
  82                                         int start = Integer.parseInt(locarray[i].substring(range+2, dash));
  83                                         int end = Integer.parseInt(locarray[i].substring(dash+1, brac));
  84                                         for(int port=start;port<=end;++port) {
  85                                                 uriList.add(new URI(mach_colon+port + (slash>=0?locarray[i].substring(slash):"")));
  86                                         }
  87                                 }
  88                         } catch (NumberFormatException nf) {
  89                                 throw new LocatorException("Invalid URI format: " + locarray[i]);
  90                         } catch (URISyntaxException e) {
  91                                 throw new LocatorException(e);
  92                         }
  93                 }
  94                 orig = new URI[uriList.size()];
  95                 uriList.toArray(orig);
  96
  97                 refresh();
  98                 new Timer("PropertyLocator Refresh Timer",true).scheduleAtFixedRate(new TimerTask() {
  99                         @Override
 100                         public void run() {
 101                                 refresh();
 102                         }
 103                 }, backgroundRefresh,backgroundRefresh);
 104         }
 105
 106         @Override
 107         public URI get(Item item) throws LocatorException {
 108                 synchronized(orig) {
 109                         if(item==null) {
 110                                 return null;
 111                         } else {
 112                                 return resolved[((PLItem)item).idx];
 113                         }
 114                 }
 115         }
 116
 117         @Override
 118         public Item first() throws LocatorException {
 119                 return end>0?current[0]:null;
 120         }
 121
 122         @Override
 123         public boolean hasItems() {
 124                 return end>0;
 125         }
 126
 127         @Override
 128         public Item next(Item item) throws LocatorException {
 129                 if(item==null) {
 130                         return null;
 131                 } else {
 132                         int spot;
 133                         if((spot=(((PLItem)item).order+1))>=end)return null;
 134                         return current[spot];
 135                 }
 136         }
 137
 138         @Override
 139         public synchronized void invalidate(Item item) throws LocatorException {
 140                 if(--end<0) {
 141                         refresh();
 142                         return;
 143                 }
 144                 if(item==null) {
 145                         return;
 146                 }
 147                 PLItem pli = (PLItem)item;
 148                 int i,order;
 149                 for(i=0;i<end;++i) {
 150                         if(pli==current[i])break;
 151                 }
 152                 order = current[i].order;
 153                 for(;i<end;++i) {
 154                         current[i]=current[i+1];
 155                         current[i].order=order++;
 156                 }
 157                 current[end]=pli;
 158         }
 159
 160         @Override
 161         public Item best() throws LocatorException {
 162                 if(current.length==0) {
 163                         refresh();
 164                 }
 165                 switch(current.length) {
 166                         case 0:
 167                                 return null;
 168                         case 1:
 169                                 return current[0];
 170                         default:
 171                                 int rand = random.nextInt(); // sonar driven syntax
 172                                 return current[Math.abs(rand)%current.length];
 173                 }
 174         }
 175
 176         @Override
 177         public synchronized boolean refresh() {
 178                 if(System.currentTimeMillis()>lastRefreshed) {
 179                         // Build up list
 180                         List<URI> resolve = new ArrayList<>();
 181                         String realname;
 182                         for(int i = 0; i < orig.length ; ++i) {
 183                                 try {
 184                                         InetAddress ia[] = InetAddress.getAllByName(orig[i].getHost());
 185
 186                                         URI o,n;
 187                                         for(int j=0;j<ia.length;++j) {
 188                                                 o = orig[i];
 189                                                 Socket socket = createSocket();
 190                                                 try {
 191                                                         realname=ia[j].getHostAddress().equals(ia[j].getHostName())?ia[j].getCanonicalHostName():ia[j].getHostName();
 192                                                         int port = o.getPort();
 193                                                         if(port<0) { // default
 194                                                                 port = "https".equalsIgnoreCase(o.getScheme())?443:80;
 195                                                         }
 196                                                         socket.connect(new InetSocketAddress(realname,port),3000);
 197                                                         try {
 198                                                                 if(socket.isConnected()) {
 199                                                                         n = new URI(
 200                                                                                         o.getScheme(),
 201                                                                                         o.getUserInfo(),
 202                                                                                         realname,
 203                                                                                         o.getPort(),
 204                                                                                         o.getPath(),
 205                                                                                         o.getQuery(),
 206                                                                                         o.getFragment()
 207                                                                                         );
 208                                                                         resolve.add(n);
 209                                                                 }
 210                                                         } finally {
 211                                                                 socket.close();
 212                                                         }
 213                                                 } catch (IOException e) {
 214                                                 } finally {
 215                                                         if(!socket.isClosed()) {
 216                                                                 try {
 217                                                                         socket.close();
 218                                                                 } catch (IOException e) {
 219                                                                         // nothing to do.
 220                                                                 }
 221                                                         }
 222                                                 }
 223                                         }
 224                                 } catch (UnknownHostException | URISyntaxException e) {
 225                                         // Note: Orig Name already known as valid, based on constructor
 226                                 }
 227                         }
 228                         end=resolve.size();
 229                         PLItem[] newCurrent;
 230                         if(current==null || current.length!=end) {
 231                                 newCurrent = new PLItem[end];
 232                         } else {
 233                                 newCurrent = current;
 234                         }
 235
 236                         for(int i=0; i< end; ++i) {
 237                                 if(newCurrent[i]==null){
 238                                         newCurrent[i]=new PLItem(i);
 239                                 } else {
 240                                         newCurrent[i].idx=newCurrent[i].order=i;
 241                                 }
 242                         }
 243                         synchronized(orig) {
 244                                 resolved = new URI[end];
 245                                 resolve.toArray(resolved);
 246                                 current = newCurrent;
 247                         }
 248                         lastRefreshed = System.currentTimeMillis()+minRefresh;
 249                         return !resolve.isEmpty();
 250                 } else {
 251                         return false;
 252                 }
 253         }
 254
 255         protected Socket createSocket() {
 256                 return new Socket();
 257         }
 258
 259         private class PLItem implements Item {
 260                 public int idx,order;
 261
 262                 public PLItem(int i) {
 263                         idx = order =i;
 264                 }
 265
 266                 public String toString() {
 267                         return "Item: " + idx + " order: " + order;
 268                 }
 269         }
 270
 271         public String toString() {
 272                 StringBuilder sb = new StringBuilder();
 273                 boolean first = true;
 274                 for(URI uri : orig) {
 275                         boolean isResolved=false;
 276                         if(uri!=null) {
 277                                 if(first) {
 278                                         first = false;
 279                                 } else {
 280                                         sb.append(", ");
 281                                 }
 282                                 sb.append(uri.toString());
 283                                 sb.append(" [");
 284                                 for(URI u2 : resolved) {
 285                                         if(uri.equals(u2)) {
 286                                                 isResolved = true;
 287                                                 break;
 288                                         }
 289                                 }
 290                                 sb.append(isResolved?"X]\n":" ]");
 291                         }
 292                 }
 293                 return sb.toString();
 294         }
 295
 296         public void destroy() {
 297         }
 298 }